diff --git a/LICENSE b/LICENSE deleted file mode 100644 index f91efc558e664c325c7a26ae68a179f86eead24d..0000000000000000000000000000000000000000 --- a/LICENSE +++ /dev/null @@ -1,178 +0,0 @@ - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - diff --git a/README_zh.md b/README_zh.md deleted file mode 100644 index 92a18a6b93c7746b0a6603e4c3365381d4d56f05..0000000000000000000000000000000000000000 --- a/README_zh.md +++ /dev/null @@ -1,95 +0,0 @@ -# **DeviceManager组件** - -## 简介 - -DeviceManager组件是OpenHarmony为开发者提供的一套分布式设备账号无关的认证组网接口。 - -其组成及依赖如下所示： - -![](figures/devicemanager_zh.png) - -## 目录 - -``` -foundation/distributedhardware/devicemanager -├── common -│   ├── log #log相关头文件存放目录 -│   └── utils #公共能力头文件存放目录 -├── interfaces -│   ├── inner_kits #内部接口头文件存放目录 -│   │   └── native_cpp #内部native接口及实现存放目录 -│   kits #外接口头文件存放目录 -│   └── js #外部JS接口及实现存放目录 -└── services - └── devicemanagerservice #devicemanagerservice服务实现核心代码 - ├── include - │   ├── authdemo #与设备认证相关头文件（非正式） - │   └── softbus #与软总线相关头文件 - └── src - ├── authdemo #设备认证功能示例代码（非正式） - └── softbus #通道建立及组网功能核心代码 -``` - -## 约束 - -- 开发语言：JS -- 适用于Hi3516DV300单板等OpenHarmony设备 - - -## 接口说明 - -当前版本设备管理服务不具备权限管理的能力。 - -以下模块的JS接口为非正式API，仅供分布式Demo应用使用，展示分布式能力，不排除对这些接口进行变更的可能性，后续版本将提供正式API。 - -参见 *ohos.distributedHardware.deviceManager.d.ts* - -| 原型 | 描述 | -| ------- | ---------- | -| createDeviceManager(bundleName: string, callback: AsyncCallback): void | 以异步方法获取DeviceManager实例 | -| release(): void | 释放DeviceManager实例 | -| getTrustedDeviceListSync(): Array | 获取信任设备列表 | -| authenticateDevice(deviceInfo: DeviceInfo): void | 设备认证 | -| on(type: 'authResult', callback: Callback<{ deviceId: string, status: number, reason: number }>): void | 订阅设备认证回调 | -| off(type: 'authResult', callback?: Callback<{ deviceId: string, status: number, reason: number }>): void | 取消订阅设备认证回调 | - - -### 示例如下： -``` -deviceManager.createDeviceManager(app.getInfo. appID, (err, data) => { - if (err) { - console.info(TAG + "createDeviceManager err:" + JSON.stringify(err)); - return; - } - console.info(TAG + "createDeviceManager success"); - dmClass = data; -} - -var deviceInfo ={ - "deviceId": "XXXXXXXX", - "deviceName": "", - deviceType: 0 -}； -dmClass.authenticateDevice(deviceInfo); -``` - -## 使用说明 - -当前版本是一个临时Demo认证方案，默认无法成功建立连接和PIN码认证，仅用于验证分布式能力，后续会提供正式的设备认证方案。 - -如果开发者感兴趣，可以通过修改代码来验证分布式能力。 - -**注：该方法存在一定安全风险，仅用于验证分布式能力。** -``` -devicemanager\services\devicemanagerservice\src\authdemo\hichain_adapter.cpp - -// PIN_CODE一般为随机6位数字字符串, 例如; -const std::string PIN_CODE = "123456"; - -// PORT为server端的监听端口号，随机端口范围一般为1024~65534, 例如 -const int32_t PORT = 10001; -``` - -## 相关仓 - -**device_manager** diff --git a/common/utils/include/single_instance.h b/common/include/ipc/ipc_def.h similarity index 45% rename from common/utils/include/single_instance.h rename to common/include/ipc/ipc_def.h index f149f90e7739d9b3ec7d83158d3804e77336cda7..e35af6f2ccafc1db919686bd203b154e27fd54c5 100644 --- a/common/utils/include/single_instance.h +++ b/common/include/ipc/ipc_def.h @@ -13,34 +13,44 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_SINGLE_INSTANCE_H -#define OHOS_DEVICE_MANAGER_SINGLE_INSTANCE_H +#ifndef DEVICE_MANAGER_IPC_DEF_H +#define DEVICE_MANAGER_IPC_DEF_H namespace OHOS { namespace DistributedHardware { -#define DECLARE_SINGLE_INSTANCE_BASE(className) \ -public: \ - static className & GetInstance(); \ -private: \ +#define DEVICE_MANAGER_SERVICE_NAME "dev_mgr_svc" +#define MAX_DM_IPC_LEN 4096 + +#define DECLARE_IPC_MODEL(className) \ +public: \ + className() = default; \ + virtual ~className() = default; \ +public: \ className(const className&) = delete; \ className& operator= (const className&) = delete; \ className(className&&) = delete; \ - className& operator= (className&&) = delete; \ - - -#define DECLARE_SINGLE_INSTANCE(className) \ - DECLARE_SINGLE_INSTANCE_BASE(className) \ -private: \ - className() = default; \ - ~className() = default; \ + className& operator= (className&&) = delete \ -#define IMPLEMENT_SINGLE_INSTANCE(className) \ -className & className::GetInstance() \ -{ \ - static auto instance = new className(); \ - return *instance; \ -} -}; // namespace DistributedHardware -}; // namespace OHOS +#define DECLARE_IPC_INTERFACE(className) \ + DECLARE_IPC_MODEL(className) -#endif // OHOS_DEVICE_MANAGER_SINGLE_INSTANCE_H \ No newline at end of file +enum IpcCmdID { + REGISTER_DEVICE_MANAGER_LISTENER = 0, + UNREGISTER_DEVICE_MANAGER_LISTENER, + GET_TRUST_DEVICE_LIST, + START_DEVICE_DISCOVER, + STOP_DEVICE_DISCOVER, + AUTHENTICATE_DEVICE, + CHECK_AUTHENTICATION, + SERVER_DEVICE_STATE_NOTIFY, + SERVER_DEVICE_FOUND, + SERVER_DISCOVER_FINISH, + SERVER_AUTH_RESULT, + SERVER_CHECK_AUTH_RESULT, + SERVER_GET_AUTHENTCATION_INFO, + SERVER_USER_AUTHORIZATION_OPERATION, + SERVER_DEVICEMANAGER_FA_NOTIFY, +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // DEVICE_MANAGER_IPC_DEF_H diff --git a/common/include/ipc/model/ipc_authenticate_device_req.h b/common/include/ipc/model/ipc_authenticate_device_req.h new file mode 100644 index 0000000000000000000000000000000000000000..f4f066b3f20642a2ec71be913384dd209d18f17a --- /dev/null +++ b/common/include/ipc/model/ipc_authenticate_device_req.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_AUTHENTICATE_DEVICE_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_AUTHENTICATE_DEVICE_REQ_H + +#include "ipc_req.h" + +#include "dm_device_info.h" +#include "dm_app_image_info.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcAuthenticateDeviceReq : public IpcReq { +DECLARE_IPC_MODEL(IpcAuthenticateDeviceReq); +public: + const DmDeviceInfo& GetDeviceInfo() const + { + return deviceInfo_; + } + + void SetDeviceInfo(const DmDeviceInfo &deviceInfo) + { + deviceInfo_ = deviceInfo; + } + + const DmAppImageInfo& GetAppImageInfo() const + { + return appImageInfo_; + } + + void SetAppImageInfo(const DmAppImageInfo &appImageInfo) + { + appImageInfo_ = appImageInfo; + } + + const std::string& GetExtra() const + { + return extra_; + } + + void SetExtra(std::string &extra) + { + extra_ = extra; + } +private: + DmDeviceInfo deviceInfo_; + DmAppImageInfo appImageInfo_; + std::string extra_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_AUTHENTICATE_DEVICE_REQ_H diff --git a/common/utils/include/device_manager_errno.h b/common/include/ipc/model/ipc_check_authenticate_req.h similarity index 53% rename from common/utils/include/device_manager_errno.h rename to common/include/ipc/model/ipc_check_authenticate_req.h index e2b8cf2c5b022bc6dbec037030a66ccdab667593..ea136b42103c505cd5ef3b802c5d264afcd94bc1 100644 --- a/common/utils/include/device_manager_errno.h +++ b/common/include/ipc/model/ipc_check_authenticate_req.h @@ -1,36 +1,40 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_ERRNO_H -#define OHOS_DEVICE_MANAGER_ERRNO_H -#include "errors.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - DISTRIBUTEDHARDWARE_MODULE_DEVICEMANAGER = 0x00 -}; - -// Error code for Common -constexpr ErrCode DEVICE_MANAGER_ERR_OFFSET = ErrCodeOffset(SUBSYS_DISTRIBUTEDHARDWARE, - DISTRIBUTEDHARDWARE_MODULE_DEVICEMANAGER); -enum { - ERR_DEVICEMANAGER_OPERATION_FAILED = DEVICE_MANAGER_ERR_OFFSET + 1, - ERR_DEVICEMANAGER_SERVICE_NOT_READY = DEVICE_MANAGER_ERR_OFFSET + 2, - ERR_DEVICEMANAGER_DEVICE_ALREADY_TRUSTED = DEVICE_MANAGER_ERR_OFFSET + 3, -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LOG_H +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CHECK_AUTHENTICATE_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_CHECK_AUTHENTICATE_REQ_H + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcCheckAuthenticateReq : public IpcReq { +DECLARE_IPC_MODEL(IpcCheckAuthenticateReq); +public: + const std::string& GetAuthPara() const + { + return authPara_; + } + + void SetAuthPara(std::string &authPara) + { + authPara_ = authPara; + } +private: + std::string authPara_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CHECK_AUTHENTICATE_REQ_H diff --git a/common/include/ipc/model/ipc_get_authenticationparam_rsp.h b/common/include/ipc/model/ipc_get_authenticationparam_rsp.h new file mode 100644 index 0000000000000000000000000000000000000000..b12c39f68c1c7f1b6e99b8da9a1bc53de1e30751 --- /dev/null +++ b/common/include/ipc/model/ipc_get_authenticationparam_rsp.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_GET_AUTH_PARAM_RSP_H +#define OHOS_DEVICE_MANAGER_IPC_GET_AUTH_PARAM_RSP_H + +#include "ipc_rsp.h" +#include "dm_device_info.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetAuthParamRsp : public IpcRsp { +DECLARE_IPC_MODEL(IpcGetAuthParamRsp); +public: + const DmAuthParam& GetAuthParam() const + { + return authParam_; + } + + void SetAuthParam(DmAuthParam &authParam) + { + authParam_ = authParam; + } +private: + DmAuthParam authParam_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_GET_AUTH_PARAM_RSP_H \ No newline at end of file diff --git a/common/include/ipc/model/ipc_get_trustdevice_req.h b/common/include/ipc/model/ipc_get_trustdevice_req.h new file mode 100644 index 0000000000000000000000000000000000000000..695d87186f2d9b7074bf830e450be09e08873d21 --- /dev/null +++ b/common/include/ipc/model/ipc_get_trustdevice_req.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_GET_TRUST_DEVICE_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_GET_TRUST_DEVICE_REQ_H + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetTrustdeviceReq : public IpcReq { +DECLARE_IPC_MODEL(IpcGetTrustdeviceReq); +public: + const std::string& GetExtra() const + { + return extra_; + } + + void SetExtra(std::string &extra) + { + extra_ = extra; + } +private: + std::string extra_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_GET_TRUST_DEVICE_REQ_H diff --git a/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp b/common/include/ipc/model/ipc_get_trustdevice_rsp.h similarity index 51% rename from interfaces/inner_kits/native_cpp/src/dm_device_info.cpp rename to common/include/ipc/model/ipc_get_trustdevice_rsp.h index b4a3bfa5ef805354bfa5449fdce490c2c26034f6..6df09e883003d1276d506e7839c437f1f1d3afd5 100644 --- a/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp +++ b/common/include/ipc/model/ipc_get_trustdevice_rsp.h @@ -1,50 +1,44 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "dm_device_info.h" - -namespace OHOS { -namespace DistributedHardware { -bool DmDeviceInfo::ReadFromParcel(Parcel &parcel) -{ - deviceId = parcel.ReadString(); - deviceName = parcel.ReadString(); - deviceTypeId = (DMDeviceType)parcel.ReadUint8(); - return true; -} - -DmDeviceInfo *DmDeviceInfo::Unmarshalling(Parcel &parcel) -{ - DmDeviceInfo *info = new (std::nothrow) DmDeviceInfo(); - if (info == nullptr) { - return nullptr; - } - - if (!info->ReadFromParcel(parcel)) { - delete info; - info = nullptr; - } - return info; -} - -bool DmDeviceInfo::Marshalling(Parcel &parcel) const -{ - parcel.WriteString(deviceId); - parcel.WriteString(deviceName); - parcel.WriteUint8((uint8_t)deviceTypeId); - return true; -} -} // namespace DistributedHardware -} // namespace OHOS +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_GET_TRUSTDEVICE_RSP_H +#define OHOS_DEVICE_MANAGER_IPC_GET_TRUSTDEVICE_RSP_H + +#include + +#include "dm_device_info.h" + +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetTrustdeviceRsp : public IpcRsp { +DECLARE_IPC_MODEL(IpcGetTrustdeviceRsp); +public: + std::vector GetDeviceVec() const + { + return deviceVec_; + } + + void SetDeviceVec(std::vector& deviceVec) + { + deviceVec_ = deviceVec; + } +private: + std::vector deviceVec_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_GET_TRUSTDEVICE_RSP_H diff --git a/common/include/ipc/model/ipc_notify_auth_result_req.h b/common/include/ipc/model/ipc_notify_auth_result_req.h new file mode 100644 index 0000000000000000000000000000000000000000..5fb8e53f78aca20315d93c35017763f2eb4122cb --- /dev/null +++ b/common/include/ipc/model/ipc_notify_auth_result_req.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H + +#include + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyAuthResultReq : public IpcReq { +DECLARE_IPC_MODEL(IpcNotifyAuthResultReq); +public: + std::string GetDeviceId() const + { + return deviceId_; + } + + void SetDeviceId(std::string& deviceId) + { + deviceId_ = deviceId; + } + + int32_t GetPinToken() const + { + return pinToken_; + } + + void SetPinToken(int32_t pinToken) + { + pinToken_ = pinToken; + } + + int32_t GetStatus() const + { + return status_; + } + + void SetStatus(int32_t status) + { + status_ = status; + } + + int32_t GetReason() const + { + return reason_; + } + + void SetReason(int32_t reason) + { + reason_ = reason; + } +private: + std::string deviceId_; + int32_t pinToken_; + int32_t status_; + int32_t reason_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H diff --git a/interfaces/inner_kits/native_cpp/include/dm_device_info.h b/common/include/ipc/model/ipc_notify_check_auth_result_req.h similarity index 44% rename from interfaces/inner_kits/native_cpp/include/dm_device_info.h rename to common/include/ipc/model/ipc_notify_check_auth_result_req.h index 58952222e00ee00790cf92a979cfccd44d9f3a7a..f98db1e21675349df0cecd13b21d8bd4ee7b84ac 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_device_info.h +++ b/common/include/ipc/model/ipc_notify_check_auth_result_req.h @@ -1,51 +1,64 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_DEVICE_INFO_H -#define OHOS_DEVICE_MANAGER_DEVICE_INFO_H - -#include "parcel.h" - -namespace OHOS { -namespace DistributedHardware { -enum DMDeviceType : uint8_t { - DEVICE_TYPE_UNKNOWN = 0x00, - DEVICE_TYPE_WIFI_CAMERA = 0x08, - DEVICE_TYPE_AUDIO = 0x0A, - DEVICE_TYPE_PC = 0x0C, - DEVICE_TYPE_PHONE = 0x0E, - DEVICE_TYPE_PAD = 0x11, - DEVICE_TYPE_WATCH = 0x6D, - DEVICE_TYPE_CAR = 0x83, - DEVICE_TYPE_TV = 0x9C, -}; - -enum DmDeviceState : uint8_t { - DEVICE_STATE_UNKNOWN = 0, - DEVICE_STATE_ONLINE = 1, - DEVICE_STATE_OFFLINE = 2, -}; - -struct DmDeviceInfo : public Parcelable { - std::string deviceId; - std::string deviceName; - DMDeviceType deviceTypeId; - bool ReadFromParcel(Parcel &parcel); - virtual bool Marshalling(Parcel &parcel) const override; - static DmDeviceInfo *Unmarshalling(Parcel &parcel); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_DEVICE_INFO_H +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H + +#include + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyCheckAuthResultReq : public IpcReq { +DECLARE_IPC_MODEL(IpcNotifyCheckAuthResultReq); +public: + std::string GetDeviceId() const + { + return deviceId_; + } + + void SetDeviceId(std::string& deviceId) + { + deviceId_ = deviceId; + } + + int32_t GetResult() const + { + return result_; + } + + void SetResult(int32_t result) + { + result_ = result; + } + + int32_t GetFlag() const + { + return flag_; + } + + void SetFlag(int32_t flag) + { + flag_ = flag; + } +private: + std::string deviceId_; + int32_t result_; + int32_t flag_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H diff --git a/common/include/ipc/model/ipc_notify_device_found_req.h b/common/include/ipc/model/ipc_notify_device_found_req.h new file mode 100644 index 0000000000000000000000000000000000000000..7ffb99d88876edb4efe90d1b4c59c1b84353eb62 --- /dev/null +++ b/common/include/ipc/model/ipc_notify_device_found_req.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_FOUND_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_FOUND_REQ_H + +#include "dm_device_info.h" + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyDeviceFoundReq : public IpcReq { +DECLARE_IPC_MODEL(IpcNotifyDeviceFoundReq); +public: + const DmDeviceInfo& GetDeviceInfo() const + { + return dmDeviceInfo_; + } + + void SetDeviceInfo(DmDeviceInfo& dmDeviceInfo) + { + dmDeviceInfo_ = dmDeviceInfo; + } + + uint16_t GetSubscribeId() const + { + return subscribeId_; + } + + void SetSubscribeId(uint16_t subscribeId) + { + subscribeId_ = subscribeId; + } +private: + uint16_t subscribeId_; + DmDeviceInfo dmDeviceInfo_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_FOUND_REQ_H diff --git a/common/include/ipc/model/ipc_notify_device_state_req.h b/common/include/ipc/model/ipc_notify_device_state_req.h new file mode 100644 index 0000000000000000000000000000000000000000..2ae13ea04e6b6fc1f2a3b3977323835ab64417b0 --- /dev/null +++ b/common/include/ipc/model/ipc_notify_device_state_req.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_STATE_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_STATE_REQ_H + +#include "dm_device_info.h" + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyDeviceStateReq : public IpcReq { +DECLARE_IPC_MODEL(IpcNotifyDeviceStateReq); +public: + int32_t GetDeviceState() const + { + return deviceState_; + } + + void SetDeviceState(int32_t deviceState) + { + deviceState_ = deviceState; + } + + const DmDeviceInfo& GetDeviceInfo() const + { + return dmDeviceInfo_; + } + + void SetDeviceInfo(DmDeviceInfo& dmDeviceInfo) + { + dmDeviceInfo_ = dmDeviceInfo; + } +private: + int32_t deviceState_; + DmDeviceInfo dmDeviceInfo_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_STATE_REQ_H diff --git a/common/include/ipc/model/ipc_notify_discover_result_req.h b/common/include/ipc/model/ipc_notify_discover_result_req.h new file mode 100644 index 0000000000000000000000000000000000000000..00ea2e5d84d3eeb3fd536193d1a897809651f087 --- /dev/null +++ b/common/include/ipc/model/ipc_notify_discover_result_req.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_NOTIFY_DISCOVER_RESULT_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_DISCOVER_RESULT_REQ_H + +#include + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyDiscoverResultReq : public IpcReq { +DECLARE_IPC_MODEL(IpcNotifyDiscoverResultReq); +public: + uint16_t GetSubscribeId() const + { + return subscribeId_; + } + + void SetSubscribeId(uint16_t subscribeId) + { + subscribeId_ = subscribeId; + } + + int32_t GetResult() const + { + return result_; + } + + void SetResult(int32_t result) + { + result_ = result; + } +private: + uint16_t subscribeId_; + int32_t result_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DISCOVER_RESULT_REQ_H diff --git a/common/include/ipc/model/ipc_notify_dmfa_result_req.h b/common/include/ipc/model/ipc_notify_dmfa_result_req.h new file mode 100644 index 0000000000000000000000000000000000000000..adbcf86cdbc2d912e122a66f2e3f9ade0e690621 --- /dev/null +++ b/common/include/ipc/model/ipc_notify_dmfa_result_req.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_NOTIFY_DMFA_RESULT_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_DMFA_RESULT_REQ_H + +#include + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcNotifyDMFAResultReq : public IpcReq { +DECLARE_IPC_MODEL(IpcNotifyDMFAResultReq); +public: + std::string GetPkgName() const + { + return PackageName_; + } + + void SetPkgName(std::string& pkgName) + { + PackageName_ = pkgName; + } + + std::string GetJsonParam() const + { + return JsonParam_; + } + + void SetJsonParam(std::string& JsonParam) + { + JsonParam_ = JsonParam; + } + + +private: + std::string PackageName_; + std::string JsonParam_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H diff --git a/common/log/include/device_manager_log.h b/common/include/ipc/model/ipc_register_listener_req.h similarity index 45% rename from common/log/include/device_manager_log.h rename to common/include/ipc/model/ipc_register_listener_req.h index 2350623f204f22fd53ea2dc3d10291e802ed8195..67690a5b8985ff94ad03a15e0aef22c5f1606115 100644 --- a/common/log/include/device_manager_log.h +++ b/common/include/ipc/model/ipc_register_listener_req.h @@ -1,54 +1,62 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_LOG_H -#define OHOS_DEVICE_MANAGER_LOG_H -#include "hilog/log.h" - -namespace OHOS { -namespace DistributedHardware { -static constexpr OHOS::HiviewDFX::HiLogLabel DM_LABEL = {LOG_CORE, LOG_DOMAIN, DH_LOG_TAG}; - -#define PRINT_LOG(Level, fmt, ...) \ - OHOS::HiviewDFX::HiLog::Level(DM_LABEL, "[%{public}s] " fmt, __FUNCTION__, ##__VA_ARGS__) - -#ifdef HILOGD -#undef HILOGD -#endif - -#ifdef HILOGI -#undef HILOGI -#endif - -#ifdef HILOGW -#undef HILOGW -#endif - -#ifdef HILOGE -#undef HILOGE -#endif - -#ifdef HILOGF -#undef HILOGF -#endif - -#define HILOGD(fmt, ...) PRINT_LOG(Debug, fmt, ##__VA_ARGS__) -#define HILOGI(fmt, ...) PRINT_LOG(Info, fmt, ##__VA_ARGS__) -#define HILOGW(fmt, ...) PRINT_LOG(Warn, fmt, ##__VA_ARGS__) -#define HILOGE(fmt, ...) PRINT_LOG(Error, fmt, ##__VA_ARGS__) -#define HILOGF(fmt, ...) PRINT_LOG(Fatal, fmt, ##__VA_ARGS__) -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LOG_H +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_REGISTER_LISTENER_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_REGISTER_LISTENER_REQ_H + +#include "ipc_req.h" + +#ifdef LITE_DEVICE +#include "liteipc_adapter.h" +#else +#include "iremote_stub.h" +#endif + +namespace OHOS { +namespace DistributedHardware { +class IpcRegisterListenerReq : public IpcReq { +DECLARE_IPC_MODEL(IpcRegisterListenerReq); +public: +#ifdef LITE_DEVICE + SvcIdentity GetSvcIdentity() const + { + return svcIdentity_; + } + + void SetSvcIdentity(SvcIdentity svcIdentity) + { + svcIdentity_ = svcIdentity; + } +#else + sptr GetListener() const + { + return listener_; + } + + void SetListener(sptr listener) + { + listener_ = listener; + } +#endif +private: +#ifdef LITE_DEVICE + SvcIdentity svcIdentity_; +#else + sptr listener_; +#endif +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_REGISTER_LISTENER_REQ_H diff --git a/common/include/ipc/model/ipc_req.h b/common/include/ipc/model/ipc_req.h new file mode 100644 index 0000000000000000000000000000000000000000..ac6e99d80dc009ca69191f95deaa9f8a360c9067 --- /dev/null +++ b/common/include/ipc/model/ipc_req.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_REQ_H + +#include + +#include "ipc_def.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcReq { +DECLARE_IPC_MODEL(IpcReq); +public: + const std::string& GetPkgName() const + { + return pkgName_; + } + + void SetPkgName(std::string &pkgName) + { + pkgName_ = pkgName; + } +private: + std::string pkgName_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_REQ_H diff --git a/common/include/ipc/model/ipc_rsp.h b/common/include/ipc/model/ipc_rsp.h new file mode 100644 index 0000000000000000000000000000000000000000..14394280be0cfa596b6d903c9249b5c35af8d6b9 --- /dev/null +++ b/common/include/ipc/model/ipc_rsp.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_RSP_H +#define OHOS_DEVICE_MANAGER_IPC_RSP_H + +#include + +#include "ipc_def.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcRsp { +DECLARE_IPC_MODEL(IpcRsp); +public: + int32_t GetErrCode() const + { + return errCode_; + } + + void SetErrCode(int32_t errCode) + { + errCode_ = errCode; + } +private: + int32_t errCode_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_RSP_H diff --git a/common/include/ipc/model/ipc_set_useroperation_req.h b/common/include/ipc/model/ipc_set_useroperation_req.h new file mode 100644 index 0000000000000000000000000000000000000000..7c7416955c0ea578d5aecad18a3cbcf4094a8446 --- /dev/null +++ b/common/include/ipc/model/ipc_set_useroperation_req.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_GET_USER_OPERATION_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_GET_USER_OPERATION_REQ_H +#include "ipc_req.h" +#include "dm_device_info.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetOperationReq : public IpcReq { +DECLARE_IPC_MODEL(IpcGetOperationReq); +public: + int32_t GetOperation() const + { + return action_; + } + + void SetOperation(int32_t action) + { + action_ = action; + } + +private: + int32_t action_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_GET_USER_OPERATION_REQ_H diff --git a/common/include/ipc/model/ipc_start_discovery_req.h b/common/include/ipc/model/ipc_start_discovery_req.h new file mode 100644 index 0000000000000000000000000000000000000000..341641e61ca71525da598fcca5f45c0c726c6f26 --- /dev/null +++ b/common/include/ipc/model/ipc_start_discovery_req.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_START_DISCOVERY_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_START_DISCOVERY_REQ_H + +#include "ipc_req.h" + +#include "dm_subscribe_info.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcStartDiscoveryReq : public IpcReq { +DECLARE_IPC_MODEL(IpcStartDiscoveryReq); +public: + const DmSubscribeInfo& GetSubscribeInfo() const + { + return subscribeInfo_; + } + + void SetSubscribeInfo(DmSubscribeInfo &subscribeInfo) + { + subscribeInfo_ = subscribeInfo; + } +private: + DmSubscribeInfo subscribeInfo_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_START_DISCOVERY_REQ_H diff --git a/common/include/ipc/model/ipc_stop_discovery_req.h b/common/include/ipc/model/ipc_stop_discovery_req.h new file mode 100644 index 0000000000000000000000000000000000000000..3497ec6f386e478f0ad5005edcc89b8a557fc207 --- /dev/null +++ b/common/include/ipc/model/ipc_stop_discovery_req.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_STOP_DISCOVERY_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_STOP_DISCOVERY_REQ_H + +#include + +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcStopDiscoveryReq : public IpcReq { +DECLARE_IPC_MODEL(IpcStopDiscoveryReq); +public: + uint16_t GetSubscribeId() const + { + return subscribeId_; + } + + void SetSubscribeId(uint16_t subscribeId) + { + subscribeId_ = subscribeId; + } +private: + uint16_t subscribeId_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_STOP_DISCOVERY_REQ_H diff --git a/devicemanager.gni b/devicemanager.gni deleted file mode 100644 index 179cd60277a697394866c534b784090fdea8d1a8..0000000000000000000000000000000000000000 --- a/devicemanager.gni +++ /dev/null @@ -1,22 +0,0 @@ -# Copyright (c) 2021 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. - - -devicemanager_path = "//foundation/distributedhardware/devicemanager" - -common_path = "${devicemanager_path}/common" - -services_path = "${devicemanager_path}/services" - -innerkits_path = "${devicemanager_path}/interfaces/inner_kits" - diff --git a/figures/devicemanager_zh.png b/figures/devicemanager_zh.png deleted file mode 100644 index 0891790acd1fd75f448e04c0d98ea9fd02e1639a..0000000000000000000000000000000000000000 Binary files a/figures/devicemanager_zh.png and /dev/null differ diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn deleted file mode 100644 index dde1bdd959ed21ed3cd57796737a713ae82ed192..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/BUILD.gn +++ /dev/null @@ -1,80 +0,0 @@ -# Copyright (C) 2021 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. - -import("//build/ohos.gni") -import("//foundation/distributedhardware/devicemanager/devicemanager.gni") - -config("dmnativeinnerkit_config") { - visibility = [ ":*" ] - include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", - "include", - "${common_path}/log/include", - "${common_path}/utils/include", - ] - - cflags = [ - "-Wall", - "-Werror", - "-Wdate-time", - "-Wfloat-equal", - "-Wshadow", - "-Wformat=2", - "-fdata-sections", - "-ffunction-sections", - "-Os", - ] - - cflags_cc = [ - "-Os", - ] -} - -config("dmnativeinnerkit_public_config") { - include_dirs = [ "include" ] -} - -ohos_shared_library("devicemanagersdk") { - sources = [ - "src/device_manager_proxy.cpp", - "src/device_manager_listener_stub.cpp", - "src/device_manager.cpp", - "src/dm_device_info.cpp", - "src/dm_subscribe_info.cpp", - ] - - configs = [ ":dmnativeinnerkit_config" ] - - public_configs = [ ":dmnativeinnerkit_public_config" ] - - deps = [ "//utils/native/base:utils" ] - - defines = [ - "DH_LOG_TAG=\"devicemanagerkit\"", - "LOG_DOMAIN=0xD004100", - ] - - external_deps = [ - "appexecfwk_standard:appexecfwk_base", - "appexecfwk_standard:appexecfwk_core", - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", - ] - - subsystem_name = "distributedhardware" - - part_name = "device_manager_base" -} diff --git a/interfaces/inner_kits/native_cpp/include/device_manager.h b/interfaces/inner_kits/native_cpp/include/device_manager.h deleted file mode 100644 index a21f8a14cc1a9f044f34463eb71286078eff38ca..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/include/device_manager.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_H -#define OHOS_DEVICE_MANAGER_H -#include "iremote_object.h" - -#include - -#include "device_manager_callback.h" -#include "device_manager_listener_stub.h" -#include "idevice_manager.h" -#include "single_instance.h" -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -class DmDeathRecipient : public IRemoteObject::DeathRecipient { -public: - void OnRemoteDied(const wptr& remote) override; - DmDeathRecipient() = default; - ~DmDeathRecipient() = default; -}; - -class DeviceManager { -friend class DmDeathRecipient; -DECLARE_SINGLE_INSTANCE(DeviceManager); -public: - int32_t InitDeviceManager(std::string &packageName, std::shared_ptr dmInitCallback); - int32_t UnInitDeviceManager(std::string &packageName); - int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList); - int32_t RegisterDevStateCallback(std::string &packageName, std::string &extra, - std::shared_ptr callback); - int32_t UnRegisterDevStateCallback(std::string &packageName); - int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback); - int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId); - int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra, - std::shared_ptr callback); - -private: - int32_t InitDeviceManagerService(); - bool IsInit(std::string &packageName); - -private: - std::mutex lock_; - sptr dmInterface_; - sptr dmRecipient_; - std::map> dmListener_; - std::map> dmInitCallback_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h b/interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h deleted file mode 100644 index 600b964575af8e639f287c85b9594277884ca08f..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_LISTENER_STUB_H -#define OHOS_DEVICE_MANAGER_LISTENER_STUB_H - -#include -#include "iremote_stub.h" -#include "idevice_manager_listener.h" - -#include "device_manager_callback.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerListenerStub : public IRemoteStub { -public: - DeviceManagerListenerStub(); - ~DeviceManagerListenerStub(); - int32_t OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel &reply, MessageOption &option) override; - int32_t OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceFound(std::string &packageName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo) override; - int32_t OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, int32_t failedReason) override; - int32_t OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) override; - int32_t OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, int32_t reason) override; - void AddDeviceStateCallback(std::shared_ptr callback); - void RemoveDeviceStateCallback(); - void AddDiscoverCallback(uint16_t subscribeId, std::shared_ptr callback); - void RemoveDiscoverCallback(uint16_t subscribeId); - void AddAuthenticateCallback(std::string deviceId, std::shared_ptr callback); - -private: - template - int32_t GetParcelableInfo(MessageParcel &reply, T &parcelableInfo); - int32_t OnDeviceOnlineInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDeviceOfflineInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDeviceChangedInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDeviceFoundInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDiscoverFailedInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDiscoverySuccessInner(MessageParcel &data, MessageParcel &reply); - int32_t OnAuthResultInner(MessageParcel &data, MessageParcel &reply); - - using ListenerFunc = int32_t (DeviceManagerListenerStub::*)(MessageParcel& data, MessageParcel& reply); - std::map memberFuncMap_; - std::shared_ptr deviceStateCallback_; - std::map> deviceDiscoverCallbacks_; - std::map> authenticateCallback_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LISTENER_STUB_H diff --git a/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h b/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h deleted file mode 100644 index 2a6f982ee9ebf9ffad92065be0845c69ad5bc9e2..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H -#define OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H - -#include "parcel.h" - -namespace OHOS { -namespace DistributedHardware { -enum DmDiscoverMode : int32_t { - /* Passive */ - DISCOVER_MODE_PASSIVE = 0x55, - /* Proactive */ - DISCOVER_MODE_ACTIVE = 0xAA -}; - -enum DmExchangeMedium : int32_t { - /** Automatic medium selection */ - AUTO = 0, - /** Bluetooth */ - BLE = 1, - /** Wi-Fi */ - COAP = 2, - /** USB */ - USB = 3, - MEDIUM_BUTT -}; - -/** - * @brief Enumerates frequencies for publishing services. - * - * This enumeration applies only to Bluetooth and is not supported currently. - */ -enum DmExchangeFreq : int32_t { - /** Low */ - LOW = 0, - /** Medium */ - MID = 1, - /** High */ - HIGH = 2, - /** Super-high */ - SUPER_HIGH = 3, - FREQ_BUTT -}; - -const std::string DM_CAPABILITY_DDMP = "ddmpCapability"; - -struct DmSubscribeInfo : public Parcelable { - /** Service ID */ - uint16_t subscribeId; - /** Discovery mode for service subscription. For details, see {@link DmDiscoverMode}. */ - DmDiscoverMode mode; - /** Service subscription medium. For details, see {@link DmExchangeMedium}. */ - DmExchangeMedium medium; - /** Service subscription frequency. For details, see {@link DmExchangeFreq}. */ - DmExchangeFreq freq; - /** only find the device with the same account */ - bool isSameAccount; - /** find the sleeping devices */ - bool isWakeRemote; - /** Service subscription capability. */ - std::string capability; - bool ReadFromParcel(Parcel &parcel); - virtual bool Marshalling(Parcel &parcel) const override; - static DmSubscribeInfo *Unmarshalling(Parcel &parcel); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H diff --git a/interfaces/inner_kits/native_cpp/include/idevice_manager.h b/interfaces/inner_kits/native_cpp/include/idevice_manager.h deleted file mode 100644 index b7123500010b8ef2949aea22282a9a0fadd45724..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/include/idevice_manager.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_INTERFACE_H -#define OHOS_DEVICE_MANAGER_INTERFACE_H - -#include "iremote_broker.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - REGISTER_DEVICE_MANAGER_LISTENER = 0, - UNREGISTER_DEVICE_MANAGER_LISTENER = 1, - REGISTER_DEVICE_STATE_CALLBACK = 2, - UNREGISTER_DEVICE_STATE_CALLBACK = 3, - GET_TRUST_DEVICE_LIST = 4, - START_DEVICE_DISCOVER = 5, - STOP_DEVICE_DISCOVER = 6, - AUTHENTICATE_DEVICE = 7, -}; - -class IDeviceManager : public OHOS::IRemoteBroker { -public: - virtual ~IDeviceManager() {} - virtual int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) = 0; - virtual int32_t RegisterDeviceManagerListener(std::string &packageName, sptr listener) = 0; - virtual int32_t UnRegisterDeviceManagerListener(std::string &packageName) = 0; - virtual int32_t RegisterDeviceStateCallback(std::string &packageName, std::string &extra) = 0; - virtual int32_t UnRegisterDeviceStateCallback(std::string &packageName) = 0; - virtual int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) = 0; - virtual int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) = 0; - virtual int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, - std::string &extra) = 0; - -public: - DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.devicemanager"); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_INTERFACE_H diff --git a/interfaces/kits/js/include/dm_native_event.h b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h similarity index 48% rename from interfaces/kits/js/include/dm_native_event.h rename to interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h index dcffbd1d32b0115d2fbedcc0d1f434ec057fa60f..818746ff706afecb07f5aa8e9252cb2c72d21351 100644 --- a/interfaces/kits/js/include/dm_native_event.h +++ b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h @@ -13,32 +13,25 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_NATIVE_EVENT_H -#define OHOS_DEVICE_MANAGER_NATIVE_EVENT_H +#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_H -#include -#include +#include #include -#include "napi/native_api.h" +#include -struct DmEventListener { - std::string eventType; - napi_ref handlerRef = nullptr; -}; +#include "ipc_req.h" +#include "ipc_rsp.h" -class DmNativeEvent { +namespace OHOS { +namespace DistributedHardware { +class IpcClient { +DECLARE_IPC_INTERFACE(IpcClient); public: - DmNativeEvent(napi_env env, napi_value thisVar); - virtual ~DmNativeEvent(); - - virtual void On(std::string &eventType, napi_value handler); - virtual void Off(std::string &eventType); - virtual void OnEvent(const std::string &eventType, size_t argc, const napi_value* argv); - -protected: - napi_env env_; - napi_ref thisVarRef_; - std::map> eventMap_; + virtual int32_t Init(std::string &pkgName) = 0; + virtual int32_t UnInit(std::string &pkgName) = 0; + virtual int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) = 0; }; - -#endif /* OHOS_DEVICE_MANAGER_NATIVE_EVENT_H */ \ No newline at end of file +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/ipc/ipc_client_proxy.h b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client_proxy.h new file mode 100644 index 0000000000000000000000000000000000000000..faa9e1a4b722295fb320e22574b84b00372308ed --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client_proxy.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_PROXY_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_PROXY_H + +#include +#include + +#include "ipc_client.h" +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcClientProxy : public IpcClient { +DECLARE_IPC_INTERFACE(IpcClientProxy); +public: + IpcClientProxy(std::shared_ptr ipcClientManager) : ipcClientManager_(ipcClientManager) {}; +public: + virtual int32_t Init(std::string &pkgName); + virtual int32_t UnInit(std::string &pkgName); + virtual int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); +private: + std::shared_ptr ipcClientManager_ {nullptr}; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_PROXY_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_manager.h b/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..997b5d39b8c9367682ae7c2583a83d544e74300b --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_manager.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H + +#include +#include +#include + +#include "ipc_client.h" +#include "ipc_client_server_proxy.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcClientManager : public IpcClient { +DECLARE_IPC_INTERFACE(IpcClientManager); +public: + virtual int32_t Init(std::string &pkgName) override; + virtual int32_t UnInit(std::string &pkgName) override; + virtual int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) override; +private: + bool IsInit(std::string &pkgName); +private: + IpcClientServerProxy serverProxy_; + std::set packageInitSet_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_server_proxy.h b/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_server_proxy.h new file mode 100644 index 0000000000000000000000000000000000000000..d7497c55c286c50527abfd7c47bb9d15174c6250 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_server_proxy.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H + +#include +#include +#include + +#include "iproxy_client.h" +#include "liteipc_adapter.h" +#include "samgr_lite.h" + +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcClientServerProxy { +public: + int32_t Init(); + int32_t SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); +private: + IClientProxy *GetServerProxy(void); + int32_t RegisterServerDeathCb(void); +private: + std::mutex lock_; + IClientProxy *serviceProxy_ {nullptr}; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H diff --git a/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_stub.h b/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_stub.h new file mode 100644 index 0000000000000000000000000000000000000000..672e4cb89448ed197a0fb7fac58e090c07f6ee17 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/lite/ipc_client_stub.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H + +#include +#include + +#include "liteipc_adapter.h" + +#include "single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcClientStub { +DECLARE_SINGLE_INSTANCE(IpcClientStub); +public: + int32_t Init(); + SvcIdentity GetSvcIdentity() const + { + return clientIdentity_; + } +private: + std::mutex lock_; + bool bInit {false}; + SvcIdentity clientIdentity_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H diff --git a/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_manager.h b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..422f297282afc35b65b94217e27c25acf0845426 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_manager.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H + +#include +#include +#include +#include + +#include "iremote_object.h" + +#include "ipc_client.h" +#include "ipc_client_stub.h" +#include "ipc_def.h" +#include "ipc_remote_broker.h" + +namespace OHOS { +namespace DistributedHardware { +class DmDeathRecipient : public IRemoteObject::DeathRecipient { +public: + void OnRemoteDied(const wptr &remote) override; + DmDeathRecipient() = default; + ~DmDeathRecipient() = default; +}; + +class IpcClientManager : public IpcClient { +friend class DmDeathRecipient; +DECLARE_IPC_INTERFACE(IpcClientManager); +public: + virtual int32_t Init(std::string &pkgName) override; + virtual int32_t UnInit(std::string &pkgName) override; + virtual int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) override; +private: + bool IsInit(std::string &pkgName); + int32_t ClientInit(); +private: + std::mutex lock_; + std::map> dmListener_; + sptr dmInterface_ {nullptr}; + sptr dmRecipient_ {nullptr}; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_server_proxy.h b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_server_proxy.h new file mode 100644 index 0000000000000000000000000000000000000000..3fd0586cd487e6a95ce9594aa1f5d371d7cf8358 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_server_proxy.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H + +#include +#include + +#include "iremote_proxy.h" +#include "ipc_remote_broker.h" +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcClientServerProxy : public IRemoteProxy { +public: + explicit IpcClientServerProxy(const sptr &impl) : IRemoteProxy(impl) {}; + ~IpcClientServerProxy() {}; + int32_t SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) override; +private: + static inline BrokerDelegator delegator_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H diff --git a/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_stub.h b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_stub.h new file mode 100644 index 0000000000000000000000000000000000000000..61633f6e8db4bcaeba23b3d3e0e14b663f0ea595 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_client_stub.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H +#define OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H + +#include +#include + +#include "iremote_stub.h" +#include "iremote_broker.h" + +#include "ipc_remote_broker.h" +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcClientStub : public IRemoteStub { +public: + IpcClientStub() {}; + ~IpcClientStub() {}; + int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override; + int32_t SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H diff --git a/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_remote_broker.h b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_remote_broker.h new file mode 100644 index 0000000000000000000000000000000000000000..b2b8618c7e2f32cfce0f7069e32f8dbdf3472ad1 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/ipc/standard/ipc_remote_broker.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_REMOTE_BROKER_H +#define OHOS_DEVICE_MANAGER_IPC_REMOTE_BROKER_H + +#include +#include + +#include "iremote_broker.h" + +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcRemoteBroker : public OHOS::IRemoteBroker { +public: + virtual ~IpcRemoteBroker() {} + virtual int32_t SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) = 0; +public: + DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.devicemanager"); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_REMOTE_BROKER_H diff --git a/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h b/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h new file mode 100644 index 0000000000000000000000000000000000000000..14dc0dcf6bba5a2559deb53ec1d6d55467a02f50 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_NOTIFY_H +#define OHOS_DEVICE_MANAGER_NOTIFY_H + +#include +#include +#include +#include + +#include "dm_device_info.h" +#include "dm_subscribe_info.h" +#include "device_manager_callback.h" +#include "single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +class DeviceManagerNotify { +DECLARE_SINGLE_INSTANCE(DeviceManagerNotify); +public: + void RegisterDeathRecipientCallback(std::string &pkgName, std::shared_ptr dmInitCallback); + void UnRegisterDeathRecipientCallback(std::string &pkgName); + void RegisterDeviceStateCallback(std::string &pkgName, std::shared_ptr callback); + void UnRegisterDeviceStateCallback(std::string &pkgName); + void RegisterDiscoverCallback(std::string &pkgName, uint16_t subscribeId, + std::shared_ptr callback); + void UnRegisterDiscoverCallback(std::string &pkgName, uint16_t subscribeId); + void RegisterAuthenticateCallback(std::string &pkgName, std::string &deviceId, + std::shared_ptr callback); + void UnRegisterAuthenticateCallback(std::string &pkgName, std::string &deviceId); + void UnRegisterPackageCallback(std::string &pkgName); + void RegisterCheckAuthenticationCallback(std::string &pkgName, std::string &authPara, + std::shared_ptr callback); + void UnRegisterCheckAuthenticationCallback(std::string &pkgName); + void RegisterDeviceManagerFaCallback(std::string &packageName, + std::shared_ptr callback); + void UnRegisterDeviceManagerFaCallback(std::string &pkgName); + +public: + void OnRemoteDied(); + void OnDeviceOnline(std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceOffline(std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceChanged(std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceFound(std::string &pkgName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo); + void OnDiscoverFailed(std::string &pkgName, uint16_t subscribeId, int32_t failedReason); + void OnDiscoverySuccess(std::string &pkgName, uint16_t subscribeId); + void OnAuthResult(std::string &pkgName, std::string &deviceId, int32_t pinToken, uint32_t status, + uint32_t reason); + void OnCheckAuthResult(std::string &pkgName, std::string &deviceId, int32_t resultCode, int32_t flag); + void OnFaCall(std::string &pkgName,std::string ¶mJson); +private: + std::mutex lock_; + std::map> deviceStateCallback_; + std::map>> deviceDiscoverCallbacks_; + std::map>> authenticateCallback_; + std::map>> checkauthcallback_; + std::map> dmInitCallback_; + std::map> dmFaCallback_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_NOTIFY_H diff --git a/interfaces/inner_kits/native_cpp/src/device_manager.cpp b/interfaces/inner_kits/native_cpp/src/device_manager.cpp deleted file mode 100644 index 65da53e98f2040c8c4597a72a539bb2c5f33155d..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/src/device_manager.cpp +++ /dev/null @@ -1,314 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_manager.h" - -#include "iservice_registry.h" -#include "system_ability_definition.h" - -#include "device_manager_errno.h" -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -IMPLEMENT_SINGLE_INSTANCE(DeviceManager); - -int32_t DeviceManager::InitDeviceManagerService() -{ - HILOGI("DeviceManager::InitDeviceManagerService start"); - if (dmInterface_ != nullptr) { - HILOGI("DeviceManagerService Already Init"); - return ERR_OK; - } - - auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); - if (samgr == nullptr) { - HILOGE("Get SystemAbilityManager Failed"); - return ERR_NO_INIT; - } - - auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID); - if (object == nullptr) { - HILOGE("Get DeviceManager SystemAbility Failed"); - return ERR_DEVICEMANAGER_SERVICE_NOT_READY; - } - - if (dmRecipient_ == nullptr) { - dmRecipient_ = sptr(new DmDeathRecipient()); - } - - if (!object->AddDeathRecipient(dmRecipient_)) { - HILOGE("InitDeviceManagerService: AddDeathRecipient Failed"); - } - - dmInterface_ = iface_cast(object); - HILOGI("DeviceManager::InitDeviceManagerService completed"); - return ERR_OK; -} - -bool DeviceManager::IsInit(std::string &packageName) -{ - if (dmInterface_ == nullptr) { - HILOGE("DeviceManager not Init"); - return false; - } - - if (dmListener_.find(packageName) == dmListener_.end()) { - HILOGE("dmListener_ not Init for %{public}s", packageName.c_str()); - return false; - } - return true; -} - -int32_t DeviceManager::InitDeviceManager(std::string &packageName, std::shared_ptr dmInitCallback) -{ - HILOGI("DeviceManager::InitDeviceManager start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty() || dmInitCallback == nullptr) { - HILOGE("InitDeviceManager error: Invalid parameter"); - return ERR_INVALID_VALUE; - } - - HILOGI("InitDeviceManager in, packageName %{public}s", packageName.c_str()); - std::lock_guard autoLock(lock_); - int32_t ret = InitDeviceManagerService(); - if (ret != ERR_OK) { - HILOGE("InitDeviceManager Failed with ret %{public}d", ret); - return ret; - } - - auto iter = dmListener_.find(packageName); - if (iter != dmListener_.end()) { - HILOGI("dmListener_ Already Init"); - dmInitCallback_[packageName] = dmInitCallback; - return ERR_OK; - } - - sptr listener = sptr(new DeviceManagerListenerStub()); - ret = dmInterface_->RegisterDeviceManagerListener(packageName, listener); - if (ret != ERR_OK) { - HILOGE("InitDeviceManager: RegisterDeviceManagerListener Failed with ret %{public}d", ret); - return ret; - } - - dmListener_[packageName] = listener; - dmInitCallback_[packageName] = dmInitCallback; - - HILOGI("DeviceManager::InitDeviceManager completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::UnInitDeviceManager(std::string &packageName) -{ - HILOGI("DeviceManager::UnInitDeviceManager start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("InitDeviceManager error: Invalid parameter"); - return ERR_INVALID_VALUE; - } - - HILOGI("UnInitDeviceManager in, packageName %{public}s", packageName.c_str()); - std::lock_guard autoLock(lock_); - if (dmInterface_ == nullptr) { - HILOGE("DeviceManager not Init"); - return ERR_NO_INIT; - } - - auto iter = dmListener_.find(packageName); - if (iter != dmListener_.end()) { - int32_t ret = dmInterface_->UnRegisterDeviceManagerListener(packageName); - if (ret != ERR_OK) { - HILOGE("UnInitDeviceManager: UnRegisterDeviceManagerListener Failed with ret %{public}d", ret); - return ret; - } - dmListener_.erase(packageName); - dmInitCallback_.erase(packageName); - } - - if (dmListener_.empty()) { - dmRecipient_ = nullptr; - dmInterface_ = nullptr; - } - HILOGI("DeviceManager::UnInitDeviceManager completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - HILOGI("DeviceManager::GetTrustedDeviceList start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("GetTrustedDeviceList in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->GetTrustedDeviceList(packageName, extra, deviceList); - if (ret != ERR_OK) { - HILOGE("RegisterDevStateCallback Failed with ret %{public}d", ret); - return ret; - } - HILOGI("DeviceManager::GetTrustedDeviceList completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::RegisterDevStateCallback(std::string &packageName, std::string &extra, - std::shared_ptr callback) -{ - HILOGI("DeviceManager::RegisterDevStateCallback start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty() || callback == nullptr) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("RegisterDevStateCallback in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->RegisterDeviceStateCallback(packageName, extra); - if (ret != ERR_OK) { - HILOGE("RegisterDevStateCallback Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->AddDeviceStateCallback(callback); - HILOGI("DeviceManager::RegisterDevStateCallback completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::UnRegisterDevStateCallback(std::string &packageName) -{ - HILOGI("DeviceManager::UnRegisterDevStateCallback start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("UnRegisterDevStateCallback in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->UnRegisterDeviceStateCallback(packageName); - if (ret != ERR_OK) { - HILOGE("UnRegisterDeviceStateCallback Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->RemoveDeviceStateCallback(); - HILOGI("DeviceManager::UnRegisterDevStateCallback completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback) -{ - HILOGI("DeviceManager::StartDeviceDiscovery start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty() || callback == nullptr) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("StartDeviceDiscovery in, packageName %{public}s", packageName.c_str()); - { - std::lock_guard autoLock(lock_); - dmListener_[packageName]->AddDiscoverCallback(subscribeInfo.subscribeId, callback); - } - int32_t ret = dmInterface_->StartDeviceDiscovery(packageName, subscribeInfo); - if (ret != ERR_OK) { - HILOGE("StartDeviceDiscovery Failed with ret %{public}d", ret); - return ret; - } - - HILOGI("DeviceManager::StartDeviceDiscovery completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) -{ - HILOGI("DeviceManager::StopDeviceDiscovery start , packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("StopDeviceDiscovery in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->StopDeviceDiscovery(packageName, subscribeId); - if (ret != ERR_OK) { - HILOGE("StopDeviceDiscovery Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->RemoveDiscoverCallback(subscribeId); - HILOGI("DeviceManager::StopDeviceDiscovery completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra, - std::shared_ptr callback) -{ - HILOGI("DeviceManager::AuthenticateDevice start , packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("AuthenticateDevice in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->AuthenticateDevice(packageName, deviceInfo, extra); - if (ret != ERR_OK) { - HILOGE("AuthenticateDevice Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->AddAuthenticateCallback(deviceInfo.deviceId, callback); - HILOGI("DeviceManager::AuthenticateDevice completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -void DmDeathRecipient::OnRemoteDied(const wptr& remote) -{ - (void)remote; - HILOGW("DmDeathRecipient : OnRemoteDied"); - for (auto iter : DeviceManager::GetInstance().dmInitCallback_) { - iter.second->OnRemoteDied(); - } -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp deleted file mode 100644 index e3fc817a76f52de3a8f5d89f9236ebd0b0b2098a..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp +++ /dev/null @@ -1,303 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_manager_listener_stub.h" - -#include "ipc_skeleton.h" -#include "ipc_types.h" - -#include "device_manager_log.h" - -using namespace std; - -namespace OHOS { -namespace DistributedHardware { -DeviceManagerListenerStub::DeviceManagerListenerStub() -{ - memberFuncMap_[ON_DEVICE_ONLINE] = &DeviceManagerListenerStub::OnDeviceOnlineInner; - memberFuncMap_[ON_DEVICE_OFFLINE] = &DeviceManagerListenerStub::OnDeviceOfflineInner; - memberFuncMap_[ON_DEVICE_CHANGE] = &DeviceManagerListenerStub::OnDeviceChangedInner; - memberFuncMap_[ON_DEVICE_FOUND] = &DeviceManagerListenerStub::OnDeviceFoundInner; - memberFuncMap_[ON_DISCOVER_SUCCESS] = &DeviceManagerListenerStub::OnDiscoverySuccessInner; - memberFuncMap_[ON_DISCOVER_FAILED] = &DeviceManagerListenerStub::OnDiscoverFailedInner; - memberFuncMap_[ON_AUTH_RESULT] = &DeviceManagerListenerStub::OnAuthResultInner; -} - -DeviceManagerListenerStub::~DeviceManagerListenerStub() -{ - memberFuncMap_.clear(); -} - -int32_t DeviceManagerListenerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HILOGI("code = %{public}d, flags= %{public}d.", code, option.GetFlags()); - auto itFunc = memberFuncMap_.find(code); - if (itFunc != memberFuncMap_.end()) { - auto memberFunc = itFunc->second; - if (data.ReadInterfaceToken() != DeviceManagerListenerStub::GetDescriptor()) { - HILOGE("interface token check failed!"); - return ERR_INVALID_STATE; - } - return (this->*memberFunc)(data, reply); - } - HILOGW("unsupport code: %{public}d", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); -} - -template -int32_t DeviceManagerListenerStub::GetParcelableInfo(MessageParcel &reply, T &parcelableInfo) -{ - std::unique_ptr info(reply.ReadParcelable()); - if (!info) { - HILOGE("readParcelableInfo failed"); - return ERR_INVALID_VALUE; - } - parcelableInfo = *info; - return ERR_NONE; -} - -int32_t DeviceManagerListenerStub::OnDeviceOnlineInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceOnline(packageName, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceOfflineInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceOffline(packageName, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceChangedInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo deviceInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceChanged(packageName, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceFoundInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt16(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceFound(packageName, subscribeId, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDiscoverFailedInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt16(); - int32_t failedReason = data.ReadInt32(); - - int32_t ret = OnDiscoverFailed(packageName, subscribeId, failedReason); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDiscoverySuccessInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt16(); - - int32_t ret = OnDiscoverySuccess(packageName, subscribeId); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnAuthResultInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - string deviceId = data.ReadString(); - int32_t status = data.ReadInt32(); - int32_t reason = data.ReadInt32(); - - int32_t ret = OnAuthResult(packageName, deviceId, status, reason); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceOnline packageName:%{public}s", packageName.c_str()); - if (deviceStateCallback_ == nullptr) { - HILOGE("OnDeviceOnlinecallback not register"); - return ERR_NULL_OBJECT; - } - deviceStateCallback_->OnDeviceOnline(deviceInfo); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceOffline packageName:%{public}s", packageName.c_str()); - if (deviceStateCallback_ == nullptr) { - HILOGE("OnDeviceOnlinecallback not register"); - return ERR_NULL_OBJECT; - } - deviceStateCallback_->OnDeviceOffline(deviceInfo); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceChanged packageName:%{public}s", packageName.c_str()); - if (deviceStateCallback_ == nullptr) { - HILOGE("OnDeviceOnlinecallback not register"); - return ERR_NULL_OBJECT; - } - deviceStateCallback_->OnDeviceChanged(deviceInfo); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDeviceFound(std::string &packageName, uint16_t subscribeId, - const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceFound packageName:%{public}s, subscribeId:%{public}d.", packageName.c_str(), (int32_t)subscribeId); - auto iter = deviceDiscoverCallbacks_.find(subscribeId); - if (iter == deviceDiscoverCallbacks_.end()) { - HILOGE("OnDeviceFound: no register discoverCallback for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnDeviceFound: discoverCallback is nullptr for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - callback->OnDeviceFound(subscribeId, const_cast(deviceInfo)); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, - int32_t failedReason) -{ - HILOGI("OnDiscoverFailed packageName:%{public}s, subscribeId %{public}d, reason %{public}d", - packageName.c_str(), subscribeId, failedReason); - auto iter = deviceDiscoverCallbacks_.find(subscribeId); - if (iter == deviceDiscoverCallbacks_.end()) { - HILOGE("OnDiscoverFailed: no register discoverCallback for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnDiscoverFailed: discoverCallback is nullptr for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - callback->OnDiscoverFailed(subscribeId, failedReason); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) -{ - HILOGI("OnDiscoverySuccess packageName:%{public}s, subscribeId %{public}d", packageName.c_str(), subscribeId); - auto iter = deviceDiscoverCallbacks_.find(subscribeId); - if (iter == deviceDiscoverCallbacks_.end()) { - HILOGE("OnDiscoverySuccess: no register discoverCallback for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnDiscoverySuccess: discoverCallback is nullptr for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - callback->OnDiscoverySuccess(subscribeId); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, - int32_t reason) -{ - HILOGI("OnAuthResult packageName:%{public}s, status %{public}d, reason %{public}d", - packageName.c_str(), status, reason); - auto iter = authenticateCallback_.find(deviceId); - if (iter == authenticateCallback_.end()) { - HILOGE("OnAuthResult: cannot find Auth callback"); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnAuthResult: Auth callback is nullptr"); - return ERR_NULL_OBJECT; - } - callback->OnAuthResult(deviceId, status, reason); - authenticateCallback_.erase(deviceId); - return ERR_OK; -} - -void DeviceManagerListenerStub::AddDeviceStateCallback(std::shared_ptr callback) -{ - deviceStateCallback_ = callback; -} - -void DeviceManagerListenerStub::RemoveDeviceStateCallback() -{ - deviceStateCallback_ = nullptr; -} - -void DeviceManagerListenerStub::AddDiscoverCallback(uint16_t subscribeId, std::shared_ptr callback) -{ - deviceDiscoverCallbacks_[subscribeId] = callback; -} - -void DeviceManagerListenerStub::RemoveDiscoverCallback(uint16_t subscribeId) -{ - deviceDiscoverCallbacks_.erase(subscribeId); -} - -void DeviceManagerListenerStub::AddAuthenticateCallback(std::string deviceId, - std::shared_ptr callback) -{ - authenticateCallback_[deviceId] = callback; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp deleted file mode 100644 index d5045590ced8e37737996edc8018932f5ceb8b79..0000000000000000000000000000000000000000 --- a/interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp +++ /dev/null @@ -1,316 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_manager_proxy.h" - -#include "ipc_types.h" - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -bool DeviceManagerProxy::WriteInterfaceToken(MessageParcel &data) -{ - if (!data.WriteInterfaceToken(DeviceManagerProxy::GetDescriptor())) { - HILOGE("write interface token failed"); - return false; - } - return true; -} - -int32_t DeviceManagerProxy::RegisterDeviceManagerListener(std::string &packageName, sptr listener) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteRemoteObject(listener)) { - HILOGE("write callback failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(REGISTER_DEVICE_MANAGER_LISTENER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("RegisterDeviceManagerListener SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::UnRegisterDeviceManagerListener(std::string &packageName) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(UNREGISTER_DEVICE_MANAGER_LISTENER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("UnRegisterDeviceManagerListener SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::RegisterDeviceStateCallback(std::string &packageName, std::string &extra) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(extra)) { - HILOGE("write extra failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(REGISTER_DEVICE_STATE_CALLBACK, data, reply, option); - if (error != ERR_NONE) { - HILOGE("RegisterDeviceStateCallback SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::UnRegisterDeviceStateCallback(std::string &packageName) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(UNREGISTER_DEVICE_STATE_CALLBACK, data, reply, option); - if (error != ERR_NONE) { - HILOGE("UnRegisterDeviceStateCallback SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -template -int32_t DeviceManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos) -{ - int32_t infoSize = reply.ReadInt32(); - for (int32_t i = 0; i < infoSize; i++) { - std::unique_ptr info(reply.ReadParcelable()); - if (!info) { - HILOGE("Read Parcelable infos failed"); - return ERR_INVALID_VALUE; - } - parcelableInfos.emplace_back(*info); - } - HILOGI("get parcelable infos success"); - return ERR_NONE; -} - -int32_t DeviceManagerProxy::GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(extra)) { - HILOGE("write extra failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(GET_TRUST_DEVICE_LIST, data, reply, option); - if (error != ERR_NONE) { - HILOGE("GetTrustedDeviceList SendRequest fail, error: %{public}d", error); - return error; - } - - error = GetParcelableInfos(reply, deviceList); - if (error != ERR_NONE) { - HILOGE("GetTrustedDeviceList GetParcelableInfos fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&subscribeInfo)) { - HILOGE("write subscribeInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(START_DEVICE_DISCOVER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("StartDeviceDiscovery SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(STOP_DEVICE_DISCOVER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("StopDeviceDiscovery SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, - std::string &extra) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(extra)) { - HILOGE("write extra failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(AUTHENTICATE_DEVICE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("AuthenticateDevice SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/ipc_client_proxy.cpp b/interfaces/inner_kits/native_cpp/src/ipc/ipc_client_proxy.cpp new file mode 100644 index 0000000000000000000000000000000000000000..77cf6559d54dcd2f30ab43d65b550e41e66abb98 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/ipc_client_proxy.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_proxy.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcClientProxy::Init(std::string &pkgName) +{ + if (ipcClientManager_ == nullptr) { + return DEVICEMANAGER_NULLPTR; + } + return ipcClientManager_->Init(pkgName); +} + +int32_t IpcClientProxy::UnInit(std::string &pkgName) +{ + if (ipcClientManager_ == nullptr) { + return DEVICEMANAGER_NULLPTR; + } + return ipcClientManager_->UnInit(pkgName); +} + +int32_t IpcClientProxy::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + if (req == nullptr || rsp == nullptr || ipcClientManager_ == nullptr) { + DMLOG(DM_LOG_INFO, "req,rsp or ipc client is null"); + return DEVICEMANAGER_NULLPTR; + } + return ipcClientManager_->SendRequest(cmdCode, req, rsp); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..26551b4353d24859018d70a99a43e615451be7cb --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_manager.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +#include "ipc_client_stub.h" +#include "ipc_register_listener_req.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcClientManager::Init(std::string &pkgName) +{ + if (IsInit(pkgName)) { + DMLOG(DM_LOG_INFO, "already init"); + return DEVICEMANAGER_OK; + } + if (serverProxy_.Init() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "server proxy init failed."); + return DEVICEMANAGER_INIT_FAILED; + } + if (IpcClientStub::GetInstance().Init() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "ipcclientstub init failed."); + return DEVICEMANAGER_INIT_FAILED; + } + + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetSvcIdentity(IpcClientStub::GetInstance().GetSvcIdentity()); + int32_t ret = serverProxy_.SendCmd(REGISTER_DEVICE_MANAGER_LISTENER, req, rsp); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "InitDeviceManager: RegisterDeviceManagerListener Failed with ret %d", ret); + return ret; + } + ret = rsp->GetErrCode(); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "DeviceManager::InitDeviceManager completed, pkgName: %s, ret=%d", pkgName.c_str(), ret); + return ret; + } + packageInitSet_.emplace(pkgName); + return DEVICEMANAGER_OK; +} + +int32_t IpcClientManager::UnInit(std::string &pkgName) +{ + DMLOG(DM_LOG_INFO, "UnInitDeviceManager in, pkgName %s", pkgName.c_str()); + if (!IsInit(pkgName)) { + return DEVICEMANAGER_FAILED; + } + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + int32_t ret = serverProxy_.SendCmd(UNREGISTER_DEVICE_MANAGER_LISTENER, req, rsp); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "UnRegisterDeviceManagerListener Failed with ret %d", ret); + return ret; + } + packageInitSet_.erase(pkgName); + DMLOG(DM_LOG_INFO, "UnInitDeviceManager SUCCESS"); + return DEVICEMANAGER_OK; +} + +int32_t IpcClientManager::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + std::string pkgName = req->GetPkgName(); + if (!IsInit(pkgName)) { + return DEVICEMANAGER_SERVICE_NOT_READY; + } + return serverProxy_.SendCmd(cmdCode, req, rsp); +} + +bool IpcClientManager::IsInit(std::string &pkgName) +{ + return (packageInitSet_.count(pkgName) > 0); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_server_proxy.cpp b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_server_proxy.cpp new file mode 100644 index 0000000000000000000000000000000000000000..88a0464dceeb175937f852233de92994d06b056e --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_server_proxy.cpp @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_server_proxy.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" +#include "device_manager_notify.h" + +#include "ipc_def.h" +#include "ipc_cmd_register.h" + +namespace OHOS { +namespace DistributedHardware { +namespace { + const int32_t INVALID_CB_ID = 0xFF; +} +static uint32_t g_deathCbId = INVALID_CB_ID; +static SvcIdentity g_svcIdentity; +static std::shared_ptr pCurRsp; + +void __attribute__((weak)) HOS_SystemInit(void) +{ + SAMGR_Bootstrap(); + return; +} + +int32_t DMDeathCallback(const IpcContext *ctx, void *ipcMsg, IpcIo *data, void *arg) +{ + (void)ctx; + (void)ipcMsg; + (void)data; + (void)arg; + DMLOG(DM_LOG_INFO, "ATTENTION SERVICE (%s) DEAD !!!\n", DEVICE_MANAGER_SERVICE_NAME); + UnregisterDeathCallback(g_svcIdentity, g_deathCbId); + g_deathCbId = INVALID_CB_ID; + g_svcIdentity.handle = 0; + g_svcIdentity.token = 0; + g_svcIdentity.cookie = 0; + DeviceManagerNotify::GetInstance().OnRemoteDied(); + return DEVICEMANAGER_OK; +} + +static int32_t SendCmdResultCb(IOwner owner, int code, IpcIo *reply) +{ + int32_t cmdCode = *(int32_t *)owner; + DMLOG(DM_LOG_INFO, "SendCmdResultCb code:%d", cmdCode); + (void)IpcCmdRegister::GetInstance().ReadResponse(cmdCode, *reply, pCurRsp); + return DEVICEMANAGER_OK; +} + +IClientProxy *IpcClientServerProxy::GetServerProxy(void) +{ + IClientProxy *clientProxy = nullptr; + IUnknown *iUnknown = nullptr; + + DMLOG(DM_LOG_INFO, "start get client proxy"); + iUnknown = SAMGR_GetInstance()->GetDefaultFeatureApi(DEVICE_MANAGER_SERVICE_NAME); + if (iUnknown == nullptr) { + return nullptr; + } + if (iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, (void **)&clientProxy) != DEVICEMANAGER_OK || + clientProxy == nullptr) { + DMLOG(DM_LOG_ERROR, "QueryInterface failed"); + } + return clientProxy; +} + +int IpcClientServerProxy::RegisterServerDeathCb(void) +{ + g_svcIdentity = SAMGR_GetRemoteIdentity(DEVICE_MANAGER_SERVICE_NAME, nullptr); + g_deathCbId = INVALID_CB_ID; + if (RegisterDeathCallback(nullptr, g_svcIdentity, DMDeathCallback, nullptr, &g_deathCbId) != EC_SUCCESS) { + DMLOG(DM_LOG_ERROR, "reg death callback failed"); + return DEVICEMANAGER_FAILED; + } + return DEVICEMANAGER_OK; +} + +int32_t IpcClientServerProxy::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + DMLOG(DM_LOG_INFO, "SendCmd:%d", cmdCode); + uint8_t data[MAX_DM_IPC_LEN] = {0}; + IpcIo request; + + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, request, data, MAX_DM_IPC_LEN) != DEVICEMANAGER_OK) { + return DEVICEMANAGER_FAILED; + } + { + std::lock_guard autoLock(lock_); + pCurRsp = rsp; + if (serviceProxy_ != nullptr && + serviceProxy_->Invoke(serviceProxy_, cmdCode, &request, &cmdCode, SendCmdResultCb) != 0) { + DMLOG(DM_LOG_ERROR, "serviceProxy_ invoke failed."); + return DEVICEMANAGER_FAILED; + } + } + DMLOG(DM_LOG_INFO, "SendCmd:%d end", cmdCode); + return DEVICEMANAGER_OK; +} + +int32_t IpcClientServerProxy::Init(void) +{ + if (serviceProxy_ != nullptr) { + DMLOG(DM_LOG_INFO, "ServerProxy already Init"); + return DEVICEMANAGER_OK; + } + HOS_SystemInit(); + serviceProxy_ = GetServerProxy(); + if (serviceProxy_ == nullptr) { + DMLOG(DM_LOG_ERROR, "get ipc client proxy failed"); + return DEVICEMANAGER_FAILED; + } + if (RegisterServerDeathCb() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "register server death cb failed"); + return DEVICEMANAGER_FAILED; + } + DMLOG(DM_LOG_INFO, "ServerProxyInit ok"); + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp similarity index 40% rename from interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp rename to interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp index 0bba105f1458fd284d25c34f0a9b6546744f9981..9ae99e19ad64562299b40306c2629e6927d14cdd 100644 --- a/interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp +++ b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp @@ -1,58 +1,57 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -bool DmSubscribeInfo::ReadFromParcel(Parcel &parcel) -{ - subscribeId = parcel.ReadInt16(); - mode = (DmDiscoverMode)parcel.ReadInt32(); - medium = (DmExchangeMedium)parcel.ReadInt32(); - freq = (DmExchangeFreq)parcel.ReadInt32(); - isSameAccount = parcel.ReadBool(); - isWakeRemote = parcel.ReadBool(); - capability = parcel.ReadString(); - return true; -} - -DmSubscribeInfo *DmSubscribeInfo::Unmarshalling(Parcel &parcel) -{ - DmSubscribeInfo *info = new (std::nothrow) DmSubscribeInfo(); - if (info == nullptr) { - return nullptr; - } - - if (!info->ReadFromParcel(parcel)) { - delete info; - info = nullptr; - } - return info; -} - -bool DmSubscribeInfo::Marshalling(Parcel &parcel) const -{ - parcel.WriteInt16(subscribeId); - parcel.WriteInt32((int32_t)mode); - parcel.WriteInt32((int32_t)medium); - parcel.WriteInt32((uint8_t)freq); - parcel.WriteBool(isSameAccount); - parcel.WriteBool(isWakeRemote); - parcel.WriteString(capability); - return true; -} -} // namespace DistributedHardware -} // namespace OHOS +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_stub.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "device_manager_notify.h" + +#include "ipc_def.h" +#include "ipc_cmd_register.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcClientStub); + +static int32_t ClientIpcInterfaceMsgHandle(const IpcContext *ctx, void *ipcMsg, IpcIo *io, void *arg) +{ + (void)arg; + if (ipcMsg == nullptr || io == nullptr || ctx == nullptr) { + DMLOG(DM_LOG_ERROR, "invalid param"); + return DEVICEMANAGER_INVALID_PARAM; + } + + uint32_t code = 0; + GetCode(ipcMsg, &code); + DMLOG(DM_LOG_INFO, "receive ipc transact code(%u)", code); + return IpcCmdRegister::GetInstance().OnIpcCmd(code, *io, *ctx, ipcMsg); +} + +int32_t IpcClientStub::Init() +{ + std::lock_guard autoLock(lock_); + if (bInit) { + return DEVICEMANAGER_OK; + } + if (RegisterIpcCallback(ClientIpcInterfaceMsgHandle, 0, IPC_WAIT_FOREVER, &clientIdentity_, nullptr) != 0) { + DMLOG(DM_LOG_ERROR, "register ipc cb failed"); + return DEVICEMANAGER_FAILED; + } + bInit = true; + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_cmd_parser.cpp b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_cmd_parser.cpp new file mode 100644 index 0000000000000000000000000000000000000000..79dc594be56cfba0f8237e5200ea8797163d6000 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_cmd_parser.cpp @@ -0,0 +1,287 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_cmd_register.h" +#include "ipc_def.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "device_manager_notify.h" + +#include "dm_device_info.h" +#include "dm_subscribe_info.h" + +#include "ipc_register_listener_req.h" +#include "ipc_start_discovery_req.h" +#include "ipc_stop_discovery_req.h" +#include "ipc_get_trustdevice_req.h" +#include "ipc_get_trustdevice_rsp.h" +#include "ipc_authenticate_device_req.h" +#include "ipc_check_authenticate_req.h" + +namespace OHOS { +namespace DistributedHardware { +ON_IPC_SET_REQUEST(REGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + SvcIdentity svcIdentity = pReq->GetSvcIdentity(); + + IpcIoInit(&request, buffer, buffLen, 1); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushSvc(&request, &svcIdentity); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(REGISTER_DEVICE_MANAGER_LISTENER, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(UNREGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::string pkgName = pBaseReq->GetPkgName(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(UNREGISTER_DEVICE_MANAGER_LISTENER, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(GET_TRUST_DEVICE_LIST, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string extra = pReq->GetExtra(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushString(&request, extra.c_str()); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + int32_t deviceNum = IpcIoPopInt32(&reply); + uint32_t deviceTotalSize = deviceNum * (int32_t)sizeof(DmDeviceInfo); + + if (deviceTotalSize > 0) { + std::vector deviceInfoVec; + DmDeviceInfo *pDmDeviceinfo = (DmDeviceInfo *)IpcIoPopFlatObj(&reply, &deviceTotalSize); + if (pDmDeviceinfo == nullptr) { + DMLOG(DM_LOG_ERROR, "GetTrustedDeviceList read node info failed!"); + pRsp->SetErrCode(DEVICEMANAGER_IPC_TRANSACTION_FAILED); + return DEVICEMANAGER_IPC_TRANSACTION_FAILED; + } + for (int32_t i = 0; i < deviceNum; ++i) { + pDmDeviceinfo = pDmDeviceinfo + i; + deviceInfoVec.emplace_back(*pDmDeviceinfo); + } + pRsp->SetDeviceVec(deviceInfoVec); + } + pRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(START_DEVICE_DISCOVER, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + const DmSubscribeInfo dmSubscribeInfo = pReq->GetSubscribeInfo(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushFlatObj(&request, &dmSubscribeInfo, sizeof(DmSubscribeInfo)); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVER, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + uint16_t subscribeId = pReq->GetSubscribeId(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushUint16(&request, subscribeId); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(STOP_DEVICE_DISCOVER, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(AUTHENTICATE_DEVICE, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string extra = pReq->GetExtra(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushString(&request, extra.c_str()); + IpcIoPushFlatObj(&request, &deviceInfo, sizeof(DmDeviceInfo)); + // L1 暂时没有考虑appimage校验（8k限制） + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(AUTHENTICATE_DEVICE, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(CHECK_AUTHENTICATION, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string authPara = pReq->GetAuthPara(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, authPara.c_str()); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(CHECK_AUTHENTICATION, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, IpcIo &reply, const IpcContext &ctx, void *ipcMsg) +{ + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&reply, &len); + DmDeviceState deviceState = static_cast(IpcIoPopInt32(&reply)); + uint32_t size; + const DmDeviceInfo *deviceInfo = (const DmDeviceInfo*)IpcIoPopFlatObj(&reply, &size); + if (pkgName == "" || len == 0 || deviceInfo == NULL) { + DMLOG(DM_LOG_ERROR, "OnDeviceOnline, get para failed"); + FreeBuffer(&ctx, ipcMsg); + return; + } + switch (deviceState) { + case DEVICE_STATE_ONLINE: + DeviceManagerNotify::GetInstance().OnDeviceOnline(pkgName, *deviceInfo); + break; + case DEVICE_STATE_OFFLINE: + DeviceManagerNotify::GetInstance().OnDeviceOffline(pkgName, *deviceInfo); + break; + case DEVICE_INFO_CHANGED: + DeviceManagerNotify::GetInstance().OnDeviceChanged(pkgName, *deviceInfo); + break; + default: + DMLOG(DM_LOG_ERROR, "unknown device state:%d", deviceState); + break; + } + FreeBuffer(&ctx, ipcMsg); +} + +ON_IPC_CMD(SERVER_DEVICE_FOUND, IpcIo &reply, const IpcContext &ctx, void *ipcMsg) +{ + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&reply, &len); + uint16_t subscribeId = IpcIoPopUint16(&reply); + uint32_t size; + const DmDeviceInfo *deviceInfo = (const DmDeviceInfo*)IpcIoPopFlatObj(&reply, &size); + if (pkgName == "" || len == 0 || deviceInfo == NULL) { + DMLOG(DM_LOG_ERROR, "OnDeviceChanged, get para failed"); + FreeBuffer(&ctx, ipcMsg); + return; + } + DeviceManagerNotify::GetInstance().OnDeviceFound(pkgName, subscribeId, *deviceInfo); + FreeBuffer(&ctx, ipcMsg); +} + +ON_IPC_CMD(SERVER_DISCOVER_FINISH, IpcIo &reply, const IpcContext &ctx, void *ipcMsg) +{ + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&reply, &len); + uint16_t subscribeId = IpcIoPopUint16(&reply); + int32_t failedReason = IpcIoPopInt32(&reply); + + if (pkgName == "" || len == 0) { + DMLOG(DM_LOG_ERROR, "OnDiscoverySuccess, get para failed"); + FreeBuffer(&ctx, ipcMsg); + return; + } + if (failedReason == DEVICEMANAGER_OK) { + DeviceManagerNotify::GetInstance().OnDiscoverySuccess(pkgName, subscribeId); + } else { + DeviceManagerNotify::GetInstance().OnDiscoverFailed(pkgName, subscribeId, failedReason); + } + FreeBuffer(&ctx, ipcMsg); +} + +ON_IPC_CMD(SERVER_AUTH_RESULT, IpcIo &reply, const IpcContext &ctx, void *ipcMsg) +{ + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&reply, &len); + size_t devIdLen = 0; + std::string deviceId = (const char *)IpcIoPopString(&reply, &devIdLen); + int32_t pinToken = IpcIoPopInt32(&reply); + int32_t status = IpcIoPopInt32(&reply); + int32_t reason = IpcIoPopInt32(&reply); + + if (pkgName == "" || len == 0 || deviceId == "" || devIdLen == 0) { + DMLOG(DM_LOG_ERROR, "OnAuthResult, get para failed"); + FreeBuffer(&ctx, ipcMsg); + return; + } + DeviceManagerNotify::GetInstance().OnAuthResult(pkgName, deviceId, pinToken, status, reason); + FreeBuffer(&ctx, ipcMsg); +} + +ON_IPC_CMD(SERVER_CHECK_AUTH_RESULT, IpcIo &reply, const IpcContext &ctx, void *ipcMsg) +{ + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&reply, &len); + size_t devIdLen = 0; + std::string deviceId = (const char *)IpcIoPopString(&reply, &devIdLen); + int32_t resultCode = IpcIoPopInt32(&reply); + int32_t flag = IpcIoPopInt32(&reply); + + if (pkgName == "" || len == 0 || deviceId == "" || devIdLen == 0) { + DMLOG(DM_LOG_ERROR, "OnAuthResult, get para failed"); + FreeBuffer(&ctx, ipcMsg); + return; + } + DeviceManagerNotify::GetInstance().OnCheckAuthResult(pkgName, deviceId, resultCode, flag); + FreeBuffer(&ctx, ipcMsg); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..26d9fb9278085021dc1ce49f396f86dd121350a2 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp @@ -0,0 +1,152 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_manager.h" + +#include "ipc_remote_broker.h" +#include "iremote_object.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "device_manager_notify.h" + +#include "ipc_register_listener_req.h" + +namespace OHOS { +namespace DistributedHardware { +void DmDeathRecipient::OnRemoteDied(const wptr &remote) +{ + (void)remote; + DMLOG(DM_LOG_WARN, "DmDeathRecipient : OnRemoteDied"); + DeviceManagerNotify::GetInstance().OnRemoteDied(); +} + +int32_t IpcClientManager::ClientInit() +{ + DMLOG(DM_LOG_INFO, "InitDeviceManagerService start"); + if (dmInterface_ != nullptr) { + DMLOG(DM_LOG_INFO, "DeviceManagerService Already Init"); + return DEVICEMANAGER_OK; + } + + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (samgr == nullptr) { + DMLOG(DM_LOG_ERROR, "Get SystemAbilityManager Failed"); + return DEVICEMANAGER_SERVICE_NOT_READY; + } + + auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID); + if (object == nullptr) { + DMLOG(DM_LOG_ERROR, "Get DeviceManager SystemAbility Failed"); + return DEVICEMANAGER_SERVICE_NOT_READY; + } + + if (dmRecipient_ == nullptr) { + dmRecipient_ = sptr(new DmDeathRecipient()); + } + if (!object->AddDeathRecipient(dmRecipient_)) { + DMLOG(DM_LOG_ERROR, "InitDeviceManagerService: AddDeathRecipient Failed"); + } + dmInterface_ = iface_cast(object); + DMLOG(DM_LOG_INFO, "DeviceManager::InitDeviceManagerService completed"); + return DEVICEMANAGER_OK; +} + +int32_t IpcClientManager::Init(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + int32_t ret = ClientInit(); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "InitDeviceManager Failed with ret %d", ret); + return ret; + } + if (dmListener_.count(pkgName) > 0) { + DMLOG(DM_LOG_INFO, "dmListener_ Already Init"); + return DEVICEMANAGER_OK; + } + + sptr listener = sptr(new IpcClientStub()); + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetListener(listener); + ret = dmInterface_->SendCmd(REGISTER_DEVICE_MANAGER_LISTENER, req, rsp); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "InitDeviceManager: RegisterDeviceManagerListener Failed with ret %d", ret); + return ret; + } + ret = rsp->GetErrCode(); + if (ret != DEVICEMANAGER_OK) { + return ret; + } + dmListener_[pkgName] = listener; + DMLOG(DM_LOG_INFO, "completed, pkgName: %s", pkgName.c_str()); + return DEVICEMANAGER_OK; +} + +int32_t IpcClientManager::UnInit(std::string &pkgName) +{ + DMLOG(DM_LOG_INFO, "in, pkgName %s", pkgName.c_str()); + if (dmInterface_ == nullptr) { + DMLOG(DM_LOG_ERROR, "DeviceManager not Init"); + return DEVICEMANAGER_SERVICE_NOT_READY; + } + + std::lock_guard autoLock(lock_); + if (dmListener_.count(pkgName) > 0) { + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + int32_t ret = dmInterface_->SendCmd(UNREGISTER_DEVICE_MANAGER_LISTENER, req, rsp); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "UnRegisterDeviceManagerListener Failed with ret %d", ret); + return ret; + } + dmListener_.erase(pkgName); + } + if (dmListener_.empty()) { + dmInterface_ = nullptr; + dmRecipient_ = nullptr; + } + DMLOG(DM_LOG_INFO, "completed, pkgName: %s", pkgName.c_str()); + return DEVICEMANAGER_OK; +} + +int32_t IpcClientManager::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + std::string pkgName = req->GetPkgName(); + if (!IsInit(pkgName)) { + return DEVICEMANAGER_SERVICE_NOT_READY; + } + return dmInterface_->SendCmd(cmdCode, req, rsp); +} + +bool IpcClientManager::IsInit(std::string &pkgName) +{ + if (dmInterface_ == nullptr) { + DMLOG(DM_LOG_ERROR, "DeviceManager not Init"); + return false; + } + std::lock_guard autoLock(lock_); + if (dmListener_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "dmListener_ not Init for %s", pkgName.c_str()); + return false; + } + return true; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_server_proxy.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_server_proxy.cpp new file mode 100644 index 0000000000000000000000000000000000000000..75d0d1923dfa1a5dc7d9f919d5103abc8381a0ce --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_server_proxy.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_server_proxy.h" + +#include "ipc_cmd_register.h" +#include "ipc_types.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcClientServerProxy::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + sptr remote = Remote(); + if (remote == nullptr) { + DMLOG(DM_LOG_ERROR, "remote service null"); + return DEVICEMANAGER_NULLPTR; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data) != DEVICEMANAGER_OK) { + return DEVICEMANAGER_FAILED; + } + if (remote->SendRequest(cmdCode, data, reply, option) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "SendRequest fail, cmd:%d", cmdCode); + return DEVICEMANAGER_IPC_FAILED; + } + return IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_stub.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_stub.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cbe30dd5bebe91de00aa8174123085cf69f701c5 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_stub.cpp @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_client_stub.h" + +#include "ipc_skeleton.h" +#include "ipc_types.h" + +#include "ipc_cmd_register.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcClientStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, + MessageOption &option) +{ + DMLOG(DM_LOG_INFO, "code = %d, flags= %d.", code, option.GetFlags()); + if (IpcCmdRegister::GetInstance().OnIpcCmd(code, data, reply) == DEVICEMANAGER_OK) { + return DEVICEMANAGER_OK; + } + DMLOG(DM_LOG_WARN, "unsupport code: %d", code); + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); +} + +int32_t IpcClientStub::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + DMLOG(DM_LOG_ERROR, "error"); + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp new file mode 100644 index 0000000000000000000000000000000000000000..88217e1bdb3b46a853798da114819cb9d67c1b54 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp @@ -0,0 +1,390 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_cmd_register.h" + +#include "securec.h" +#include "constants.h" +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "device_manager_notify.h" + +#include "ipc_def.h" +#include "ipc_register_listener_req.h" +#include "ipc_start_discovery_req.h" +#include "ipc_stop_discovery_req.h" +#include "ipc_get_trustdevice_req.h" +#include "ipc_get_trustdevice_rsp.h" +#include "ipc_authenticate_device_req.h" +#include "ipc_check_authenticate_req.h" +#include "ipc_get_authenticationparam_rsp.h" +#include "ipc_set_useroperation_req.h" + +namespace OHOS { +namespace DistributedHardware { +ON_IPC_SET_REQUEST(REGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + sptr listener = pReq->GetListener(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteRemoteObject(listener)) { + DMLOG(DM_LOG_ERROR, "write listener failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(UNREGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::string pkgName = pBaseReq->GetPkgName(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write papam failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(GET_TRUST_DEVICE_LIST, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string extra = pReq->GetExtra(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkg failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteString(extra)) { + DMLOG(DM_LOG_ERROR, "write extra failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + int32_t deviceNum = reply.ReadInt32(); + int32_t deviceTotalSize = deviceNum * (int32_t)sizeof(DmDeviceInfo); + if (deviceTotalSize > 0) { + std::vector deviceInfoVec; + DmDeviceInfo *pDmDeviceinfo = (DmDeviceInfo *)reply.ReadRawData(deviceTotalSize); + if (pDmDeviceinfo == nullptr) { + DMLOG(DM_LOG_ERROR, "GetTrustedDeviceList read node info failed!"); + pRsp->SetErrCode(DEVICEMANAGER_IPC_TRANSACTION_FAILED); + return DEVICEMANAGER_IPC_TRANSACTION_FAILED; + } + for (int32_t i = 0; i < deviceTotalSize; ++i) { + pDmDeviceinfo = pDmDeviceinfo + i; + deviceInfoVec.emplace_back(*pDmDeviceinfo); + } + pRsp->SetDeviceVec(deviceInfoVec); + } + pRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(START_DEVICE_DISCOVER, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + const DmSubscribeInfo dmSubscribeInfo = pReq->GetSubscribeInfo(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteRawData(&dmSubscribeInfo, sizeof(DmSubscribeInfo))) { + DMLOG(DM_LOG_ERROR, "write subscribe info failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVER, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + uint16_t subscribeId = pReq->GetSubscribeId(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt16(subscribeId)) { + DMLOG(DM_LOG_ERROR, "write subscribeId failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(STOP_DEVICE_DISCOVER, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(AUTHENTICATE_DEVICE, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string extra = pReq->GetExtra(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + DmAppImageInfo imageInfo = pReq->GetAppImageInfo(); + + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteString(extra)) { + DMLOG(DM_LOG_ERROR, "write extra failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteRawData(&deviceInfo, sizeof(DmDeviceInfo))) { + DMLOG(DM_LOG_ERROR, "write deviceInfo failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + int32_t appIconLen = imageInfo.GetAppIconLen(); + int32_t appThumbnailLen = imageInfo.GetAppThumbnailLen(); + if (!data.WriteInt32(appIconLen)) { + DMLOG(DM_LOG_ERROR, "write imageinfo appicon len failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(appThumbnailLen)) { + DMLOG(DM_LOG_ERROR, "write imageinfo appThumbnailLen failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (appIconLen > 0 && !data.WriteRawData(imageInfo.GetAppIcon(), appIconLen)) { + DMLOG(DM_LOG_ERROR, "write imageinfo appIcon failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (appThumbnailLen > 0 && !data.WriteRawData(imageInfo.GetAppThumbnail(), appThumbnailLen)) { + DMLOG(DM_LOG_ERROR, "write imageinfo appThumbnail failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(AUTHENTICATE_DEVICE, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(CHECK_AUTHENTICATION, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string authPara = pReq->GetAuthPara(); + if (!data.WriteString(authPara)) { + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(CHECK_AUTHENTICATION, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + DmDeviceState deviceState = static_cast(data.ReadInt32()); + DmDeviceInfo dmDeviceInfo; + size_t deviceSize = sizeof(DmDeviceInfo); + void *deviceInfo = (void *)data.ReadRawData(deviceSize); + if (deviceInfo != nullptr && memcpy_s(&dmDeviceInfo, deviceSize, deviceInfo, deviceSize) != 0) { + reply.WriteInt32(DEVICEMANAGER_COPY_FAILED); + return DEVICEMANAGER_OK; + } + switch (deviceState) { + case DEVICE_STATE_ONLINE: + DeviceManagerNotify::GetInstance().OnDeviceOnline(pkgName, dmDeviceInfo); + break; + case DEVICE_STATE_OFFLINE: + DeviceManagerNotify::GetInstance().OnDeviceOffline(pkgName, dmDeviceInfo); + break; + case DEVICE_INFO_CHANGED: + DeviceManagerNotify::GetInstance().OnDeviceChanged(pkgName, dmDeviceInfo); + break; + default: + DMLOG(DM_LOG_ERROR, "unknown device state:%d", deviceState); + break; + } + reply.WriteInt32(DEVICEMANAGER_OK); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_DEVICE_FOUND, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + uint16_t subscribeId = data.ReadInt16(); + DmDeviceInfo dmDeviceInfo; + size_t deviceSize = sizeof(DmDeviceInfo); + void *deviceInfo = (void *)data.ReadRawData(deviceSize); + if (deviceInfo != nullptr && memcpy_s(&dmDeviceInfo, deviceSize, deviceInfo, deviceSize) != 0) { + reply.WriteInt32(DEVICEMANAGER_COPY_FAILED); + return DEVICEMANAGER_OK; + } + DeviceManagerNotify::GetInstance().OnDeviceFound(pkgName, subscribeId, dmDeviceInfo); + reply.WriteInt32(DEVICEMANAGER_OK); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_DISCOVER_FINISH, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + uint16_t subscribeId = data.ReadInt16(); + int32_t failedReason = data.ReadInt32(); + + if (failedReason == DEVICEMANAGER_OK) { + DeviceManagerNotify::GetInstance().OnDiscoverySuccess(pkgName, subscribeId); + } else { + DeviceManagerNotify::GetInstance().OnDiscoverFailed(pkgName, subscribeId, failedReason); + } + reply.WriteInt32(DEVICEMANAGER_OK); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_AUTH_RESULT, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + std::string deviceId = data.ReadString(); + int32_t pinToken = data.ReadInt32(); + int32_t status = data.ReadInt32(); + int32_t reason = data.ReadInt32(); + + DeviceManagerNotify::GetInstance().OnAuthResult(pkgName, deviceId, pinToken, status, reason); + reply.WriteInt32(DEVICEMANAGER_OK); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_CHECK_AUTH_RESULT, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + std::string deviceId = data.ReadString(); + int32_t resultCode = data.ReadInt32(); + int32_t flag = data.ReadInt32(); + + DeviceManagerNotify::GetInstance().OnCheckAuthResult(pkgName, deviceId, resultCode, flag); + reply.WriteInt32(DEVICEMANAGER_OK); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_GET_AUTHENTCATION_INFO, std::shared_ptr pBaseReq, MessageParcel& data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string packagename = pReq->GetPkgName(); + if (!data.WriteString(packagename)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_GET_AUTHENTCATION_INFO, MessageParcel& reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + DmAuthParam authParam; + authParam.direction = reply.ReadInt32(); + authParam.authType = reply.ReadInt32(); + if (authParam.direction == AUTH_SESSION_SIDE_CLIENT) { + authParam.pinToken = reply.ReadInt32(); + pRsp->SetAuthParam(authParam); + return DEVICEMANAGER_OK; + } + + authParam.packageName = reply.ReadString(); + authParam.appName = reply.ReadString(); + authParam.appDescription = reply.ReadString(); + authParam.business = reply.ReadInt32(); + authParam.pincode = reply.ReadInt32(); + + int32_t appIconLen = reply.ReadInt32(); + uint8_t *appIconBuffer = nullptr; + int32_t appThumbnailLen = reply.ReadInt32(); + uint8_t *appThumbBuffer = nullptr; + if (appIconLen > 0) { + appIconBuffer = (uint8_t *)reply.ReadRawData(appIconLen); + } + if (appThumbnailLen > 0) { + appThumbBuffer = (uint8_t *)reply.ReadRawData(appThumbnailLen); + } + authParam.imageinfo.Reset(appIconBuffer, appIconLen, appThumbBuffer, appThumbnailLen); + pRsp->SetAuthParam(authParam); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_USER_AUTHORIZATION_OPERATION, std::shared_ptr pBaseReq, MessageParcel& data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + int32_t action = pReq->GetOperation(); + + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(action)) { + DMLOG(DM_LOG_ERROR, "write extra failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_USER_AUTHORIZATION_OPERATION, MessageParcel& reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_DEVICEMANAGER_FA_NOTIFY, MessageParcel &data, MessageParcel &reply) +{ + DMLOG(DM_LOG_INFO, "OnFaCallBack"); + std::string packagename = data.ReadString(); + std::string paramJson = data.ReadString(); + DMLOG(DM_LOG_INFO, "OnFaCallBack Packagename is %s", packagename.c_str()); + DMLOG(DM_LOG_INFO, "OnFaCallBack Json is %s", paramJson.c_str()); + DeviceManagerNotify::GetInstance().OnFaCall(packagename, paramJson); + + if (!reply.WriteInt32(DEVICEMANAGER_OK)) { + DMLOG(DM_LOG_ERROR, "write return failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bf8961b576127f24a1c921840647cf8263a6c339 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp @@ -0,0 +1,295 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "device_manager_notify.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" +#include "nlohmann/json.hpp" +#include "constants.h" +#include "device_manager.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DeviceManagerNotify); + +void DeviceManagerNotify::RegisterDeathRecipientCallback(std::string &pkgName, + std::shared_ptr dmInitCallback) +{ + std::lock_guard autoLock(lock_); + dmInitCallback_[pkgName] = dmInitCallback; +} + +void DeviceManagerNotify::UnRegisterDeathRecipientCallback(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + dmInitCallback_.erase(pkgName); +} + +void DeviceManagerNotify::RegisterDeviceStateCallback(std::string &pkgName, + std::shared_ptr callback) +{ + std::lock_guard autoLock(lock_); + deviceStateCallback_[pkgName] = callback; +} + +void DeviceManagerNotify::UnRegisterDeviceStateCallback(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + deviceStateCallback_.erase(pkgName); +} + +void DeviceManagerNotify::RegisterDiscoverCallback(std::string &pkgName, uint16_t subscribeId, + std::shared_ptr callback) +{ + std::lock_guard autoLock(lock_); + if (deviceDiscoverCallbacks_.count(pkgName) == 0) { + deviceDiscoverCallbacks_[pkgName] = std::map>(); + } + deviceDiscoverCallbacks_[pkgName][subscribeId] = callback; +} + +void DeviceManagerNotify::UnRegisterDiscoverCallback(std::string &pkgName, uint16_t subscribeId) +{ + std::lock_guard autoLock(lock_); + if (deviceDiscoverCallbacks_.count(pkgName) > 0) { + deviceDiscoverCallbacks_[pkgName].erase(subscribeId); + if (deviceDiscoverCallbacks_[pkgName].empty()) { + deviceDiscoverCallbacks_.erase(pkgName); + } + } +} + +void DeviceManagerNotify::RegisterAuthenticateCallback(std::string &pkgName, std::string &deviceId, + std::shared_ptr callback) +{ + std::lock_guard autoLock(lock_); + if (authenticateCallback_.count(pkgName) == 0) { + authenticateCallback_[pkgName] = std::map>(); + } + authenticateCallback_[pkgName][deviceId] = callback; +} + +void DeviceManagerNotify::UnRegisterAuthenticateCallback(std::string &pkgName, std::string &deviceId) +{ + std::lock_guard autoLock(lock_); + if (authenticateCallback_.count(pkgName) > 0) { + authenticateCallback_[pkgName].erase(deviceId); + if (authenticateCallback_[pkgName].empty()) { + authenticateCallback_.erase(pkgName); + } + } +} + +void DeviceManagerNotify::UnRegisterPackageCallback(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + deviceStateCallback_.erase(pkgName); + deviceDiscoverCallbacks_.erase(pkgName); + authenticateCallback_.erase(pkgName); + dmInitCallback_.erase(pkgName); +} + +void DeviceManagerNotify::RegisterCheckAuthenticationCallback(std::string &pkgName, std::string &authPara, + std::shared_ptr callback) +{ + std::lock_guard autoLock(lock_); + if (checkauthcallback_.count(pkgName) == 0) { + checkauthcallback_[pkgName] = std::map>(); + } + checkauthcallback_[pkgName][authPara] = callback; +} + +void DeviceManagerNotify::UnRegisterCheckAuthenticationCallback(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + deviceStateCallback_.erase(pkgName); + deviceDiscoverCallbacks_.erase(pkgName); + authenticateCallback_.erase(pkgName); + dmInitCallback_.erase(pkgName); + checkauthcallback_.erase(pkgName); +} + +void DeviceManagerNotify::RegisterDeviceManagerFaCallback(std::string &packageName, + std::shared_ptr callback) +{ + std::lock_guard autoLock(lock_); + dmFaCallback_[packageName] = callback; +} + +void DeviceManagerNotify::UnRegisterDeviceManagerFaCallback(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + dmFaCallback_.erase(pkgName); +} + + +void DeviceManagerNotify::OnRemoteDied() +{ + DMLOG(DM_LOG_WARN, "DeviceManager : OnRemoteDied"); + for (auto iter : dmInitCallback_) { + iter.second->OnRemoteDied(); + } +} + +void DeviceManagerNotify::OnDeviceOnline(std::string &pkgName, const DmDeviceInfo &deviceInfo) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceOnline pkgName:%s", pkgName.c_str()); + std::lock_guard autoLock(lock_); + if (deviceStateCallback_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDeviceOnlinecallback not register"); + return; + } + deviceStateCallback_[pkgName]->OnDeviceOnline(deviceInfo); +} + +void DeviceManagerNotify::OnDeviceOffline(std::string &pkgName, const DmDeviceInfo &deviceInfo) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceOffline pkgName:%s", pkgName.c_str()); + std::lock_guard autoLock(lock_); + if (deviceStateCallback_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDeviceOfflinecallback not register"); + return; + } + deviceStateCallback_[pkgName]->OnDeviceOffline(deviceInfo); +} + +void DeviceManagerNotify::OnDeviceChanged(std::string &pkgName, const DmDeviceInfo &deviceInfo) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceChanged pkgName:%s", pkgName.c_str()); + std::lock_guard autoLock(lock_); + if (deviceStateCallback_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDeviceChangedcallback not register"); + return; + } + deviceStateCallback_[pkgName]->OnDeviceChanged(deviceInfo); +} + +void DeviceManagerNotify::OnDeviceFound(std::string &pkgName, uint16_t subscribeId, + const DmDeviceInfo &deviceInfo) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceFound pkgName:%s, subscribeId:%d.", pkgName.c_str(), + (int32_t)subscribeId); + std::lock_guard autoLock(lock_); + if (deviceDiscoverCallbacks_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDeviceFound: no register discoverCallback for this package"); + return; + } + std::map>& discoverCallMap = deviceDiscoverCallbacks_[pkgName]; + auto iter = discoverCallMap.find(subscribeId); + if (iter == discoverCallMap.end()) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDeviceFound: no register discoverCallback for subscribeId %d", + subscribeId); + return; + } + iter->second->OnDeviceFound(subscribeId, deviceInfo); +} + +void DeviceManagerNotify::OnDiscoverFailed(std::string &pkgName, uint16_t subscribeId, int32_t failedReason) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnDiscoverFailed pkgName:%s, subscribeId %d, reason %d", + pkgName.c_str(), subscribeId, failedReason); + std::lock_guard autoLock(lock_); + if (deviceDiscoverCallbacks_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDiscoverFailed: no register discoverCallback for this package"); + return; + } + std::map>& discoverCallMap = deviceDiscoverCallbacks_[pkgName]; + auto iter = discoverCallMap.find(subscribeId); + if (iter == discoverCallMap.end()) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDiscoverFailed: no register discoverCallback for subscribeId %d", + subscribeId); + return; + } + iter->second->OnDiscoverFailed(subscribeId, failedReason); +} + +void DeviceManagerNotify::OnDiscoverySuccess(std::string &pkgName, uint16_t subscribeId) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnDiscoverySuccess pkgName:%s, subscribeId:%d.", pkgName.c_str(), + subscribeId); + std::lock_guard autoLock(lock_); + if (deviceDiscoverCallbacks_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDiscoverySuccess: no register discoverCallback for this package"); + return; + } + std::map>& discoverCallMap = deviceDiscoverCallbacks_[pkgName]; + auto iter = discoverCallMap.find(subscribeId); + if (iter == discoverCallMap.end()) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnDiscoverySuccess: no register discoverCallback for subscribeId %d", + subscribeId); + return; + } + iter->second->OnDiscoverySuccess(subscribeId); +} + +void DeviceManagerNotify::OnAuthResult(std::string &pkgName, std::string &deviceId, int32_t pinToken, + uint32_t status, uint32_t reason) +{ + DMLOG(DM_LOG_INFO, "DeviceManagerNotify::OnAuthResult pkgName:%s, status:%d, reason:%d", + pkgName.c_str(), status, reason); + std::lock_guard autoLock(lock_); + if (authenticateCallback_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnAuthResult: no register authCallback for this package"); + return; + } + std::map>& authCallMap = authenticateCallback_[pkgName]; + auto iter = authCallMap.find(deviceId); + if (iter == authCallMap.end()) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnAuthResult: no register authCallback for deviceID "); + return; + } + iter->second->OnAuthResult(deviceId, pinToken, status, reason); + authenticateCallback_[pkgName].erase(deviceId); + if (authenticateCallback_[pkgName].empty()) { + authenticateCallback_.erase(pkgName); + } +} + +void DeviceManagerNotify::OnCheckAuthResult(std::string &pkgName, std::string &deviceId, int32_t resultCode, + int32_t flag) +{ + DMLOG(DM_LOG_INFO, "DeviceManagerNotify::OnCheckAuthResult pkgName:%s, resultCode:%d, flag:%d", + pkgName.c_str(), resultCode, flag); + std::lock_guard autoLock(lock_); + if (checkauthcallback_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnCheckAuthResult: no register authCallback for this package"); + return; + } + std::map>& CheckAuthCallmap = checkauthcallback_[pkgName]; + auto iter = CheckAuthCallmap.find(deviceId); + if (iter == CheckAuthCallmap.end()) { + DMLOG(DM_LOG_ERROR, "DeviceManager OnCheckAuthResult: no register CheckAuthCallmap for deviceID"); + return; + } + iter->second->OnCheckAuthResult(deviceId, resultCode, flag); + checkauthcallback_[pkgName].erase(deviceId); + if (checkauthcallback_[pkgName].empty()) { + checkauthcallback_.erase(pkgName); + } +} + +void DeviceManagerNotify::OnFaCall(std::string &pkgName, std::string ¶mJson) +{ + DMLOG(DM_LOG_INFO, "DeviceManager OnFaCallback pkgName:%s", pkgName.c_str()); + std::lock_guard autoLock(lock_); + if (dmFaCallback_.count(pkgName) == 0) { + DMLOG(DM_LOG_ERROR, "DeviceManager DmFaCallback not register"); + return; + } + dmFaCallback_[pkgName]->OnCall(paramJson); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn deleted file mode 100644 index f2ea6932d67bf9e898ceeb8f77922f9c0a3b0a74..0000000000000000000000000000000000000000 --- a/interfaces/kits/js/BUILD.gn +++ /dev/null @@ -1,82 +0,0 @@ -# Copyright (C) 2021 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. - -import("//build/ohos.gni") -import("//foundation/distributedhardware/devicemanager/devicemanager.gni") - -config("dmnativejs_config") { - visibility = [ ":*" ] - include_dirs = [ - "//third_party/node/src", - "//foundation/ace/napi/native_engine", - "//foundation/ace/napi/interfaces/kits", - "//utils/native/base/include", - "include", - "${common_path}/log/include", - "${common_path}/utils/include", - "${innerkits_path}/native_cpp/include", - ] - - cflags = [ - "-Wall", - "-Werror", - "-Wdate-time", - "-Wfloat-equal", - "-Wshadow", - "-Wformat=2", - "-fdata-sections", - "-ffunction-sections", - "-Os", - ] - - cflags_cc = [ - "-Os", - ] -} - -ohos_shared_library("devicemanager") { - sources = [ - "src/native_devicemanager_js.cpp", - "src/dm_native_event.cpp", - ] - - configs = [ ":dmnativejs_config" ] - - deps = [ - "//utils/native/base:utils", - "//foundation/ace/napi:ace_napi", - "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", - ] - - defines = [ - "DH_LOG_TAG=\"devicemanagerkit_js\"", - "LOG_DOMAIN=0xD004100", - ] - - external_deps = [ - "appexecfwk_standard:appexecfwk_base", - "appexecfwk_standard:appexecfwk_core", - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", - ] - - subsystem_name = "distributedhardware" - relative_install_dir = "module/distributedhardware" - part_name = "device_manager_base" -} - -group("devicemanager_native_js") { - deps = [ ":devicemanager" ] -} diff --git a/interfaces/kits/js/include/native_devicemanager_js.h b/interfaces/kits/js/include/native_devicemanager_js.h deleted file mode 100644 index 872d7b457bef0d46b4e4a5bbbc00afc2b732869b..0000000000000000000000000000000000000000 --- a/interfaces/kits/js/include/native_devicemanager_js.h +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H -#define OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H - -#include -#include -#include "napi/native_api.h" -#include "napi/native_node_api.h" -#include "device_manager_callback.h" -#include "dm_native_event.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" - -const int DM_NAPI_BUF_LENGTH = 256; - -struct AsyncCallbackInfo { - napi_env env = nullptr; - napi_async_work asyncWork = nullptr; - - char bundleName[DM_NAPI_BUF_LENGTH] = {0}; - size_t bundleNameLen = 0; - - napi_ref callback = nullptr; - int32_t status = -1; -}; - -enum DmNapiDevStateChangeAction { - ONLINE = 0, - READY = 1, - OFFLINE = 2, - CHANGE = 3 -}; - -class DmNapiInitCallback : public OHOS::DistributedHardware::DmInitCallback { -public: - explicit DmNapiInitCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiInitCallback() {} - void OnRemoteDied() override; - -private: - std::string bundleName_; -}; - -class DmNapiDeviceStateCallback : public OHOS::DistributedHardware::DeviceStateCallback { -public: - explicit DmNapiDeviceStateCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiDeviceStateCallback() {}; - void OnDeviceOnline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; - void OnDeviceReady(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; - void OnDeviceOffline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; - void OnDeviceChanged(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; - -private: - std::string bundleName_; -}; - -class DmNapiDiscoverCallback : public OHOS::DistributedHardware::DiscoverCallback { -public: - explicit DmNapiDiscoverCallback(std::string &bundleName) : refCount_(0), bundleName_(bundleName) {} - virtual ~DmNapiDiscoverCallback() {}; - void OnDeviceFound(uint16_t subscribeId, OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; - void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) override; - void OnDiscoverySuccess(uint16_t subscribeId) override; - void IncreaseRefCount(); - void DecreaseRefCount(); - int32_t GetRefCount(); - -private: - std::atomic refCount_; - std::string bundleName_; -}; - -class DmNapiAuthenticateCallback : public OHOS::DistributedHardware::AuthenticateCallback { -public: - explicit DmNapiAuthenticateCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiAuthenticateCallback() {}; - void OnAuthResult(std::string &deviceId, int32_t status, int32_t reason) override; - -private: - std::string bundleName_; -}; - -class DeviceManagerNapi : public DmNativeEvent { -public: - explicit DeviceManagerNapi(napi_env env, napi_value thisVar); - virtual ~DeviceManagerNapi(); - static napi_value Init(napi_env env, napi_value exports); - static napi_value Constructor(napi_env env, napi_callback_info info); - static napi_value CreateDeviceManager(napi_env env, napi_callback_info info); - static napi_value ReleaseDeviceManager(napi_env env, napi_callback_info info); - static napi_value GetTrustedDeviceListSync(napi_env env, napi_callback_info info); - static napi_value StartDeviceDiscoverSync(napi_env env, napi_callback_info info); - static napi_value StopDeviceDiscoverSync(napi_env env, napi_callback_info info); - static napi_value AuthenticateDeviceSync(napi_env env, napi_callback_info info); - static napi_value JsOn(napi_env env, napi_callback_info info); - static napi_value JsOff(napi_env env, napi_callback_info info); - static void HandleCreateDmCallBack(const napi_env &env, AsyncCallbackInfo *asCallbackInfo); - static DeviceManagerNapi *GetDeviceManagerNapi(std::string &buldleName); - static void CreateDmCallback(std::string &bundleName, std::string &eventType); - static void ReleaseDmCallback(std::string &bundleName, std::string &eventType); - static void DeviceInfoToJsArray(const napi_env& env, - const std::vector& vecDevInfo, - const int idx, napi_value& arrayResult); - static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, - napi_value& result); - static void SetValueUtf8String(const napi_env& env, const std::string& fieldStr, const std::string& str, - napi_value& result); - static void JsObjectToString(const napi_env& env, const napi_value& object, - const std::string& fieldStr, const int bufLen, std::string& fieldRef); - static void JsObjectToBool(const napi_env& env, const napi_value& object, - const std::string& fieldStr, bool& fieldRef); - static void JsObjectToInt(const napi_env& env, const napi_value& object, const std::string& fieldStr, - int& fieldRef); - static int32_t JsToDmSubscribeInfo(const napi_env& env, const napi_value& object, - OHOS::DistributedHardware::DmSubscribeInfo& info); - static void JsToDmDeviceInfo(const napi_env& env, const napi_value& object, - OHOS::DistributedHardware::DmDeviceInfo& info); - void OnDeviceStateChange(DmNapiDevStateChangeAction action, - const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo); - void OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo); - void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason); - void OnAuthResult(const std::string& deviceId, int32_t status, int32_t reason); - -private: - napi_env env_; - napi_ref wrapper_; - static napi_ref sConstructor_; - std::string bundleName_; -}; - -#endif // OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H diff --git a/interfaces/kits/js/src/dm_native_event.cpp b/interfaces/kits/js/src/dm_native_event.cpp deleted file mode 100644 index d3aca3d174e0a67ac2ef93dd9da2d0d05bc1b4ef..0000000000000000000000000000000000000000 --- a/interfaces/kits/js/src/dm_native_event.cpp +++ /dev/null @@ -1,106 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "dm_native_event.h" - -#include "device_manager_log.h" - -using namespace OHOS::DistributedHardware; - -DmNativeEvent::DmNativeEvent(napi_env env, napi_value thisVar) -{ - env_ = env; - thisVarRef_ = nullptr; - napi_create_reference(env, thisVar, 1, &thisVarRef_); -} - -DmNativeEvent::~DmNativeEvent() -{ - for (auto iter = eventMap_.begin(); iter != eventMap_.end(); iter++) { - auto listener = iter->second; - napi_delete_reference(env_, listener->handlerRef); - } - eventMap_.clear(); - napi_delete_reference(env_, thisVarRef_); -} - -void DmNativeEvent::On(std::string &eventType, napi_value handler) -{ - HILOGI("DmNativeEvent On in for event: %{public}s", eventType.c_str()); - auto listener = std::make_shared(); - listener->eventType = eventType; - napi_create_reference(env_, handler, 1, &listener->handlerRef); - eventMap_[eventType] = listener; -} - -void DmNativeEvent::Off(std::string &eventType) -{ - HILOGI("DmNativeEvent Off in for event: %{public}s", eventType.c_str()); - napi_handle_scope scope = nullptr; - napi_open_handle_scope(env_, &scope); - if (scope == nullptr) { - HILOGE("scope is nullptr"); - return; - } - - auto iter = eventMap_.find(eventType); - if (iter == eventMap_.end()) { - HILOGE("eventType %{public}s not find", eventType.c_str()); - return; - } - auto listener = iter->second; - napi_delete_reference(env_, listener->handlerRef); - eventMap_.erase(eventType); - napi_close_handle_scope(env_, scope); -} - -void DmNativeEvent::OnEvent(const std::string &eventType, size_t argc, const napi_value* argv) -{ - HILOGI("OnEvent for %{public}s", eventType.c_str()); - napi_handle_scope scope = nullptr; - napi_open_handle_scope(env_, &scope); - if (scope == nullptr) { - HILOGE("scope is nullptr"); - return; - } - - auto iter = eventMap_.find(eventType); - if (iter == eventMap_.end()) { - HILOGE("eventType %{public}s not find", eventType.c_str()); - return; - } - auto listener = iter->second; - napi_value thisVar = nullptr; - napi_status status = napi_get_reference_value(env_, thisVarRef_, &thisVar); - if (status != napi_ok) { - HILOGE("napi_get_reference_value thisVar for %{public}s failed, status=%{public}d", eventType.c_str(), status); - return; - } - - napi_value handler = nullptr; - status = napi_get_reference_value(env_, listener->handlerRef, &handler); - if (status != napi_ok) { - HILOGE("napi_get_reference_value handler for %{public}s failed, status=%{public}d", eventType.c_str(), status); - return; - } - - napi_value callResult = nullptr; - status = napi_call_function(env_, thisVar, handler, argc, argv, &callResult); - if (status != napi_ok) { - HILOGE("napi_call_function for %{public}s failed, status=%{public}d", eventType.c_str(), status); - return; - } - napi_close_handle_scope(env_, scope); -} \ No newline at end of file diff --git a/interfaces/kits/js/src/native_devicemanager_js.cpp b/interfaces/kits/js/src/native_devicemanager_js.cpp deleted file mode 100644 index 15a9df211b112cd8031153492036e3244eba92c2..0000000000000000000000000000000000000000 --- a/interfaces/kits/js/src/native_devicemanager_js.cpp +++ /dev/null @@ -1,886 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "native_devicemanager_js.h" - -#include - -#include "device_manager.h" -#include "device_manager_log.h" - -using namespace OHOS::DistributedHardware; - -namespace { -#define GET_PARAMS(env, info, num) \ - size_t argc = num; \ - napi_value argv[num] = { nullptr }; \ - napi_value thisVar = nullptr; \ - void *data = nullptr; \ - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisVar, &data)) - -const std::string DM_NAPI_EVENT_DEVICE_STATE_CHANGE = "deviceStateChange"; -const std::string DM_NAPI_EVENT_DEVICE_FOUND = "deviceFound"; -const std::string DM_NAPI_EVENT_DEVICE_DISCOVER_FAIL = "discoverFail"; -const std::string DM_NAPI_EVENT_DEVICE_AUTH_RESULT = "authResult"; -const std::string DM_NAPI_EVENT_DEVICE_SERVICE_DIE = "serviceDie"; - -const std::string DEVICE_MANAGER_NAPI_CLASS_NAME = "DeviceManager"; - -const int DM_NAPI_ARGS_ONE = 1; -const int DM_NAPI_ARGS_TWO = 2; -const int DM_NAPI_SUB_ID_MAX = 65535; - -std::map g_deviceManagerMap; -std::map> g_initCallbackMap; -std::map> g_deviceStateCallbackMap; -std::map> g_discoverCallbackMap; -std::map> g_authCallbackMap; -} - -enum DmNapiSubscribeCap { - DM_NAPI_SUBSCRIBE_CAPABILITY_DDMP = 0 -}; - -napi_ref DeviceManagerNapi::sConstructor_ = nullptr; - -void DmNapiInitCallback::OnRemoteDied() -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnRemoteDied, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnEvent("serviceDie", 0, nullptr); -} - -void DmNapiDeviceStateCallback::OnDeviceOnline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceOnline, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::ONLINE, deviceInfo); -} - -void DmNapiDeviceStateCallback::OnDeviceReady(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceOnline, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::READY, deviceInfo); -} - -void DmNapiDeviceStateCallback::OnDeviceOffline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceOffline, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::OFFLINE, deviceInfo); -} - -void DmNapiDeviceStateCallback::OnDeviceChanged(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceChanged, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::CHANGE, deviceInfo); -} - -void DmNapiDiscoverCallback::OnDeviceFound(uint16_t subscribeId, - OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceFound, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - - HILOGI("OnDeviceFound for %{public}s, subscribeId %{public}d", bundleName_.c_str(), (int32_t)subscribeId); - deviceManagerNapi->OnDeviceFound(subscribeId, deviceInfo); -} - -void DmNapiDiscoverCallback::OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDiscoverFailed, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - - deviceManagerNapi->OnDiscoverFailed(subscribeId, failedReason); -} - -void DmNapiDiscoverCallback::OnDiscoverySuccess(uint16_t subscribeId) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnDiscoverySuccess, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - HILOGE("DiscoverySuccess for %{public}s, subscribeId %{public}d", bundleName_.c_str(), (int32_t)subscribeId); -} - -void DmNapiDiscoverCallback::IncreaseRefCount() -{ - refCount_++; -} - -void DmNapiDiscoverCallback::DecreaseRefCount() -{ - refCount_--; -} - -int32_t DmNapiDiscoverCallback::GetRefCount() -{ - return refCount_; -} - -void DmNapiAuthenticateCallback::OnAuthResult(std::string &deviceId, int32_t status, int32_t reason) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - HILOGE("OnAuthResult, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnAuthResult(deviceId, status, reason); -} - -DeviceManagerNapi::DeviceManagerNapi(napi_env env, napi_value thisVar) : DmNativeEvent(env, thisVar) -{ - env_ = env; - wrapper_ = nullptr; -} - -DeviceManagerNapi::~DeviceManagerNapi() -{ - if (wrapper_ != nullptr) { - napi_delete_reference(env_, wrapper_); - } -} - -DeviceManagerNapi *DeviceManagerNapi::GetDeviceManagerNapi(std::string &buldleName) -{ - auto iter = g_deviceManagerMap.find(buldleName); - if (iter == g_deviceManagerMap.end()) { - return nullptr; - } - return iter->second; -} - -void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, - const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - napi_value result; - napi_create_object(env_, &result); - SetValueInt32(env_, "action", (int)action, result); - - napi_value device; - napi_create_object(env_, &device); - SetValueUtf8String(env_, "deviceId", deviceInfo.deviceId, device); - SetValueUtf8String(env_, "deviceName", deviceInfo.deviceName, device); - SetValueInt32(env_, "deviceType", (int)deviceInfo.deviceTypeId, device); - - napi_set_named_property(env_, result, "device", device); - OnEvent("deviceStateChange", DM_NAPI_ARGS_ONE, &result); -} - -void DeviceManagerNapi::OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceFound for subscribeId %{public}d", (int32_t)subscribeId); - napi_value result; - napi_create_object(env_, &result); - SetValueInt32(env_, "subscribeId", (int)subscribeId, result); - - napi_value device; - napi_create_object(env_, &device); - SetValueUtf8String(env_, "deviceId", deviceInfo.deviceId, device); - SetValueUtf8String(env_, "deviceName", deviceInfo.deviceName, device); - SetValueInt32(env_, "deviceType", (int)deviceInfo.deviceTypeId, device); - - napi_set_named_property(env_, result, "device", device); - OnEvent("deviceFound", DM_NAPI_ARGS_ONE, &result); -} - -void DeviceManagerNapi::OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) -{ - HILOGI("OnDiscoverFailed for subscribeId %{public}d", (int32_t)subscribeId); - napi_value result; - napi_create_object(env_, &result); - SetValueInt32(env_, "subscribeId", (int)subscribeId, result); - SetValueInt32(env_, "reason", (int)failedReason, result); - OnEvent("discoverFail", DM_NAPI_ARGS_ONE, &result); -} - -void DeviceManagerNapi::OnAuthResult(const std::string& deviceId, int32_t status, int32_t reason) -{ - HILOGI("OnAuthResult for status: %{public}d, reason: %{public}d", status, reason); - napi_value result; - napi_create_object(env_, &result); - - SetValueUtf8String(env_, "deviceId", deviceId, result); - SetValueInt32(env_, "status", (int)status, result); - SetValueInt32(env_, "reason", (int)reason, result); - OnEvent("authResult", DM_NAPI_ARGS_ONE, &result); -} - -void DeviceManagerNapi::SetValueUtf8String(const napi_env &env, const std::string& fieldStr, const std::string& str, - napi_value& result) -{ - napi_value value; - napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value); - napi_set_named_property(env, result, fieldStr.c_str(), value); -} - -void DeviceManagerNapi::SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, - napi_value& result) -{ - napi_value value; - napi_create_int32(env, intValue, &value); - napi_set_named_property(env, result, fieldStr.c_str(), value); -} - -void DeviceManagerNapi::DeviceInfoToJsArray(const napi_env& env, - const std::vector& vecDevInfo, - const int idx, napi_value& arrayResult) -{ - napi_value result; - napi_create_object(env, &result); - - SetValueUtf8String(env, "deviceId", vecDevInfo[idx].deviceId.c_str(), result); - SetValueUtf8String(env, "deviceName", vecDevInfo[idx].deviceName.c_str(), result); - SetValueInt32(env, "deviceType", (int)vecDevInfo[idx].deviceTypeId, result); - - napi_status status = napi_set_element(env, arrayResult, idx, result); - if (status != napi_ok) { - HILOGE("DmDeviceInfo To JsArray set element error: %{public}d", status); - } -} - -void DeviceManagerNapi::JsObjectToString(const napi_env& env, const napi_value& object, - const std::string& fieldStr, const int bufLen, std::string& fieldRef) -{ - bool hasProperty = false; - NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); - if (hasProperty) { - napi_value field; - napi_valuetype valueType; - - napi_get_named_property(env, object, fieldStr.c_str(), &field); - NAPI_CALL_RETURN_VOID(env, napi_typeof(env, field, &valueType)); - NAPI_ASSERT_RETURN_VOID(env, valueType == napi_string, "Wrong argument type. String expected."); - if (bufLen <= 0) { - HILOGE("js object to str bufLen invalid"); - return; - } - std::unique_ptr buf = std::make_unique(bufLen); - if (buf == nullptr) { - HILOGE("js object to str malloc failed"); - return; - } - (void)memset_s(buf.get(), bufLen, 0, bufLen); - size_t result = 0; - NAPI_CALL_RETURN_VOID(env, napi_get_value_string_utf8(env, field, buf.get(), bufLen, &result)); - fieldRef = buf.get(); - } else { - HILOGE("devicemanager napi js to str no property: %{public}s", fieldStr.c_str()); - } -} - -void DeviceManagerNapi::JsObjectToInt(const napi_env& env, const napi_value& object, - const std::string& fieldStr, int& fieldRef) -{ - bool hasProperty = false; - NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); - if (hasProperty) { - napi_value field; - napi_valuetype valueType; - - napi_get_named_property(env, object, fieldStr.c_str(), &field); - NAPI_CALL_RETURN_VOID(env, napi_typeof(env, field, &valueType)); - NAPI_ASSERT_RETURN_VOID(env, valueType == napi_number, "Wrong argument type. Number expected."); - napi_get_value_int32(env, field, &fieldRef); - } else { - HILOGE("devicemanager napi js to int no property: %{public}s", fieldStr.c_str()); - } -} - -void DeviceManagerNapi::JsObjectToBool(const napi_env& env, const napi_value& object, - const std::string& fieldStr, bool& fieldRef) -{ - bool hasProperty = false; - NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); - if (hasProperty) { - napi_value field; - napi_valuetype valueType; - - napi_get_named_property(env, object, fieldStr.c_str(), &field); - NAPI_CALL_RETURN_VOID(env, napi_typeof(env, field, &valueType)); - NAPI_ASSERT_RETURN_VOID(env, valueType == napi_boolean, "Wrong argument type. Bool expected."); - napi_get_value_bool(env, field, &fieldRef); - } else { - HILOGE("devicemanager napi js to bool no property: %{public}s", fieldStr.c_str()); - } -} - -int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env& env, const napi_value& object, - OHOS::DistributedHardware::DmSubscribeInfo& info) -{ - int subscribeId = -1; - JsObjectToInt(env, object, "subscribeId", subscribeId); - if (subscribeId < 0 || subscribeId > DM_NAPI_SUB_ID_MAX) { - HILOGE("DeviceManagerNapi::JsToDmSubscribeInfo, subscribeId error, subscribeId: %{public}d ", subscribeId); - return -1; - } - - info.subscribeId = (uint16_t)subscribeId; - - int mode = -1; - JsObjectToInt(env, object, "mode", mode); - info.mode = (DmDiscoverMode)mode; - - int medium = -1; - JsObjectToInt(env, object, "medium", medium); - info.medium = (DmExchangeMedium)medium; - - int freq = -1; - JsObjectToInt(env, object, "freq", freq); - info.freq = (DmExchangeFreq)freq; - - JsObjectToBool(env, object, "isSameAccount", info.isSameAccount); - JsObjectToBool(env, object, "isWakeRemote", info.isWakeRemote); - - int capability = -1; - JsObjectToInt(env, object, "capability", capability); - if (capability == DmNapiSubscribeCap::DM_NAPI_SUBSCRIBE_CAPABILITY_DDMP) { - info.capability = std::string(DM_CAPABILITY_DDMP); - } - return 0; -} - -void DeviceManagerNapi::JsToDmDeviceInfo(const napi_env& env, const napi_value& object, - OHOS::DistributedHardware::DmDeviceInfo& info) -{ - JsObjectToString(env, object, "deviceId", DM_NAPI_BUF_LENGTH, info.deviceId); - JsObjectToString(env, object, "deviceName", DM_NAPI_BUF_LENGTH, info.deviceName); - int deviceType = -1; - JsObjectToInt(env, object, "deviceType", deviceType); - info.deviceTypeId = (DMDeviceType)deviceType; -} - - -void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &eventType) -{ - HILOGE("CreateDmCallback for bunderName %{public}s eventType %{public}s", bundleName.c_str(), eventType.c_str()); - if (eventType == DM_NAPI_EVENT_DEVICE_STATE_CHANGE) { - auto iter = g_deviceStateCallbackMap.find(bundleName); - if (iter == g_deviceStateCallbackMap.end()) { - auto callback = std::make_shared(bundleName); - std::string extra = ""; - int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(bundleName, extra, callback); - if (ret != 0) { - HILOGE("RegisterDevStateCallback failed for bunderName %{public}s", bundleName.c_str()); - return; - } - g_deviceStateCallbackMap[bundleName] = callback; - } - return; - } - - if (eventType == DM_NAPI_EVENT_DEVICE_FOUND || eventType == DM_NAPI_EVENT_DEVICE_DISCOVER_FAIL) { - std::shared_ptr discoverCallback = nullptr; - auto iter = g_discoverCallbackMap.find(bundleName); - if (iter == g_discoverCallbackMap.end()) { - auto callback = std::make_shared(bundleName); - g_discoverCallbackMap[bundleName] = callback; - discoverCallback = callback; - } else { - discoverCallback = iter->second; - } - - discoverCallback->IncreaseRefCount(); - return; - } - - if (eventType == DM_NAPI_EVENT_DEVICE_AUTH_RESULT) { - auto iter = g_authCallbackMap.find(bundleName); - if (iter == g_authCallbackMap.end()) { - auto callback = std::make_shared(bundleName); - g_authCallbackMap[bundleName] = callback; - } - return; - } -} - -void DeviceManagerNapi::ReleaseDmCallback(std::string &bundleName, std::string &eventType) -{ - if (eventType == DM_NAPI_EVENT_DEVICE_STATE_CHANGE) { - auto iter = g_deviceStateCallbackMap.find(bundleName); - if (iter == g_deviceStateCallbackMap.end()) { - HILOGE("ReleaseDmCallback: cannot find stateCallback for bunderName %{public}s", bundleName.c_str()); - return; - } - int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(bundleName); - if (ret != 0) { - HILOGE("RegisterDevStateCallback failed for bunderName %{public}s", bundleName.c_str()); - return; - } - g_deviceStateCallbackMap.erase(bundleName); - return; - } - - if (eventType == DM_NAPI_EVENT_DEVICE_FOUND || eventType == DM_NAPI_EVENT_DEVICE_DISCOVER_FAIL) { - std::shared_ptr discoverCallback = nullptr; - auto iter = g_discoverCallbackMap.find(bundleName); - if (iter == g_discoverCallbackMap.end()) { - return; - } - - discoverCallback = iter->second; - discoverCallback->DecreaseRefCount(); - if (discoverCallback->GetRefCount() == 0) { - g_discoverCallbackMap.erase(bundleName); - } - return; - } - - if (eventType == DM_NAPI_EVENT_DEVICE_AUTH_RESULT) { - auto iter = g_authCallbackMap.find(bundleName); - if (iter == g_authCallbackMap.end()) { - return; - } - - g_authCallbackMap.erase(bundleName); - } -} - -napi_value DeviceManagerNapi::GetTrustedDeviceListSync(napi_env env, napi_callback_info info) -{ - HILOGI("GetTrustedDeviceList in"); - size_t argc = 0; - napi_value thisVar = nullptr; - napi_value array = nullptr; - - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); - NAPI_ASSERT(env, argc == 0, "Wrong number of arguments"); - - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - std::string extra = ""; - std::vector devList; - int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(deviceManagerWrapper->bundleName_, extra, devList); - if (ret != 0) { - HILOGE("GetTrustedDeviceList for bunderName %{public}s failed, ret %{public}d", - deviceManagerWrapper->bundleName_.c_str(), ret); - return array; - } - - if (devList.size() > 0) { - bool isArray = false; - napi_create_array(env, &array); - napi_is_array(env, array, &isArray); - if (isArray == false) { - HILOGE("napi_create_array fail"); - } - - for (size_t i = 0; i != devList.size(); ++i) { - DeviceInfoToJsArray(env, devList, i, array); - } - } else { - HILOGE("devList is null"); - } - - return array; -} - -napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callback_info info) -{ - HILOGI("StartDeviceDiscoverSync in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); - napi_value result = nullptr; - napi_valuetype valueType; - napi_typeof(env, argv[0], &valueType); - NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected."); - - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - - std::shared_ptr discoverCallback = nullptr; - auto iter = g_discoverCallbackMap.find(deviceManagerWrapper->bundleName_); - if (iter == g_discoverCallbackMap.end()) { - discoverCallback = std::make_shared(deviceManagerWrapper->bundleName_); - g_discoverCallbackMap[deviceManagerWrapper->bundleName_] = discoverCallback; - } else { - discoverCallback = iter->second; - } - DmSubscribeInfo subInfo; - int32_t res = JsToDmSubscribeInfo(env, argv[0], subInfo); - NAPI_ASSERT(env, res == 0, "Wrong subscribeId "); - - int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(deviceManagerWrapper->bundleName_, - subInfo, discoverCallback); - if (ret != 0) { - HILOGE("StartDeviceDiscovery for bunderName %{public}s failed, ret %{public}d", - deviceManagerWrapper->bundleName_.c_str(), ret); - return result; - } - - napi_get_undefined(env, &result); - return result; -} - -napi_value DeviceManagerNapi::StopDeviceDiscoverSync(napi_env env, napi_callback_info info) -{ - HILOGI("StopDeviceDiscoverSync in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); - napi_value result = nullptr; - napi_valuetype valueType; - napi_typeof(env, argv[0], &valueType); - NAPI_ASSERT(env, valueType == napi_number, "Wrong argument type. Object expected."); - - int32_t subscribeId = 0; - napi_get_value_int32(env, argv[0], &subscribeId); - NAPI_ASSERT(env, subscribeId <= DM_NAPI_SUB_ID_MAX, "Wrong argument. subscribeId Too Big."); - - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(deviceManagerWrapper->bundleName_, - (int16_t)subscribeId); - if (ret != 0) { - HILOGE("StopDeviceDiscovery for bunderName %{public}s failed, ret %{public}d", - deviceManagerWrapper->bundleName_.c_str(), ret); - return result; - } - - napi_get_undefined(env, &result); - return result; -} - -napi_value DeviceManagerNapi::AuthenticateDeviceSync(napi_env env, napi_callback_info info) -{ - HILOGI("AuthenticateDeviceSync in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); - napi_value result = nullptr; - napi_valuetype valueType; - napi_typeof(env, argv[0], &valueType); - NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected."); - - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - - std::shared_ptr authCallback = nullptr; - auto iter = g_authCallbackMap.find(deviceManagerWrapper->bundleName_); - if (iter == g_authCallbackMap.end()) { - authCallback = std::make_shared(deviceManagerWrapper->bundleName_); - g_authCallbackMap[deviceManagerWrapper->bundleName_] = authCallback; - } else { - authCallback = iter->second; - } - DmDeviceInfo deviceInfo; - JsToDmDeviceInfo(env, argv[0], deviceInfo); - - std::string extra = ""; - int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(deviceManagerWrapper->bundleName_, deviceInfo, - extra, authCallback); - if (ret != 0) { - HILOGE("AuthenticateDevice for bunderName %{public}s failed, ret %{public}d", - deviceManagerWrapper->bundleName_.c_str(), ret); - return result; - } - - napi_get_undefined(env, &result); - return result; -} - -napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) -{ - HILOGI("JsOn in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); - NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_TWO, "Wrong number of arguments, required 2"); - - napi_valuetype eventValueType = napi_undefined; - napi_typeof(env, argv[0], &eventValueType); - NAPI_ASSERT(env, eventValueType == napi_string, "type mismatch for parameter 1"); - - napi_valuetype eventHandleType = napi_undefined; - napi_typeof(env, argv[1], &eventHandleType); - NAPI_ASSERT(env, eventHandleType == napi_function, "type mismatch for parameter 2"); - - size_t typeLen = 0; - napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typeLen); - - NAPI_ASSERT(env, typeLen > 0, "typeLen == 0"); - std::unique_ptr type = std::make_unique(typeLen + 1); - napi_get_value_string_utf8(env, argv[0], type.get(), typeLen + 1, &typeLen); - - std::string eventType = type.get(); - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - - HILOGI("JsOn for bunderName %{public}s, eventType %{public}s ", deviceManagerWrapper->bundleName_.c_str(), - eventType.c_str()); - deviceManagerWrapper->On(eventType, argv[1]); - CreateDmCallback(deviceManagerWrapper->bundleName_, eventType); - - napi_value result = nullptr; - napi_get_undefined(env, &result); - return result; -} - -napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) -{ - HILOGI("JsOff in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); - size_t requireArgc = 1; - NAPI_ASSERT(env, argc >= requireArgc, "Wrong number of arguments, required 1"); - - napi_valuetype eventValueType = napi_undefined; - napi_typeof(env, argv[0], &eventValueType); - NAPI_ASSERT(env, eventValueType == napi_string, "type mismatch for parameter 1"); - - if (argc > requireArgc) { - napi_valuetype eventHandleType = napi_undefined; - napi_typeof(env, argv[1], &eventHandleType); - NAPI_ASSERT(env, eventValueType == napi_function, "type mismatch for parameter 2"); - } - - size_t typeLen = 0; - napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typeLen); - - NAPI_ASSERT(env, typeLen > 0, "typeLen == 0"); - std::unique_ptr type = std::make_unique(typeLen + 1); - napi_get_value_string_utf8(env, argv[0], type.get(), typeLen + 1, &typeLen); - - std::string eventType = type.get(); - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - - HILOGI("JsOff for bunderName %{public}s, eventType %{public}s ", deviceManagerWrapper->bundleName_.c_str(), - eventType.c_str()); - deviceManagerWrapper->Off(eventType); - ReleaseDmCallback(deviceManagerWrapper->bundleName_, eventType); - - napi_value result = nullptr; - napi_get_undefined(env, &result); - return result; -} - -napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_info info) -{ - HILOGI("ReleaseDeviceManager in"); - size_t argc = 0; - napi_value thisVar = nullptr; - napi_value result = nullptr; - - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); - NAPI_ASSERT(env, argc == 0, "Wrong number of arguments"); - - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - HILOGI("ReleaseDeviceManager for bunderName %{public}s", deviceManagerWrapper->bundleName_.c_str()); - int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(deviceManagerWrapper->bundleName_); - if (ret != 0) { - HILOGE("ReleaseDeviceManager for bunderName %{public}s failed, ret %{public}d", - deviceManagerWrapper->bundleName_.c_str(), ret); - napi_create_uint32(env, ret, &result); - return result; - } - - g_deviceManagerMap.erase(deviceManagerWrapper->bundleName_); - g_initCallbackMap.erase(deviceManagerWrapper->bundleName_); - g_deviceStateCallbackMap.erase(deviceManagerWrapper->bundleName_); - g_discoverCallbackMap.erase(deviceManagerWrapper->bundleName_); - g_authCallbackMap.erase(deviceManagerWrapper->bundleName_); - napi_get_undefined(env, &result); - return result; -} - -void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbackInfo *asCallbackInfo) -{ - napi_value resourceName; - napi_create_string_latin1(env, "createDeviceManagerCallback", NAPI_AUTO_LENGTH, &resourceName); - napi_create_async_work( - env, nullptr, resourceName, - [](napi_env env, void *data) { - (void)env; - AsyncCallbackInfo *asCallbackInfo = (AsyncCallbackInfo *)data; - std::string bundleName = std::string(asCallbackInfo->bundleName); - std::shared_ptr initCallback = std::make_shared(bundleName); - if (DeviceManager::GetInstance().InitDeviceManager(bundleName, initCallback) != 0) { - HILOGE("InitDeviceManager for bunderName %{public}s failed", bundleName.c_str()); - return; - } - g_initCallbackMap[bundleName] = initCallback; - asCallbackInfo->status = 0; - }, - [](napi_env env, napi_status status, void *data) { - (void)status; - AsyncCallbackInfo *asCallbackInfo = (AsyncCallbackInfo *)data; - napi_value result[DM_NAPI_ARGS_TWO] = { 0 }; - napi_value ctor; - napi_value argv; - napi_get_reference_value(env, sConstructor_, &ctor); - napi_create_string_utf8(env, asCallbackInfo->bundleName, NAPI_AUTO_LENGTH, &argv); - napi_status ret = napi_new_instance(env, ctor, DM_NAPI_ARGS_ONE, &argv, &result[1]); - if (ret != napi_ok) { - HILOGE("Create DeviceManagerNapi for bunderName %{public}s failed", asCallbackInfo->bundleName); - asCallbackInfo->status = -1; - } - - if (asCallbackInfo->status == 0) { - HILOGI("InitDeviceManager for bunderName %{public}s success", asCallbackInfo->bundleName); - napi_get_undefined(env, &result[0]); - napi_value callback = nullptr; - napi_value callResult = nullptr; - napi_get_reference_value(env, asCallbackInfo->callback, &callback); - napi_call_function(env, nullptr, callback, DM_NAPI_ARGS_TWO, &result[0], &callResult); - napi_delete_reference(env, asCallbackInfo->callback); - } else { - HILOGI("InitDeviceManager for bunderName %{public}s failed", asCallbackInfo->bundleName); - napi_value message = nullptr; - napi_create_object(env, &result[0]); - napi_create_int32(env, asCallbackInfo->status, &message); - napi_set_named_property(env, result[0], "code", message); - napi_get_undefined(env, &result[1]); - } - napi_delete_async_work(env, asCallbackInfo->asyncWork); - delete asCallbackInfo; - }, - (void *)asCallbackInfo, - &asCallbackInfo->asyncWork); - napi_queue_async_work(env, asCallbackInfo->asyncWork); -} - -napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_info info) -{ - HILOGI("CreateDeviceManager in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); - NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_TWO, "Wrong number of arguments, required 2"); - - napi_valuetype bundleNameValueType = napi_undefined; - napi_typeof(env, argv[0], &bundleNameValueType); - NAPI_ASSERT(env, bundleNameValueType == napi_string, "type mismatch for parameter 0"); - - napi_valuetype funcValueType = napi_undefined; - napi_typeof(env, argv[1], &funcValueType); - NAPI_ASSERT(env, funcValueType == napi_function, "type mismatch for parameter 1"); - - auto *asCallbackInfo = new AsyncCallbackInfo(); - asCallbackInfo->env = env; - napi_get_value_string_utf8(env, argv[0], asCallbackInfo->bundleName, DM_NAPI_BUF_LENGTH - 1, - &asCallbackInfo->bundleNameLen); - napi_create_reference(env, argv[1], 1, &asCallbackInfo->callback); - - HandleCreateDmCallBack(env, asCallbackInfo); - - napi_value result = nullptr; - napi_get_undefined(env, &result); - return result; -} - -napi_value DeviceManagerNapi::Constructor(napi_env env, napi_callback_info info) -{ - HILOGI("DeviceManagerNapi Constructor in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); - NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_ONE, "Wrong number of arguments, required 1"); - - napi_valuetype valueType = napi_undefined; - napi_typeof(env, argv[0], &valueType); - NAPI_ASSERT(env, valueType == napi_string, "type mismatch for parameter 1"); - - char bundleName[DM_NAPI_BUF_LENGTH] = { 0 }; - size_t typeLen = 0; - napi_get_value_string_utf8(env, argv[0], bundleName, sizeof(bundleName), &typeLen); - - HILOGI("create DeviceManagerNapi for packageName:%{public}s", bundleName); - DeviceManagerNapi *obj = new DeviceManagerNapi(env, thisVar); - obj->bundleName_ = std::string(bundleName); - g_deviceManagerMap[obj->bundleName_] = obj; - napi_wrap(env, thisVar, reinterpret_cast(obj), - [](napi_env env, void *data, void *hint) { - (void)env; - (void)hint; - DeviceManagerNapi *deviceManager = (DeviceManagerNapi *)data; - delete deviceManager; - }, - nullptr, &(obj->wrapper_)); - return thisVar; -} - -napi_value DeviceManagerNapi::Init(napi_env env, napi_value exports) -{ - napi_value dmClass; - napi_property_descriptor dmProperties[] = { - DECLARE_NAPI_FUNCTION("release", ReleaseDeviceManager), - DECLARE_NAPI_FUNCTION("getTrustedDeviceListSync", GetTrustedDeviceListSync), - DECLARE_NAPI_FUNCTION("startDeviceDiscovery", StartDeviceDiscoverSync), - DECLARE_NAPI_FUNCTION("stopDeviceDiscovery", StopDeviceDiscoverSync), - DECLARE_NAPI_FUNCTION("authenticateDevice", AuthenticateDeviceSync), - DECLARE_NAPI_FUNCTION("on", JsOn), - DECLARE_NAPI_FUNCTION("off", JsOff) - }; - - napi_property_descriptor static_prop[] = { - DECLARE_NAPI_STATIC_FUNCTION("createDeviceManager", CreateDeviceManager), - }; - - HILOGD("DeviceManagerNapi::Init() is called!"); - NAPI_CALL(env, - napi_define_class(env, DEVICE_MANAGER_NAPI_CLASS_NAME.c_str(), NAPI_AUTO_LENGTH, Constructor, nullptr, - sizeof(dmProperties) / sizeof(dmProperties[0]), dmProperties, &dmClass)); - NAPI_CALL(env, napi_create_reference(env, dmClass, 1, &sConstructor_)); - NAPI_CALL(env, napi_set_named_property(env, exports, DEVICE_MANAGER_NAPI_CLASS_NAME.c_str(), dmClass)); - NAPI_CALL(env, napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop)); - HILOGI("All props and functions are configured.."); - return exports; -} - -/* - * Function registering all props and functions of ohos.distributedhardware - */ -static napi_value Export(napi_env env, napi_value exports) -{ - HILOGI("Export() is called!"); - DeviceManagerNapi::Init(env, exports); - return exports; -} - -/* - * module define - */ -static napi_module g_dmModule = { - .nm_version = 1, - .nm_flags = 0, - .nm_filename = nullptr, - .nm_register_func = Export, - .nm_modname = "distributedhardware.devicemanager", - .nm_priv = ((void *)0), - .reserved = {0} - }; - -/* - * module register - */ -extern "C" __attribute__((constructor)) void RegisterModule(void) -{ - HILOGI("RegisterModule() is called!"); - napi_module_register(&g_dmModule); -} diff --git a/ohos.build b/ohos.build deleted file mode 100644 index 66b59c67a4dce0b0d842a2503df9544d6a254011..0000000000000000000000000000000000000000 --- a/ohos.build +++ /dev/null @@ -1,28 +0,0 @@ -{ - "parts": { - "device_manager_base": { - "variants": ["phone", "wearable", "ivi"], - "inner_kits": [ - { - "type": "so", - "name": "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", - "header": { - "header_base": "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include", - "header_files": [ - "device_manager_proxy.h", - "idevice_manager.h" - ] - } - } - ], - "module_list": [ - "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", - "//foundation/distributedhardware/devicemanager/interfaces/kits/js:devicemanager_native_js", - "//foundation/distributedhardware/devicemanager/services/devicemanagerservice:devicemanagerservice", - "//foundation/distributedhardware/devicemanager/sa_profile:dm_sa_profile" - ], - "system_kits": [] - } - }, - "subsystem": "distributedhardware" -} diff --git a/sa_profile/4802.xml b/sa_profile/4802.xml deleted file mode 100644 index 398977926affe714d592b75c701543622c556616..0000000000000000000000000000000000000000 --- a/sa_profile/4802.xml +++ /dev/null @@ -1,27 +0,0 @@ - - - - foundation - - 4802 - libdevicemanagerservice.z.so - - - true - false - 1 - - diff --git a/sa_profile/BUILD.gn b/sa_profile/BUILD.gn deleted file mode 100644 index 89d88fa4cb2abe85d6ee559ede2365302407b1f2..0000000000000000000000000000000000000000 --- a/sa_profile/BUILD.gn +++ /dev/null @@ -1,20 +0,0 @@ -# Copyright (C) 2021 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. - -import("//build/ohos/sa_profile/sa_profile.gni") - -ohos_sa_profile("dm_sa_profile") { - sources = [ "4802.xml" ] - - part_name = "device_manager_base" -} diff --git a/services/devicemanagerservice/BUILD.gn b/services/devicemanagerservice/BUILD.gn deleted file mode 100644 index 35ff65151579f29751647010c45a91266ab78535..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/BUILD.gn +++ /dev/null @@ -1,93 +0,0 @@ -# Copyright (C) 2021 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. - -import("//build/ohos.gni") -import("//foundation/distributedhardware/devicemanager/devicemanager.gni") - -config("dmservice_config") { - visibility = [ ":*" ] - include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", - "include", - "include/softbus", - "include/authdemo", - "include/util", - "${common_path}/log/include", - "${common_path}/utils/include", - "${innerkits_path}/native_cpp/include", - "//base/security/deviceauth/interfaces/innerkits", - "//third_party/json/include", - "//base/startup/syspara_lite/adapter/native/syspara/include", - ] - - cflags = [ - "-Wall", - "-Werror", - "-Wdate-time", - "-Wfloat-equal", - "-Wshadow", - "-Wformat=2", - "-fvisibility=hidden", - "-fdata-sections", - "-ffunction-sections", - "-Os", - ] - - cflags_cc = [ - "-fvisibility-inlines-hidden", - "-Os", - ] -} - -ohos_shared_library("devicemanagerservice") { - sources = [ - "src/device_manager_service.cpp", - "src/device_manager_stub.cpp", - "src/device_manager_listener_proxy.cpp", - "src/softbus/softbus_adapter.cpp", - "src/authdemo/device_client_channel.cpp", - "src/authdemo/device_server_channel.cpp", - "src/authdemo/hichain_adapter.cpp", - "src/util/anonymous_string.cpp", - ] - - configs = [ ":dmservice_config" ] - - deps = [ - "//utils/native/base:utils", - "${innerkits_path}/native_cpp:devicemanagersdk", - "//base/security/deviceauth/services:deviceauth_sdk", - ] - - defines = [ - "DH_LOG_TAG=\"devicemanager\"", - "LOG_DOMAIN=0xD004100", - ] - - external_deps = [ - "appexecfwk_standard:appexecfwk_base", - "appexecfwk_standard:appexecfwk_core", - "appexecfwk_standard:libeventhandler", - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", - "dsoftbus_standard:softbus_client", - "startup_l2:syspara", - ] - - subsystem_name = "distributedhardware" - - part_name = "device_manager_base" -} diff --git a/services/devicemanagerservice/include/authdemo/device_client_channel.h b/services/devicemanagerservice/include/authdemo/device_client_channel.h deleted file mode 100644 index dac934e17cdaa476561962f69530ea90859489f3..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/authdemo/device_client_channel.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_CLIENT_CHANNEL_H -#define OHOS_DEVICE_CLIENT_CHANNEL_H - -#include -#include - -#include "device_auth.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceClientChannel { -public: - DeviceClientChannel(int64_t requestId, const DeviceGroupManager& deviceGroupManager, - std::function onError) - : requestId_(requestId), socketFd_(-1), deviceGroupManager_(deviceGroupManager), onError_(onError) {} - ~DeviceClientChannel(); - - DeviceClientChannel()=delete; - DeviceClientChannel(const DeviceClientChannel&)=delete; - DeviceClientChannel &operator=(const DeviceClientChannel&)=delete; - -public: - int32_t Connect(const std::string& ip, short port); - bool Send(const char* data, const int32_t dataLen); - void Receive(void); - void OnDataReceived(const char* data, const int32_t dataLen); - void ResetConnection(); - -private: - int64_t requestId_; - int32_t socketFd_; - const DeviceGroupManager& deviceGroupManager_; - // call back for socket channel - std::function onError_; -}; -} -} -#endif \ No newline at end of file diff --git a/services/devicemanagerservice/include/authdemo/device_server_channel.h b/services/devicemanagerservice/include/authdemo/device_server_channel.h deleted file mode 100644 index 6e3b279fc13d4cf4902ef058be22e82f8a4860a1..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/authdemo/device_server_channel.h +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_SERVER_CHANNEL_H -#define OHOS_DEVICE_SERVER_CHANNEL_H - -#include -#include -#include - -#include "device_auth.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceServerChannel { -public: - DeviceServerChannel(const DeviceGroupManager& deviceGroupManager, - std::function onError) - : socketFd_(-1), clientFd_(-1), deviceGroupManager_(deviceGroupManager), onError_(onError) {} - ~DeviceServerChannel(); - - DeviceServerChannel()=delete; - DeviceServerChannel(const DeviceServerChannel&)=delete; - DeviceServerChannel &operator=(const DeviceServerChannel&)=delete; - -public: - int32_t Start(const int32_t port); - bool Send(const char* data, const int32_t dataLen); - void Receive(); - void OnDataReceived(const char* data, const int32_t dataLen); - void ResetConnection(); - -private: - int32_t socketFd_; - int32_t clientFd_; - const DeviceGroupManager& deviceGroupManager_; - std::function onError_; -}; -} -} -#endif \ No newline at end of file diff --git a/services/devicemanagerservice/include/authdemo/hichain_adapter.h b/services/devicemanagerservice/include/authdemo/hichain_adapter.h deleted file mode 100644 index 55ca7e5b29fec6fdb1331f1db90d090deb98a538..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/authdemo/hichain_adapter.h +++ /dev/null @@ -1,114 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_HICHAIN_ADAPTER_H -#define OHOS_HICHAIN_ADAPTER_H - -#include -#include -#include -#include -#include - -#include "device_auth.h" -#include "event_handler.h" -#include "nlohmann/json.hpp" -#include "thread_pool.h" - -#include "device_client_channel.h" -#include "device_server_channel.h" -#include "single_instance.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - SUCCESS = 0, - GROUP_CREATE_FAILED = 1, - MEMBER_ADD_FAILED = 2, - CREATE_CHANNEL_FAILED = 3, -}; - -struct DeviceReqInfo { - std::string deviceId; - std::string ipAddr; - short port; -}; - -class BindCallback { -public: - virtual void onBindSuccess(std::string deviceId, const char* returnData) = 0; - virtual void onBindFailed(std::string deviceId, int32_t errorCode) = 0; - virtual void onUnBindSuccess(std::string /* deviceId */, const char* /* returnData */) {} - virtual void onUnBindFailed(std::string /* deviceId */, int32_t /* errorCode*/) {} - virtual ~BindCallback() {} -}; - -class HichainAuthCallBack { -public: - static bool onTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); - static void onSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen); - static void onFinish(int64_t requestId, int operationCode, const char *returnData); - static void onError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn); - static char* onBindRequest(int64_t requestId, int operationCode, const char *reqParams); -}; - -class HichainAdapter { -DECLARE_SINGLE_INSTANCE(HichainAdapter); -public: - int Init(); - - int32_t Bind(const DeviceReqInfo& devReqInfo, std::shared_ptr callback, bool sync = false); - - void OnBindSuccess(int64_t requestId, const char* returnData); - void OnBindFailed(int64_t requestId, int32_t errorCode); - - void UnBind(const std::string& deviceId); - void OnUnBindFinished(); - - bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); - - void OnGroupCreated(int64_t requestId, const char *groupInfo); - - char* OnBindRequest(int64_t requestId, int operationCode, const char *reqParams); - -private: - std::string GetGroupIdByName(int32_t groupType, const std::string& groupName); - int32_t CreateGroup(int64_t requestId); - int32_t AddMemeber(int64_t requestId, std::string& groupId, const std::string& pinCode); - int64_t GenRequestId(); - -private: - std::atomic requestIdIndex_ {0}; - std::map bindingDeviceMap_; - std::map> clientBindReqMap_; - std::map> bindCallBackMap_; - const DeviceGroupManager* deviceGroupManager_ = nullptr; - std::unique_ptr deviceServerInst_; - mutable ThreadPool threadPool_; - - DeviceAuthCallback deviceAuthCallback_ = { - .onTransmit = HichainAuthCallBack::onTransmit, - .onSessionKeyReturned = HichainAuthCallBack::onSessionKeyReturned, - .onFinish = HichainAuthCallBack::onFinish, - .onError = HichainAuthCallBack::onError, - .onRequest = HichainAuthCallBack::onBindRequest, - }; - - // call back for socket channel - std::function onError_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_HICHAIN_ADAPTER_H \ No newline at end of file diff --git a/services/devicemanagerservice/include/device_manager_listener_proxy.h b/services/devicemanagerservice/include/device_manager_listener_proxy.h deleted file mode 100644 index d32f7837ad692ae76da6ec293a75a37943ba246c..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/device_manager_listener_proxy.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_LISTENER_PROXY_H -#define OHOS_DEVICE_MANAGER_LISTENER_PROXY_H - -#include "idevice_manager_listener.h" -#include "iremote_proxy.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerListenerProxy : public IRemoteProxy { -public: - explicit DeviceManagerListenerProxy(const sptr& impl) - : IRemoteProxy(impl) {}; - ~DeviceManagerListenerProxy() {}; - int32_t OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceFound(std::string &packageName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo) override; - int32_t OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, int32_t failedReason) override; - int32_t OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) override; - int32_t OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, int32_t reason) override; -private: - bool WriteInterfaceToken(MessageParcel &data); - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LISTENER_PROXY_H diff --git a/services/devicemanagerservice/include/device_manager_stub.h b/services/devicemanagerservice/include/device_manager_stub.h deleted file mode 100644 index db5555468ac1a8592246dc7d19c92d4c2367fc96..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/device_manager_stub.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_STUB_H -#define OHOS_DEVICE_MANAGER_STUB_H - -#include -#include "iremote_stub.h" -#include "idevice_manager.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerStub : public IRemoteStub { -public: - DeviceManagerStub(); - ~DeviceManagerStub(); - int32_t OnRemoteRequest(uint32_t code, - MessageParcel &data, MessageParcel &reply, MessageOption &option) override; -private: - int32_t RegisterDeviceManagerListenerInner(MessageParcel &data, MessageParcel &reply); - int32_t UnRegisterDeviceManagerListenerInner(MessageParcel &data, MessageParcel &reply); - int32_t RegisterDeviceStateCallbackInner(MessageParcel &data, MessageParcel &reply); - int32_t UnRegisterDeviceStateCallbackInner(MessageParcel &data, MessageParcel &reply); - int32_t GetTrustedDeviceListInner(MessageParcel &data, MessageParcel &reply); - int32_t StartDeviceDiscoveryInner(MessageParcel &data, MessageParcel &reply); - int32_t StopDeviceDiscoveryInner(MessageParcel &data, MessageParcel &reply); - int32_t AuthenticateDeviceInner(MessageParcel &data, MessageParcel &reply); - template - int32_t GetParcelableInfo(MessageParcel &reply, T &parcelableInfo); - bool EnforceInterceToken(MessageParcel &data); - using CmdProcFunc = int32_t (DeviceManagerStub::*)(MessageParcel &data, MessageParcel &reply); - std::map memberFuncMap_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_STUB_H diff --git a/interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h b/services/devicemanagerservice/include/ipc/ipc_server_adapter.h similarity index 35% rename from interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h rename to services/devicemanagerservice/include/ipc/ipc_server_adapter.h index bf55490d39f9fb1a60a9ffdc6b1ed548e88442ef..b371e03a4ed47b5e49e57f829c4305d5f13fed23 100644 --- a/interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h +++ b/services/devicemanagerservice/include/ipc/ipc_server_adapter.h @@ -1,50 +1,53 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_LISTENER_INTERFACE_H -#define OHOS_DEVICE_MANAGER_LISTENER_INTERFACE_H - -#include "iremote_broker.h" -#include "dm_device_info.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - ON_DEVICE_ONLINE = 0, - ON_DEVICE_OFFLINE = 1, - ON_DEVICE_CHANGE = 2, - ON_DEVICE_FOUND = 3, - ON_DISCOVER_SUCCESS = 4, - ON_DISCOVER_FAILED = 5, - ON_AUTH_RESULT = 6, -}; - -class IDeviceManagerListener : public OHOS::IRemoteBroker { -public: - virtual ~IDeviceManagerListener() {} - virtual int32_t OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDeviceFound(std::string &packageName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, int32_t failedReason) = 0; - virtual int32_t OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) = 0; - virtual int32_t OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, int32_t reason) = 0; - -public: - DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.devicemanagerlistener"); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LISTENER_INTERFACE_H +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_ADAPTER_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_ADAPTER_H + +#include + +#include "dm_app_image_info.h" +#include "dm_device_info.h" +#include "dm_subscribe_info.h" + +#include "hichain_connector.h" + +#include "single_instance.h" +#include "softbus_adapter.h" +#include "ability_manager_interface.h" +#include "want.h" +#include "ipc_server_adapter.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcServerAdapter { +DECLARE_SINGLE_INSTANCE(IpcServerAdapter); +public: + int32_t ModuleInit(); + int32_t GetTrustedDeviceList(std::string &pkgName, std::string &extra, DmDeviceInfo **info, int32_t *infoNum); + int32_t StartDeviceDiscovery(std::string &pkgName, DmSubscribeInfo &dmSubscribeInfo); + int32_t StopDiscovery(std::string &pkgName, uint16_t subscribeId); + int32_t AuthenticateDevice(std::string &pkgName, const DmDeviceInfo &deviceInfo, + const DmAppImageInfo &imageInfo, std::string &extra); + int32_t CheckAuthentication(std::string &authPara); + int32_t GetAuthenticationParam(std::string &pkgName, DmAuthParam &authParam); + int32_t SetUserOperation(std::string &pkgName, int32_t action); + static int32_t GenRandInt(int32_t minPinToken, int32_t maxPinToken); +private: + int32_t CheckParamValid(nlohmann::json &extraJson, const DmAppImageInfo &imageInfo); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_ADAPTER_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h b/services/devicemanagerservice/include/ipc/ipc_server_listener_adapter.h similarity index 40% rename from interfaces/inner_kits/native_cpp/include/device_manager_callback.h rename to services/devicemanagerservice/include/ipc/ipc_server_listener_adapter.h index 58aff430f16a29f197ba13b46c2d8a7c0cc8fede..e4b3e357d703f97a289c2bb8595694c6976b691a 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h +++ b/services/devicemanagerservice/include/ipc/ipc_server_listener_adapter.h @@ -1,52 +1,43 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_CALLBACK_H -#define OHOS_DEVICE_MANAGER_CALLBACK_H -#include "dm_device_info.h" - -namespace OHOS { -namespace DistributedHardware { -class DmInitCallback { -public: - virtual ~DmInitCallback() {} - virtual void OnRemoteDied() = 0; -}; - -class DeviceStateCallback { -public: - virtual ~DeviceStateCallback() {} - virtual void OnDeviceOnline(const DmDeviceInfo &deviceInfo) = 0; - virtual void OnDeviceReady(const DmDeviceInfo &deviceInfo) = 0; - virtual void OnDeviceOffline(const DmDeviceInfo &deviceInfo) = 0; - virtual void OnDeviceChanged(const DmDeviceInfo &deviceInfo) = 0; -}; - -class DiscoverCallback { -public: - virtual ~DiscoverCallback() {} - virtual void OnDiscoverySuccess(uint16_t subscribeId) = 0; - virtual void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) = 0; - virtual void OnDeviceFound(uint16_t subscribeId, DmDeviceInfo &deviceInfo) = 0; -}; - -class AuthenticateCallback { -public: - virtual ~AuthenticateCallback() {} - virtual void OnAuthResult(std::string &deviceId, int32_t status, int32_t reason) = 0; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_CALLBACK_H +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_ADAPTER_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_ADAPTER_H + +#include "discovery_service.h" + +#include "ipc_server_listener.h" + +#include "single_instance.h" +#include "dm_device_info.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcServerListenerAdapter { +DECLARE_SINGLE_INSTANCE(IpcServerListenerAdapter); +public: + void OnDeviceStateChange(DmDeviceState state, DmDeviceInfo &deviceInfo); + void OnDeviceFound(std::string &pkgName, uint16_t originId, DmDeviceInfo &deviceInfo); + void OnDiscoverFailed(std::string &pkgName, uint16_t originId, DiscoveryFailReason failReason); + void OnDiscoverySuccess(std::string &pkgName, uint16_t originId); + void OnAuthResult(std::string &pkgName, std::string &deviceId, int32_t pinToken, uint32_t status, uint32_t reason); + void OnCheckAuthResult(std::string &pkgName, std::string &deviceId, int32_t resultCode, int32_t flag); + void OnFaCall(std::string &pkgName, std::string ¶mJson); +private: + IpcServerListener ipcServerListener_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_ADAPTER_H diff --git a/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h b/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..9503191aa0b6430a4051deede3af5877b120bd5d --- /dev/null +++ b/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H + +#include + +#include "ipc_req.h" +#include "ipc_rsp.h" + +#include "ipc_server_listenermgr.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcServerListener { +public: + IpcServerListener() = default; + virtual ~IpcServerListener() = default; +public: + int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); + int32_t SendAll(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); +private: + void CommonSvcToIdentity(CommonSvcId *svcId, SvcIdentity *identity); + int32_t GetIdentityByPkgName(std::string &name, SvcIdentity *svc); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H diff --git a/services/devicemanagerservice/include/ipc/lite/ipc_server_listenermgr.h b/services/devicemanagerservice/include/ipc/lite/ipc_server_listenermgr.h new file mode 100644 index 0000000000000000000000000000000000000000..3e39f8ccec3e255a70156cc1dd7c4bae07693eb9 --- /dev/null +++ b/services/devicemanagerservice/include/ipc/lite/ipc_server_listenermgr.h @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_MGR_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_MGR_H + +#include +#include +#include +#include + +#include "liteipc_adapter.h" +#include "single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +typedef struct CommonSvcId { + unsigned int handle; + unsigned int token; + unsigned int cookie; + IpcContext *ipcCtx; + unsigned int cbId; +}CommonSvcId; + +class IpcServerListenermgr { +DECLARE_SINGLE_INSTANCE(IpcServerListenermgr); +public: + int32_t RegisterListener(std::string &pkgName, const CommonSvcId *svcId); + int32_t GetListenerByPkgName(std::string &pkgName, CommonSvcId *svcId); + int32_t UnregisterListener(std::string &pkgName); + const std::map &GetAllListeners(); +private: + std::map dmListenerMap_; + std::mutex lock_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_MGR_H diff --git a/services/devicemanagerservice/include/ipc/lite/ipc_server_stub.h b/services/devicemanagerservice/include/ipc/lite/ipc_server_stub.h new file mode 100644 index 0000000000000000000000000000000000000000..9baa73d4a1b2b406b6970cd479854c95a3e8f062 --- /dev/null +++ b/services/devicemanagerservice/include/ipc/lite/ipc_server_stub.h @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H + +#include + +#include "liteipc_adapter.h" + +int32_t IpcServerStubInit(void); +int32_t RegisterDeviceManagerListener(IpcIo *req, IpcIo *reply); +int32_t UnRegisterDeviceManagerListener(IpcIo *req, IpcIo *reply); +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H diff --git a/services/devicemanagerservice/include/ipc/standard/ipc_server_client_proxy.h b/services/devicemanagerservice/include/ipc/standard/ipc_server_client_proxy.h new file mode 100644 index 0000000000000000000000000000000000000000..15b5e44a4ef46af22aef201c630823e4dc2eb829 --- /dev/null +++ b/services/devicemanagerservice/include/ipc/standard/ipc_server_client_proxy.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_CLIENT_PROXY_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_CLIENT_PROXY_H + +#include "ipc_remote_broker.h" +#include "iremote_proxy.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcServerClientProxy : public IRemoteProxy { +public: + explicit IpcServerClientProxy(const sptr &impl) + : IRemoteProxy(impl) {}; + ~IpcServerClientProxy() {}; + int32_t SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) override; +private: + static inline BrokerDelegator delegator_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_CLIENT_PROXY_H diff --git a/services/devicemanagerservice/include/ipc/standard/ipc_server_listener.h b/services/devicemanagerservice/include/ipc/standard/ipc_server_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..3737b7cdefa529f5f2af4eed65bfcccbe1248f01 --- /dev/null +++ b/services/devicemanagerservice/include/ipc/standard/ipc_server_listener.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H + +#include + +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcServerListener { +public: + IpcServerListener() = default; + virtual ~IpcServerListener() = default; +public: + int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); + int32_t SendAll(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H diff --git a/services/devicemanagerservice/include/device_manager_service.h b/services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h similarity index 40% rename from services/devicemanagerservice/include/device_manager_service.h rename to services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h index af19ab97e67d9a85a42ec5ca453cead807cc98c1..4e653eb97d1d38d97e728730a3b6e9366b592527 100644 --- a/services/devicemanagerservice/include/device_manager_service.h +++ b/services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h @@ -1,98 +1,76 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_SERVICE_H -#define OHOS_DEVICE_MANAGER_SERVICE_H - -#include -#include -#include -#include -#include -#include "system_ability.h" -#include "thread_pool.h" -#include "iremote_stub.h" -#include "idevice_manager.h" -#include "idevice_manager_listener.h" -#include "device_manager_stub.h" -#include "single_instance.h" -#include "hichain_adapter.h" - -namespace OHOS { -namespace DistributedHardware { -enum class ServiceRunningState { - STATE_NOT_START, - STATE_RUNNING -}; - -enum DmBindStatus : uint32_t { - STATE_BIND_SUCCESS, - STATE_BIND_FAILD -}; - -class AppDeathRecipient : public IRemoteObject::DeathRecipient { -public: - void OnRemoteDied(const wptr& remote) override; - AppDeathRecipient() = default; - ~AppDeathRecipient() = default; -}; - -class HiChainBindCallback : public BindCallback { -public: - void onBindSuccess(std::string deviceId, const char* returnData) override; - void onBindFailed(std::string deviceId, int32_t errorCode) override; -}; - -class DeviceManagerService : public SystemAbility, public DeviceManagerStub { -friend class HiChainBindCallback; -DECLARE_SYSTEM_ABILITY(DeviceManagerService); -DECLARE_SINGLE_INSTANCE_BASE(DeviceManagerService); -public: - DeviceManagerService(); - ~DeviceManagerService() = default; - void OnStart() override; - void OnStop() override; - ServiceRunningState QueryServiceState() const; - - int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) override; - int32_t RegisterDeviceManagerListener(std::string &packageName, sptr listener) override; - int32_t UnRegisterDeviceManagerListener(std::string &packageName) override; - int32_t RegisterDeviceStateCallback(std::string &packageName, std::string &extra) override; - int32_t UnRegisterDeviceStateCallback(std::string &packageName) override; - int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) override; - int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) override; - int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra) override; - const std::map>& GetDmListener(); - const sptr GetDmListener(std::string packageName) const; - -private: - bool Init(); - void RegisterDeviceStateListener(); - -private: - bool registerToService_; - ServiceRunningState state_; - mutable ThreadPool threadPool_; - std::mutex listenerLock_; - std::shared_ptr hichainBindCallback_; - std::map> appRecipient_; - std::map> dmListener_; - std::map devStateCallbackParas_; - std::map authCallbackParas_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SERVICE_H +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H +#define OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H + +#include +#include +#include +#include +#include + +#include "nlohmann/json.hpp" + +#include "system_ability.h" +#include "thread_pool.h" +#include "iremote_stub.h" +#include "ipc_remote_broker.h" + +#include "single_instance.h" +#include "hichain_connector.h" + +namespace OHOS { +namespace DistributedHardware { +enum class ServiceRunningState { + STATE_NOT_START, + STATE_RUNNING +}; + +class AppDeathRecipient : public IRemoteObject::DeathRecipient { +public: + void OnRemoteDied(const wptr &remote) override; + AppDeathRecipient() = default; + ~AppDeathRecipient() = default; +}; + +class IpcServerStub : public SystemAbility, public IRemoteStub { +DECLARE_SYSTEM_ABILITY(IpcServerStub); +DECLARE_SINGLE_INSTANCE_BASE(IpcServerStub); +public: + void OnStart() override; + void OnStop() override; + int32_t OnRemoteRequest(uint32_t code, + MessageParcel &data, MessageParcel &reply, MessageOption &option) override; + int32_t SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) override; + int32_t RegisterDeviceManagerListener(std::string &pkgName, sptr listener); + int32_t UnRegisterDeviceManagerListener(std::string &pkgName); + ServiceRunningState QueryServiceState() const; + const std::map> &GetDmListener(); + const sptr GetDmListener(std::string pkgName) const; +private: + IpcServerStub(); + ~IpcServerStub() = default; + bool Init(); +private: + bool registerToService_; + ServiceRunningState state_; + std::mutex listenerLock_; + std::map> appRecipient_; + std::map> dmListener_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H diff --git a/services/devicemanagerservice/include/softbus/softbus_adapter.h b/services/devicemanagerservice/include/softbus/softbus_adapter.h deleted file mode 100644 index 6d0ba83dce492ebc979a7fce1b355a71ce15a082..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/softbus/softbus_adapter.h +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_SOFTBUS_ADAPTER_H -#define OHOS_DEVICE_MANAGER_SOFTBUS_ADAPTER_H - -#include -#include -#include -#include "softbus_bus_center.h" -#include "discovery_service.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" -#include "single_instance.h" - -namespace OHOS { -namespace DistributedHardware { -struct SubscribeInfoAdapter { - SubscribeInfo info; - uint16_t subscribeIdOrigin; - uint16_t subscribeIdPrefix; -}; - -class SoftbusAdapter { -DECLARE_SINGLE_INSTANCE(SoftbusAdapter); -public: - static int32_t GetSoftbusTrustDevices(const std::string &packageName, std::string &extra, - std::vector &deviceList); - void RegSoftBusDeviceStateListener(); - int32_t StartSoftbusDiscovery(std::string &packageName, DmSubscribeInfo &info); - int32_t StopSoftbusDiscovery(std::string &packageName, uint16_t subscribeId); - static void OnSoftbusDeviceOffline(NodeBasicInfo *info); - static void OnSoftBusDeviceOnline(NodeBasicInfo *info); - static void OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info); - static void OnSoftbusDeviceFound(const DeviceInfo *device); - static void OnSoftbusDiscoverFailed(int subscribeId, DiscoveryFailReason failReason); - static void OnSoftbusDiscoverySuccess(int subscribeId); - static void OnSoftbusJoinLNNResult(ConnectionAddr *addr, const char *networkId, int32_t retCode); - static void OnSoftbusLeaveLNNResult(const char *networkId, int32_t retCode); - const std::map>>& GetsubscribeInfos(); - int32_t SoftbusJoinLnn(std::string devId); - int32_t SoftbusLeaveLnn(std::string networkId); - int32_t GetConnectionIpAddr(std::string deviceId, std::string &ipAddr); - static bool IsDeviceOnLine(std::string &deviceId); - -private: - static void OnSoftBusDeviceStateChange(DmDeviceState state, NodeBasicInfo *info); - std::string GetPackageNameBySubscribeId(uint16_t subscribeId); - bool GetsubscribeIdAdapter(std::string packageName, int16_t originId, int32_t &adapterId); - bool GetPackageNameBySubscribeId(int32_t adapterId, std::string &packageName); - void SaveDiscoverDeviceInfo(const DeviceInfo *deviceInfo); - void RemoveDiscoverDeviceInfo(const std::string deviceId); - -private: - std::map>> subscribeInfos_; - std::map> discoverDeviceInfoMap_; - std::vector> discoverDeviceInfoVector_; - std::atomic subscribeIdPrefix {0}; - INodeStateCb softbusNodeStateCb = { - .events = EVENT_NODE_STATE_ONLINE | EVENT_NODE_STATE_OFFLINE | EVENT_NODE_STATE_INFO_CHANGED, - .onNodeOnline = OnSoftBusDeviceOnline, - .onNodeOffline = OnSoftbusDeviceOffline, - .onNodeBasicInfoChanged = OnSoftbusDeviceInfoChanged - }; - IDiscoveryCallback softbusDiscoverCallback = { - .OnDeviceFound = OnSoftbusDeviceFound, - .OnDiscoverFailed = OnSoftbusDiscoverFailed, - .OnDiscoverySuccess = OnSoftbusDiscoverySuccess - }; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SOFTBUS_ADAPTER_H diff --git a/services/devicemanagerservice/src/authdemo/device_client_channel.cpp b/services/devicemanagerservice/src/authdemo/device_client_channel.cpp deleted file mode 100644 index f1ccaea7bbe1e4003d3aecbf9b0488610527bb47..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/authdemo/device_client_channel.cpp +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_client_channel.h" - -#include -#include - -#include -#include -#include -#include - -#include -#include - -#include -#include - -#include - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - constexpr int32_t CLIENT_DATA_BUFFER_LENGTH = 2048; - const int32_t RECV_DATA_TIMEOUT = 5; - const int32_t REQUEST_ID_LENGTH = 10; -} - -DeviceClientChannel::~DeviceClientChannel() -{ - if (socketFd_ != -1) { - close(socketFd_); - socketFd_ = -1; - } -} - -int32_t DeviceClientChannel::Connect(const std::string& ip, short port) -{ - HILOGI("DeviceClientChannel::Connect begin to connect to server."); - int32_t socketFd = socket(AF_INET, SOCK_STREAM, 0); - if (socketFd == -1) { - HILOGE("DeviceClientChannel::Connect create socket failed, errMsg: %{public}s.", strerror(errno)); - return -1; - } - - struct sockaddr_in addr; - if (memset_s(&addr, sizeof(addr), 0, sizeof(addr)) != EOK) { - HILOGE("DeviceClientChannel::Connect error init addr."); - close(socketFd); - return -1; - } - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = inet_addr(ip.c_str()); - addr.sin_port = htons(port); - - int32_t ret = connect(socketFd, (struct sockaddr*) &addr, sizeof(addr)); - if (ret == -1) { - HILOGE("DeviceClientChannel::Connect connet server failed, errMsg: %{public}s.", strerror(errno)); - close(socketFd); - return -1; - } - - socketFd_ = socketFd; - HILOGI("DeviceClientChannel::Connect connect to server, fd: %{public}d.", socketFd_); - - // wait five seconds, if recv none, release the connection - struct timeval timeout = {RECV_DATA_TIMEOUT, 0}; - setsockopt(socketFd_, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval)); - return 0; -} - -bool DeviceClientChannel::Send(const char* data, const int32_t dataLen) -{ - // The client needs to add requestId to the header of the data - std::stringstream reqIdStr; - reqIdStr << requestId_; - - int32_t sendDataLen = dataLen + REQUEST_ID_LENGTH; - std::unique_ptr sendData = std::make_unique(sendDataLen); - if (memset_s(sendData.get(), sendDataLen, 0, sendDataLen) != EOK) { - HILOGE("DeviceClientChannel::Send error init send data."); - return false; - } - - if (memcpy_s(sendData.get(), sendDataLen, reqIdStr.str().c_str(), REQUEST_ID_LENGTH) != EOK) { - HILOGE("DeviceClientChannel::Send error init requestId."); - return false; - } - - if (memcpy_s(sendData.get() + REQUEST_ID_LENGTH, sendDataLen - REQUEST_ID_LENGTH, data, dataLen) != EOK) { - HILOGE("DeviceClientChannel::Send error init data."); - return false; - } - - int32_t ret = send(socketFd_, sendData.get(), sendDataLen, 0); - if (ret == -1) { - HILOGE("DeviceClientChannel::send data failed, errMsg: %{public}s.", strerror(errno)); - return false; - } - - HILOGI("DeviceClientChannel::send data, size:%{public}d.", ret); - return true; -} - -void DeviceClientChannel::Receive() -{ - HILOGI("DeviceClientChannel::Receive data, socketFd:%{public}d.", socketFd_); - char dataBuf[CLIENT_DATA_BUFFER_LENGTH] = {0}; - - while (socketFd_ != -1) { - (void)memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf)); - int32_t rc = recv(socketFd_, dataBuf, sizeof(dataBuf), 0); - if (rc == 0) { - HILOGE("DeviceClientChannel::Receive error, client shutdown, socketFd_:%{public}d, errMsg: %{public}s.", - socketFd_, strerror(errno)); - close(socketFd_); - socketFd_ = -1; - break; - } else if (rc == -1 || rc == EAGAIN) { - HILOGE("DeviceClientChannel::Receive data failed, socketFd_:%{public}d, errMsg: %{public}s.", - socketFd_, strerror(errno)); - close(socketFd_); - socketFd_ = -1; - break; - } else { - HILOGI("DeviceClientChannel::Receive data, socketFd_:%{public}d, size:%{public}d.", socketFd_, rc); - OnDataReceived(dataBuf, rc); - } - } - HILOGI("DeviceClientChannel::Receive data end, socketFd:%{public}d.", socketFd_); -} - -void DeviceClientChannel::OnDataReceived(const char* data, const int32_t dataLen) -{ - int ret = deviceGroupManager_.processData(requestId_, (uint8_t *) data, dataLen); - HILOGI("DeviceClientChannel::OnDataReceived process data, ret:%{public}d, dataLen:%{public}d.", ret, dataLen); - if (ret != 0) { - close(socketFd_); - socketFd_ = -1; - onError_(requestId_, 0, ret, nullptr); - } -} - -void DeviceClientChannel::ResetConnection() -{ - HILOGI("DeviceClientChannel::ResetConnection bind finished, release connection."); - close(socketFd_); - socketFd_ = -1; -} -} -} \ No newline at end of file diff --git a/services/devicemanagerservice/src/authdemo/device_server_channel.cpp b/services/devicemanagerservice/src/authdemo/device_server_channel.cpp deleted file mode 100644 index af142ff3cabbc8d1615421522b889d8c1c3e17d5..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/authdemo/device_server_channel.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_server_channel.h" - -#include -#include - -#include -#include - -#include -#include - -#include -#include - -#include - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - const int32_t DATA_BUFFER_LENGTH = 2048; - const int32_t REQUEST_ID_LENGTH = 10; - const int32_t LISTENING_QUEUE_LEN = 10; - const int64_t MIN_REQUEST_ID = 1000000000; - const int32_t RECV_DATA_TIMEOUT = 5; -} - -DeviceServerChannel::~DeviceServerChannel() -{ - if (socketFd_ != -1) { - close(socketFd_); - socketFd_ = -1; - } - - if (clientFd_ != -1) { - close(clientFd_); - clientFd_ = -1; - } -} - -int32_t DeviceServerChannel::Start(const int32_t port) -{ - HILOGI("DeviceServerChannel::Start begin to start server."); - if (port <= 0) { - HILOGE("DeviceServerChannel::start port is invalid."); - return -1; - } - - int32_t socketFd = socket(AF_INET, SOCK_STREAM, 0); - if (socketFd == -1) { - HILOGE("DeviceServerChannel::start create socket failed, errMsg: %{public}s.", strerror(errno)); - return -1; - } - - struct sockaddr_in addr; - if (memset_s(&addr, sizeof(addr), 0, sizeof(addr)) != EOK) { - HILOGE("DeviceServerChannel::Start error init addr."); - close(socketFd); - return -1; - } - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = INADDR_ANY; - addr.sin_port = htons(port); - - int32_t ret = bind(socketFd, (struct sockaddr*) &addr, sizeof(addr)); - if (ret == -1) { - HILOGE("DeviceServerChannel::start bind addr failed, errMsg: %{public}s.", strerror(errno)); - close(socketFd); - return -1; - } - - socketFd_ = socketFd; - HILOGI("DeviceServerChannel::start bind addr success, fd:%{public}d.", socketFd_); - - ret = listen(socketFd_, LISTENING_QUEUE_LEN); - if (ret == -1) { - HILOGE("DeviceServerChannel::start listen port failed, errMsg: %{public}s.", strerror(errno)); - close(socketFd_); - socketFd_ = -1; - return -1; - } - - return 0; -} - -void DeviceServerChannel::Receive() -{ - HILOGI("DeviceServerChannel::receive begin to listen client connecting."); - struct sockaddr_in client_addr; - socklen_t len = sizeof(client_addr); - - while (true) { - int32_t fd = accept(socketFd_, (struct sockaddr*) &client_addr, &len); - if (fd == -1) { - HILOGE("DeviceServerChannel::receive accept connect failed, errMsg: %{public}s.", strerror(errno)); - continue; - } - - if (clientFd_ != -1) { - HILOGW("DeviceServerChannel::receive another client is connected, close new connect."); - close(fd); - continue; - } - - HILOGI("DeviceServerChannel::receive new client in."); - clientFd_ = fd; - - // wait five seconds, if recv none, release the connection - struct timeval timeout = {RECV_DATA_TIMEOUT, 0}; - setsockopt(clientFd_, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval)); - - // demo project, blocked here to receive data, informal solution, will be discard later - char dataBuf[DATA_BUFFER_LENGTH] = {0}; - while (clientFd_ != -1) { - if (memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf)) != EOK) { - HILOGE("DeviceServerChannel::receive error init data buf."); - close(clientFd_); - clientFd_ = -1; - break; - } - - int32_t rc = recv(clientFd_, dataBuf, sizeof(dataBuf), 0); - if (rc == 0) { - HILOGE("DeviceServerChannel::receive error, client shutdown."); - close(clientFd_); - clientFd_ = -1; - break; - } else if (rc == -1 || rc == EAGAIN) { - HILOGE("DeviceServerChannel::receive receive data failed, errMsg: %{public}s.", strerror(errno)); - close(clientFd_); - clientFd_ = -1; - break; - } else { - HILOGI("DeviceServerChannel::receive receive data, size:%{public}d.", rc); - OnDataReceived(dataBuf, rc); - } - } - } -} - -void DeviceServerChannel::OnDataReceived(const char* data, const int32_t dataLen) -{ - HILOGI("DeviceServerChannel::OnDataReceived dataLen:%{public}d.", dataLen); - if (dataLen < REQUEST_ID_LENGTH) { - HILOGI("DeviceServerChannel::OnDataReceived error, data is invalid."); - return; - } - - // the client adds requestId to the header of data, the server needs to parse the original data - char reqIdChar[REQUEST_ID_LENGTH + 1] = {0}; - (void)memcpy_s(reqIdChar, sizeof(reqIdChar), data, REQUEST_ID_LENGTH); - reqIdChar[REQUEST_ID_LENGTH] = '\0'; - int64_t requestId = strtoll(reqIdChar, nullptr, REQUEST_ID_LENGTH); - if (requestId < MIN_REQUEST_ID) { - HILOGI("DeviceServerChannel::OnDataReceived error, requestId is invalid."); - return; - } - - const char* newData = data + REQUEST_ID_LENGTH; - int len = dataLen - REQUEST_ID_LENGTH; - int ret = deviceGroupManager_.processData(requestId, (const uint8_t *) newData, len); - HILOGI("DeviceServerChannel::OnDataReceived process data, ret:%{public}d, dataLen:%{public}d.", ret, len); - if (ret != 0) { - onError_(requestId, 0, ret, nullptr); - close(clientFd_); - clientFd_ = -1; - } -} - -bool DeviceServerChannel::Send(const char* data, const int32_t dataLen) -{ - int32_t ret = send(clientFd_, data, dataLen, 0); - if (ret == -1) { - HILOGE("DeviceServerChannel::send failed,socket:%{public}d,errMsg: %{public}s.", clientFd_, strerror(errno)); - return false; - } - - HILOGI("DeviceServerChannel::send data,socket:%{public}d, size:%{public}d.", clientFd_, ret); - return true; -} - -void DeviceServerChannel::ResetConnection() -{ - HILOGI("DeviceServerChannel::ResetConnection bind finished, release connection."); - close(clientFd_); - clientFd_ = -1; -} -} -} \ No newline at end of file diff --git a/services/devicemanagerservice/src/authdemo/hichain_adapter.cpp b/services/devicemanagerservice/src/authdemo/hichain_adapter.cpp deleted file mode 100644 index 5ccc74020fdc6d5771b21bde3f5b28beec1dfd92..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/authdemo/hichain_adapter.cpp +++ /dev/null @@ -1,384 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "hichain_adapter.h" - -#include -#include -#include -#include - -#include "parameter.h" - -#include "anonymous_string.h" -#include "device_client_channel.h" -#include "device_manager_log.h" -#include "device_server_channel.h" - - -namespace OHOS { -namespace DistributedHardware { -namespace { -// demo solution, may has security issues, later will be replaced by a formal plan -const std::string PIN_CODE = ""; -const int32_t PORT = -1; - -const std::string DEVICE_MANAGER_APP = "ohos.distributedhardware.devicemanager"; -const std::string DEVICE_MANAGER_GROUPNAME = "DMPeerToPeerGroup"; - -const int64_t MIN_REQUEST_ID = 1000000000; -const int64_t MAX_REQUEST_ID = 9999999999; - -const int32_t DEVICE_UUID_LENGTH = 65; -const int32_t PEER_TO_PEER_GROUP = 256; -const int32_t FIELD_EXPIRE_TIME_VALUE = 90; - -const int32_t THREAD_POOL_NUMBER = 20; -} - -IMPLEMENT_SINGLE_INSTANCE(HichainAdapter); - -int HichainAdapter::Init() -{ - HILOGI("HichainAdapter::init, begin to init hichain adapter."); - if (threadPool_.GetThreadsNum() == 0) { - threadPool_.Start(THREAD_POOL_NUMBER); - } - - bindingDeviceMap_.clear(); - bindCallBackMap_.clear(); - clientBindReqMap_.clear(); - - // call back for socket channel - using std::placeholders::_1; - using std::placeholders::_2; - using std::placeholders::_3; - using std::placeholders::_4; - onError_ = std::bind(HichainAuthCallBack::onError, _1, _2, _3, _4); - - HILOGI("HichainAdapter::init, init device auth service."); - InitDeviceAuthService(); - - // get group auth manager instance, and register callback - deviceGroupManager_ = GetGmInstance(); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::init, failed to init group manager!"); - return -1; - } - deviceGroupManager_->regCallback(DEVICE_MANAGER_APP.c_str(), &deviceAuthCallback_); - - HILOGI("HichainAdapter::init, start socket server channel."); - deviceServerInst_ = std::make_unique(*deviceGroupManager_, onError_); - if (deviceServerInst_->Start(PORT) == -1) { - HILOGE("HichainAdapter::init, failed to start server!"); - return -1; - } - - // start the server channel to receive data - auto receiveFunc = [this]() { - this->deviceServerInst_->Receive(); - }; - threadPool_.AddTask(receiveFunc); - - HILOGI("HichainAdapter::init, init hichain adapter success."); - return 0; -} - -int32_t HichainAdapter::Bind(const DeviceReqInfo& devReqInfo, std::shared_ptr callback, bool sync) -{ - (void)sync; - HILOGI("HichainAdapter::Bind, begin to bind device: %{public}s.", GetAnonyString(devReqInfo.deviceId).c_str()); - for (auto &item : bindingDeviceMap_) { - if (item.second == devReqInfo.deviceId) { - HILOGW("HichainAdapter::bind device is binding, update call back."); - } - } - - int64_t requestId = GenRequestId(); - std::shared_ptr clientChannel = - std::make_shared(requestId, *deviceGroupManager_, onError_); - if (clientChannel->Connect(devReqInfo.ipAddr, PORT) == -1) { - HILOGE("HichainAdapter::bind failed to connect to server, create channel failed."); - return CREATE_CHANNEL_FAILED; - } - - // start the client channel to recevice data - auto receiveFunc = [&clientChannel]() { - clientChannel->Receive(); - }; - threadPool_.AddTask(receiveFunc); - - std::string groupId = GetGroupIdByName(PEER_TO_PEER_GROUP, DEVICE_MANAGER_GROUPNAME); - if (groupId == "") { - HILOGE("HichainAdapter::bind group not exist, begin to create group."); - int32_t ret = CreateGroup(requestId); - if (ret != 0) { - HILOGE("HichainAdapter::bind faild to start create group task, ret: %{public}d.", ret); - return GROUP_CREATE_FAILED; - } - } else { - HILOGE("HichainAdapter::bind group exist, begin to add member."); - int ret = AddMemeber(requestId, groupId, PIN_CODE); - if (ret != 0) { - HILOGE("HichainAdapter::bind faild to start add member task, ret: %{public}d.", ret); - return MEMBER_ADD_FAILED; - } - } - - clientBindReqMap_[requestId] = clientChannel; - bindingDeviceMap_[requestId] = devReqInfo.deviceId; - bindCallBackMap_[requestId] = callback; - return SUCCESS; -} - -std::string HichainAdapter::GetGroupIdByName(int32_t groupType, const std::string& groupName) -{ - HILOGI("HichainAdapter::GetGroupIdByName get group info."); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::GetGroupIdByName group manager is null."); - return ""; - } - - nlohmann::json reqParam; - reqParam[FIELD_GROUP_TYPE] = groupType; - reqParam[FIELD_GROUP_NAME] = groupName; - - char* returnGroupVec = nullptr; - uint32_t groupNum = 0; - int32_t ret = deviceGroupManager_->getGroupInfo(DEVICE_MANAGER_APP.c_str(), reqParam.dump().c_str(), - &returnGroupVec, &groupNum); - if (ret != 0) { - HILOGE("HichainAdapter::GetGroupIdByName failed to get group info, ret=%{public}d.", ret); - return ""; - } - - if (groupNum == 0) { - HILOGE("HichainAdapter::GetGroupIdByName group not exist, return empty."); - return ""; - } - - nlohmann::json groupObj = nlohmann::json::parse(returnGroupVec, nullptr, false); - if (groupObj.is_discarded()) { - HILOGE("HichainAdapter::GetGroupIdByName parse group info error, json invalid."); - return ""; - } - - for (auto& item : groupObj) { - if (item.contains(FIELD_GROUP_ID)) { - return item.at(FIELD_GROUP_ID); - } - } - - HILOGI("HichainAdapter::GetGroupIdByName group info not found, return empty"); - return ""; -} - -int32_t HichainAdapter::CreateGroup(int64_t requestId) -{ - HILOGE("HichainAdapter::CreateGroup requestId:%{public}lld.", requestId); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::CreateGroup group manager is null."); - return -1; - } - - nlohmann::json jsonObj; - jsonObj[FIELD_GROUP_TYPE] = PEER_TO_PEER_GROUP; - jsonObj[FIELD_GROUP_NAME] = DEVICE_MANAGER_GROUPNAME; - - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - - jsonObj[FIELD_DEVICE_ID] = localDeviceId; - jsonObj[FIELD_USER_TYPE] = 0; - jsonObj[FIELD_GROUP_VISIBILITY] = -1; - jsonObj[FIELD_EXPIRE_TIME] = FIELD_EXPIRE_TIME_VALUE; - - return deviceGroupManager_->createGroup(requestId, DEVICE_MANAGER_APP.c_str(), jsonObj.dump().c_str()); -} - -int32_t HichainAdapter::AddMemeber(int64_t requestId, std::string& groupId, const std::string& pinCode) -{ - HILOGE("HichainAdapter::AddMemeber requestId:%{public}lld.", requestId); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::AddMemeber group manager is null."); - return -1; - } - - nlohmann::json jsonObj; - jsonObj[FIELD_GROUP_ID] = groupId; - jsonObj[FIELD_GROUP_TYPE] = PEER_TO_PEER_GROUP; - jsonObj[FIELD_PIN_CODE] = pinCode; - jsonObj[FIELD_IS_ADMIN] = true; - return deviceGroupManager_->addMemberToGroup(requestId, DEVICE_MANAGER_APP.c_str(), jsonObj.dump().c_str()); -} - -bool HichainAdapter::OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen) -{ - HILOGI("HichainAdapter::OnTransmit requestId:%{public}lld, size:%{public}d.", requestId, dataLen); - if (clientBindReqMap_.count(requestId) > 0) { - HILOGI("HichainAdapter::OnTransmit client send to server."); - return clientBindReqMap_[requestId]->Send((const char*) data, dataLen); - } else { - HILOGI("HichainAdapter::OnTransmit server send to client."); - return deviceServerInst_->Send((const char*) data, dataLen); - } -} - -void HichainAdapter::OnGroupCreated(int64_t requestId, const char *groupInfo) -{ - nlohmann::json jsonObject = nlohmann::json::parse(groupInfo); - if (jsonObject.find(FIELD_GROUP_ID) == jsonObject.end()) { - HILOGE("HichainAdapter::onGroupCreated failed to get groupId."); - OnBindFailed(requestId, GROUP_CREATE_FAILED); - return; - } - - std::string groupId = jsonObject.at(FIELD_GROUP_ID).get(); - HILOGI("HichainAdapter::onGroupCreated group create success,groupId:%{public}s.", GetAnonyString(groupId).c_str()); - - // group创建成功之后，需要添加把对端设备添加到创建好的群组中 - int ret = AddMemeber(requestId, groupId, PIN_CODE); - if (ret != 0) { - HILOGE("HichainAdapter::onGroupCreated faild to start add member task, ret: %{public}d.", ret); - OnBindFailed(requestId, MEMBER_ADD_FAILED); - return; - } -} - -char* HichainAdapter::OnBindRequest(int64_t requestId, int operationCode, const char *reqParams) -{ - (void)requestId; - (void)operationCode; - (void)reqParams; - - HILOGI("HichainAdapter::OnBindRequest."); - nlohmann::json jsonObj; - jsonObj[FIELD_CONFIRMATION] = REQUEST_ACCEPTED; - jsonObj[FIELD_PIN_CODE] = PIN_CODE; - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - jsonObj[FIELD_DEVICE_ID] = localDeviceId; - - std::string jsonStr = jsonObj.dump(); - char *buffer = strdup(jsonStr.c_str()); - return buffer; -} - -void HichainAdapter::OnBindSuccess(int64_t requestId, const char* returnData) -{ - HILOGI("HichainAdapter::OnBindSuccess requestId:%{public}lld,dataLen:%{public}d.", requestId, strlen(returnData)); - if (bindCallBackMap_.count(requestId) == 1) { - bindCallBackMap_[requestId]->onBindSuccess(bindingDeviceMap_[requestId], returnData); - bindCallBackMap_.erase(requestId); - } - - if (clientBindReqMap_.count(requestId) == 1) { - clientBindReqMap_[requestId]->ResetConnection(); - clientBindReqMap_[requestId].reset(); - clientBindReqMap_.erase(requestId); - } - - if (bindingDeviceMap_.count(requestId) == 1) { - bindingDeviceMap_.erase(requestId); - } - - deviceServerInst_->ResetConnection(); -} - -int64_t HichainAdapter::GenRequestId() -{ - int64_t requestId = 0; - do { - requestId = (int64_t)requestIdIndex_ + MIN_REQUEST_ID; - if (requestId > MAX_REQUEST_ID) { - requestId = MIN_REQUEST_ID; - requestIdIndex_ = 0; - } else { - requestIdIndex_++; - } - } while (clientBindReqMap_.count(requestId) != 0); - return requestId; -} - -void HichainAdapter::OnBindFailed(int64_t requestId, int32_t errorCode) -{ - HILOGI("HichainAdapter::OnBindFailed requestId:%{public}lld, errorCode:%{public}d.", requestId, errorCode); - if (bindCallBackMap_.count(requestId) == 1) { - bindCallBackMap_[requestId]->onBindFailed(bindingDeviceMap_[requestId], errorCode); - bindCallBackMap_.erase(requestId); - } - - if (clientBindReqMap_.count(requestId) == 1) { - clientBindReqMap_[requestId].reset(); - clientBindReqMap_.erase(requestId); - } - - if (bindingDeviceMap_.count(requestId) == 1) { - bindingDeviceMap_.erase(requestId); - } -} - -void HichainAdapter::UnBind(const std::string& deviceId) -{ - // reserved interface, to be implemented - (void)deviceId; -} - -void HichainAdapter::OnUnBindFinished() -{ - // reserved interface, to be implemented -} - -bool HichainAuthCallBack::onTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen) -{ - HILOGI("HichainAuthCallBack::onTransmit requestId:%{public}lld,size:%{public}d.", requestId, dataLen); - return HichainAdapter::GetInstance().OnTransmit(requestId, data, dataLen); -} - -void HichainAuthCallBack::onSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen) -{ - (void)requestId; - (void)sessionKey; - HILOGI("HichainAuthCallBack::onSessionKeyReturned size:%{public}d.", sessionKeyLen); -} - -void HichainAuthCallBack::onFinish(int64_t requestId, int operationCode, const char *returnData) -{ - HILOGI("HichainAuthCallBack::onFinish reqId:%{public}lld, operation:%{public}d.", requestId, operationCode); - if (operationCode == GroupOperationCode::GROUP_CREATE) { - HichainAdapter::GetInstance().OnGroupCreated(requestId, returnData); - return; - } - - if (operationCode == GroupOperationCode::MEMBER_INVITE || operationCode == GroupOperationCode::MEMBER_JOIN) { - HichainAdapter::GetInstance().OnBindSuccess(requestId, returnData); - } -} - -void HichainAuthCallBack::onError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn) -{ - (void)errorReturn; - HILOGI("HichainAuthCallBack::onError reqId:%{public}lld, operation:%{public}d, errorCode:%{public}d.", - requestId, operationCode, errorCode); - HichainAdapter::GetInstance().OnBindFailed(requestId, errorCode); -} - -char* HichainAuthCallBack::onBindRequest(int64_t requestId, int operationCode, const char *reqParams) -{ - HILOGI("HichainAuthCallBack::onBindRequest reqId:%{public}lld, operation: %{public}d.", requestId, operationCode); - return HichainAdapter::GetInstance().OnBindRequest(requestId, operationCode, reqParams); -} -} -} diff --git a/services/devicemanagerservice/src/device_manager_listener_proxy.cpp b/services/devicemanagerservice/src/device_manager_listener_proxy.cpp deleted file mode 100644 index d721ef705715290240b9827d83c337b8546452e7..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/device_manager_listener_proxy.cpp +++ /dev/null @@ -1,294 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_manager_listener_proxy.h" - -#include "ipc_types.h" - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -bool DeviceManagerListenerProxy::WriteInterfaceToken(MessageParcel &data) -{ - if (!data.WriteInterfaceToken(DeviceManagerListenerProxy::GetDescriptor())) { - HILOGE("write interface token failed"); - return false; - } - return true; -} - -int32_t DeviceManagerListenerProxy::OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_ONLINE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceOnline SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_OFFLINE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceOffline SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_CHANGE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceChanged SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDeviceFound(std::string &packageName, uint16_t subscribeId, - const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeId failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_FOUND, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceFound SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, - int32_t failedReason) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeId failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt32(failedReason)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DISCOVER_FAILED, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDiscoverFailed SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeId failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DISCOVER_SUCCESS, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDiscoverySuccess SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, - int32_t reason) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(deviceId)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt32(status)) { - HILOGE("write status failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt32(reason)) { - HILOGE("write reason failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_AUTH_RESULT, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnAuthResult SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/src/device_manager_service.cpp b/services/devicemanagerservice/src/device_manager_service.cpp deleted file mode 100644 index 5da977ab721d0802f29e1ea4310a92292070fb51..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/device_manager_service.cpp +++ /dev/null @@ -1,291 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_manager_service.h" - -#include "if_system_ability_manager.h" -#include "ipc_skeleton.h" -#include "ipc_types.h" -#include "iservice_registry.h" -#include "string_ex.h" -#include "system_ability_definition.h" - -#include "anonymous_string.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" -#include "softbus_adapter.h" - -#include "hichain_adapter.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - const int32_t THREAD_POOL_TASK_NUM = 1; -} - -IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService); - -const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(&DeviceManagerService::GetInstance()); - -DeviceManagerService::DeviceManagerService() : SystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, true) -{ - registerToService_ = false; - state_ = ServiceRunningState::STATE_NOT_START; - hichainBindCallback_ = std::make_shared(); -} - -void DeviceManagerService::OnStart() -{ - HILOGI("DeviceManagerService::OnStart start"); - if (state_ == ServiceRunningState::STATE_RUNNING) { - HILOGD("DeviceManagerService has already started."); - return; - } - if (!Init()) { - HILOGE("failed to init DeviceManagerService"); - return; - } - state_ = ServiceRunningState::STATE_RUNNING; -} - -bool DeviceManagerService::Init() -{ - HILOGI("DeviceManagerService::Init ready to init."); - if (!registerToService_) { - bool ret = Publish(this); - if (!ret) { - HILOGE("DeviceManagerService::Init Publish failed!"); - return false; - } - registerToService_ = true; - } - if (threadPool_.GetThreadsNum() == 0) { - threadPool_.Start(THREAD_POOL_TASK_NUM); - } - RegisterDeviceStateListener(); - return true; -} - -void DeviceManagerService::OnStop() -{ - HILOGI("DeviceManagerService::OnStop ready to stop service."); - state_ = ServiceRunningState::STATE_NOT_START; - registerToService_ = false; -} - -ServiceRunningState DeviceManagerService::QueryServiceState() const -{ - return state_; -} - -void DeviceManagerService::RegisterDeviceStateListener() -{ - auto registerFunc = []() { - SoftbusAdapter::GetInstance().RegSoftBusDeviceStateListener(); - HichainAdapter::GetInstance().Init(); - }; - threadPool_.AddTask(registerFunc); -} - -int32_t DeviceManagerService::RegisterDeviceManagerListener(std::string &packageName, sptr listener) -{ - if (packageName.empty() || listener == nullptr) { - HILOGE("Error: parameter invalid"); - return ERR_NULL_OBJECT; - } - - HILOGI("In, packageName: %{public}s", packageName.c_str()); - std::lock_guard autoLock(listenerLock_); - auto iter = dmListener_.find(packageName); - if (iter != dmListener_.end()) { - HILOGI("RegisterDeviceManagerListener: listener already exists"); - return ERR_NONE; - } - - sptr appRecipient = sptr(new AppDeathRecipient()); - if (!listener->AddDeathRecipient(appRecipient)) { - HILOGE("RegisterDeviceManagerListener: AddDeathRecipient Failed"); - } - dmListener_[packageName] = listener; - appRecipient_[packageName] = appRecipient; - return ERR_NONE; -} - -int32_t DeviceManagerService::UnRegisterDeviceManagerListener(std::string &packageName) -{ - if (packageName.empty()) { - HILOGE("Error: parameter invalid"); - return ERR_NULL_OBJECT; - } - - HILOGI("In, packageName: %{public}s", packageName.c_str()); - std::lock_guard autoLock(listenerLock_); - auto listenerIter = dmListener_.find(packageName); - if (listenerIter == dmListener_.end()) { - HILOGI("UnRegisterDeviceManagerListener: listener not exists"); - return ERR_NONE; - } - - auto recipientIter = appRecipient_.find(packageName); - if (recipientIter == appRecipient_.end()) { - HILOGI("UnRegisterDeviceManagerListener: appRecipient not exists"); - dmListener_.erase(packageName); - return ERR_NONE; - } - - auto listener = listenerIter->second; - auto appRecipient = recipientIter->second; - listener->RemoveDeathRecipient(appRecipient); - appRecipient_.erase(packageName); - dmListener_.erase(packageName); - return ERR_NONE; -} - -int32_t DeviceManagerService::RegisterDeviceStateCallback(std::string &packageName, std::string &extra) -{ - HILOGI("In, packageName: %{public}s", packageName.c_str()); - devStateCallbackParas_[packageName] = extra; - return ERR_NONE; -} - -int32_t DeviceManagerService::UnRegisterDeviceStateCallback(std::string &packageName) -{ - HILOGI("In, packageName: %{public}s", packageName.c_str()); - devStateCallbackParas_.erase(packageName); - return ERR_NONE; -} - -int32_t DeviceManagerService::GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - HILOGI("In, packageName: %{public}s", packageName.c_str()); - return SoftbusAdapter::GetSoftbusTrustDevices(packageName, extra, deviceList); -} - -int32_t DeviceManagerService::StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) -{ - HILOGI("In, packageName: %{public}s, subscribeId %{public}d", packageName.c_str(), - (int32_t)subscribeInfo.subscribeId); - return SoftbusAdapter::GetInstance().StartSoftbusDiscovery(packageName, subscribeInfo); -} - -int32_t DeviceManagerService::StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) -{ - HILOGI("In, packageName: %{public}s, subscribeId %{public}d", packageName.c_str(), (int32_t)subscribeId); - return SoftbusAdapter::GetInstance().StopSoftbusDiscovery(packageName, subscribeId); -} - -int32_t DeviceManagerService::AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, - std::string &extra) -{ - (void)extra; - - std::string deviceId = deviceInfo.deviceId; - if (SoftbusAdapter::IsDeviceOnLine(deviceId)) { - HILOGI("AuthenticateDevice, deviceId is already in trusted list, return."); - return ERR_DEVICEMANAGER_DEVICE_ALREADY_TRUSTED; - } - - DeviceReqInfo devReqInfo; - devReqInfo.deviceId = deviceId; - HILOGI("AuthenticateDevice In, packageName: %{public}s, deviceId %{public}s", packageName.c_str(), - GetAnonyString(deviceId).c_str()); - int32_t ret = SoftbusAdapter::GetInstance().GetConnectionIpAddr(deviceId, devReqInfo.ipAddr); - if (ret != ERR_OK) { - HILOGE("AuthenticateDevice Error: can not find ip by deviceId."); - return ret; - } - - authCallbackParas_[deviceId] = packageName; - return HichainAdapter::GetInstance().Bind(devReqInfo, hichainBindCallback_, false); -} - -const std::map>& DeviceManagerService::GetDmListener() -{ - return dmListener_; -} - -const sptr DeviceManagerService::GetDmListener(std::string packageName) const -{ - auto iter = dmListener_.find(packageName); - if (iter == dmListener_.end()) { - return nullptr; - } - auto remote = iter->second; - sptr dmListener = iface_cast(remote); - return dmListener; -} - -void AppDeathRecipient::OnRemoteDied(const wptr& remote) -{ - HILOGW("AppDeathRecipient: OnRemoteDied"); - std::map> listeners = DeviceManagerService::GetInstance().GetDmListener(); - std::string packageName; - for (auto iter : listeners) { - if (iter.second == remote.promote()) { - packageName = iter.first; - break; - } - } - - if (packageName.empty()) { - HILOGE("AppDeathRecipient: OnRemoteDied, no packageName matched"); - return; - } - - HILOGI("AppDeathRecipient: OnRemoteDied for %{public}s", packageName.c_str()); - DeviceManagerService::GetInstance().UnRegisterDeviceManagerListener(packageName); -} - - -void HiChainBindCallback::onBindSuccess(std::string deviceId, const char *returnData) -{ - (void)returnData; - HILOGI("onBindSuccess, DM bind succeed, deviceId: %{public}s", GetAnonyString(deviceId).c_str()); - auto res = DeviceManagerService::GetInstance().authCallbackParas_; - auto iter = res.find(deviceId); - if (iter == res.end()) { - HILOGE("onBindSuccess deviceInfo not found by deviceId."); - return; - } - - std::string packageName = iter->second; - sptr dmListener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (dmListener != nullptr) { - dmListener->OnAuthResult(packageName, deviceId, DmBindStatus::STATE_BIND_SUCCESS, ERR_NONE); - } - - int32_t ret = SoftbusAdapter::GetInstance().SoftbusJoinLnn(deviceId); - HILOGI("onBindSuccess, DM bind succeed, joinlnn ret=%{public}d.", ret); -} - -void HiChainBindCallback::onBindFailed(std::string deviceId, int32_t errorCode) -{ - HILOGI("onBindFailed, DM bind failed, deviceId: %{public}s, errorCode: %{public}d", - GetAnonyString(deviceId).c_str(), errorCode); - auto res = DeviceManagerService::GetInstance().authCallbackParas_; - auto iter = res.find(deviceId); - if (iter == res.end()) { - HILOGE("onBindFailed deviceInfo not found by deviceId."); - return; - } - - std::string packageName = iter->second; - sptr dmListener = DeviceManagerService::GetInstance().GetDmListener(packageName); - - dmListener->OnAuthResult(packageName, deviceId, DmBindStatus::STATE_BIND_FAILD, errorCode); -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/src/device_manager_stub.cpp b/services/devicemanagerservice/src/device_manager_stub.cpp deleted file mode 100644 index 9ab1bf5ca76e1c82531b7d45597fa6daa9895ef4..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/device_manager_stub.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "device_manager_stub.h" - -#include "ipc_skeleton.h" -#include "ipc_types.h" - - -#include "device_manager_log.h" - -using namespace std; - -namespace OHOS { -namespace DistributedHardware { -DeviceManagerStub::DeviceManagerStub() -{ - memberFuncMap_[GET_TRUST_DEVICE_LIST] = &DeviceManagerStub::GetTrustedDeviceListInner; - memberFuncMap_[REGISTER_DEVICE_MANAGER_LISTENER] = &DeviceManagerStub::RegisterDeviceManagerListenerInner; - memberFuncMap_[UNREGISTER_DEVICE_MANAGER_LISTENER] = &DeviceManagerStub::UnRegisterDeviceManagerListenerInner; - memberFuncMap_[REGISTER_DEVICE_STATE_CALLBACK] = &DeviceManagerStub::RegisterDeviceStateCallbackInner; - memberFuncMap_[UNREGISTER_DEVICE_STATE_CALLBACK] = &DeviceManagerStub::UnRegisterDeviceStateCallbackInner; - memberFuncMap_[START_DEVICE_DISCOVER] = &DeviceManagerStub::StartDeviceDiscoveryInner; - memberFuncMap_[STOP_DEVICE_DISCOVER] = &DeviceManagerStub::StopDeviceDiscoveryInner; - memberFuncMap_[AUTHENTICATE_DEVICE] = &DeviceManagerStub::AuthenticateDeviceInner; -} - -DeviceManagerStub::~DeviceManagerStub() -{ - memberFuncMap_.clear(); -} - -int32_t DeviceManagerStub::OnRemoteRequest(uint32_t code, - MessageParcel& data, MessageParcel &reply, MessageOption &option) -{ - HILOGI("code = %{public}d, flags= %{public}d.", code, option.GetFlags()); - auto itFunc = memberFuncMap_.find(code); - if (itFunc != memberFuncMap_.end()) { - auto memberFunc = itFunc->second; - if (memberFunc != nullptr) { - if (!EnforceInterceToken(data)) { - HILOGE("interface token check failed!"); - return ERR_INVALID_STATE; - } - return (this->*memberFunc)(data, reply); - } - } - HILOGW("unsupport code: %{public}d", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); -} - -int32_t DeviceManagerStub::RegisterDeviceManagerListenerInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - sptr listener = data.ReadRemoteObject(); - int32_t result = RegisterDeviceManagerListener(packageName, listener); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::UnRegisterDeviceManagerListenerInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - int32_t result = UnRegisterDeviceManagerListener(packageName); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::RegisterDeviceStateCallbackInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - string extra = data.ReadString(); - HILOGI("packageName:%{public}s, extra:%{public}s", packageName.c_str(), extra.c_str()); - int32_t result = RegisterDeviceStateCallback(packageName, extra); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::UnRegisterDeviceStateCallbackInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - HILOGI("packageName:%{public}s", packageName.c_str()); - int32_t result = UnRegisterDeviceStateCallback(packageName); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::GetTrustedDeviceListInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - string extra = data.ReadString(); - HILOGI("packageName:%{public}s, extra:%{public}s", packageName.c_str(), extra.c_str()); - std::vector devInfos; - int32_t result = GetTrustedDeviceList(packageName, extra, devInfos); - reply.WriteInt32(devInfos.size()); - for (auto &it : devInfos) { - if (!reply.WriteParcelable(&it)) { - return ERR_INVALID_VALUE; - } - } - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -template -int32_t DeviceManagerStub::GetParcelableInfo(MessageParcel &reply, T &parcelableInfo) -{ - std::unique_ptr info(reply.ReadParcelable()); - if (!info) { - HILOGE("readParcelableInfo failed"); - return ERR_INVALID_VALUE; - } - parcelableInfo = *info; - return ERR_NONE; -} - -int32_t DeviceManagerStub::StartDeviceDiscoveryInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - DmSubscribeInfo subscribeInfo; - int32_t result = GetParcelableInfo(data, subscribeInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - HILOGI("packageName:%{public}s, subscribeId: %{public}d", packageName.c_str(), subscribeInfo.subscribeId); - result = StartDeviceDiscovery(packageName, subscribeInfo); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::StopDeviceDiscoveryInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt32(); - HILOGI("packageName:%{public}s, subscribeId: %{public}d", packageName.c_str(), subscribeId); - int32_t result = StopDeviceDiscovery(packageName, subscribeId); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::AuthenticateDeviceInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - string extra = data.ReadString(); - HILOGI("packageName:%{public}s, extra:%{public}s", packageName.c_str(), extra.c_str()); - result = AuthenticateDevice(packageName, deviceInfo, extra); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -bool DeviceManagerStub::EnforceInterceToken(MessageParcel& data) -{ - u16string interfaceToken = data.ReadInterfaceToken(); - u16string descriptor = DeviceManagerStub::GetDescriptor(); - return interfaceToken == descriptor; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/ipc_server_adapter.cpp b/services/devicemanagerservice/src/ipc/ipc_server_adapter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..095dcebda9de57eb02180784559f30aef4e872ff --- /dev/null +++ b/services/devicemanagerservice/src/ipc/ipc_server_adapter.cpp @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2021 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. + */ +#include + +#include "securec.h" + +#include "anonymous_string.h" +#include "auth_manager.h" +#include "constants.h" +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "dm_ability_manager.h" +#include "encrypt_utils.h" +#include "ipc_server_adapter.h" +#include "ipc_server_listener.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcServerAdapter); + +int32_t IpcServerAdapter::CheckParamValid(nlohmann::json &extraJson, const DmAppImageInfo &imageInfo) +{ + if (!extraJson.contains(APP_NAME_KEY) || + !extraJson.contains(APP_DESCRIPTION_KEY) || + !extraJson.contains(AUTH_TYPE)) { + DMLOG(DM_LOG_ERROR, "Invalid para"); + return DEVICEMANAGER_INVALID_VALUE; + } + + std::string appName = extraJson[APP_NAME_KEY]; + std::string appDescription = extraJson[APP_DESCRIPTION_KEY]; + + if (appName.empty() || appDescription.empty()) { + DMLOG(DM_LOG_ERROR, "Invalid app image info"); + return DEVICEMANAGER_INVALID_VALUE; + } + if (extraJson[AUTH_TYPE] != AUTH_TYPE_PIN) { + DMLOG(DM_LOG_ERROR, "invalid auth type, only support pin auth"); + return DEVICEMANAGER_INVALID_VALUE; + } + return DEVICEMANAGER_OK; +} + +int32_t IpcServerAdapter::GenRandInt(int32_t randMin, int32_t randMax) +{ + std::random_device randDevice; + std::mt19937 genRand(randDevice()); + std::uniform_int_distribution disRand(randMin, randMax); + return disRand(genRand); +} + +int32_t IpcServerAdapter::ModuleInit() +{ + if (SoftbusAdapter::Init() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "softbus adapter init failed"); + return DEVICEMANAGER_INIT_FAILED; + } + if (HichainConnector::GetInstance().Init() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "hichain connector init failed"); + return DEVICEMANAGER_INIT_FAILED; + } + return DEVICEMANAGER_OK; +} + +int32_t IpcServerAdapter::GetTrustedDeviceList(std::string &pkgName, std::string &extra, + DmDeviceInfo **info, int32_t *infoNum) +{ + DMLOG(DM_LOG_INFO, "In, pkgName: %s", pkgName.c_str()); + NodeBasicInfo *nodeInfo = nullptr; + int32_t ret = SoftbusAdapter::GetTrustDevices(pkgName, &nodeInfo, infoNum); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "DM_GetSoftbusTrustDevices failed with ret %d", ret); + return ret; + } + *info = nullptr; + if (*infoNum > 0) { + *info = (DmDeviceInfo *)malloc(sizeof(DmDeviceInfo) * (*infoNum)); + } + for (int32_t i = 0; i < *infoNum; ++i) { + NodeBasicInfo *nodeBasicInfo = nodeInfo + i; + DmDeviceInfo *deviceInfo = *info + i; + + (void)memcpy_s(deviceInfo->deviceId, sizeof(deviceInfo->deviceId), nodeBasicInfo->networkId, + std::min(sizeof(deviceInfo->deviceId), sizeof(nodeBasicInfo->networkId))); + (void)memcpy_s(deviceInfo->deviceName, sizeof(deviceInfo->deviceName), nodeBasicInfo->deviceName, + std::min(sizeof(deviceInfo->deviceName), sizeof(nodeBasicInfo->deviceName))); + deviceInfo->deviceTypeId = (DMDeviceType)nodeBasicInfo->deviceTypeId; + } + FreeNodeInfo(nodeInfo); + DMLOG(DM_LOG_INFO, "success, pkgName:%s, deviceCount %d", pkgName.c_str(), *infoNum); + return DEVICEMANAGER_OK; +} + +int32_t IpcServerAdapter::StartDeviceDiscovery(std::string &pkgName, DmSubscribeInfo &dmSubscribeInfo) +{ + DMLOG(DM_LOG_INFO, "In, pkgName: %s, subscribeId %d", pkgName.c_str(), + (int32_t)dmSubscribeInfo.subscribeId); + + DMLOG(DM_LOG_INFO, "capability: %s", dmSubscribeInfo.capability); + SubscribeInfo subscribeInfo; + + subscribeInfo.subscribeId = dmSubscribeInfo.subscribeId; + subscribeInfo.mode = (DiscoverMode)dmSubscribeInfo.mode; + subscribeInfo.medium = (ExchanageMedium)dmSubscribeInfo.medium; + subscribeInfo.freq = (ExchangeFreq)dmSubscribeInfo.freq; + subscribeInfo.isSameAccount = dmSubscribeInfo.isSameAccount; + subscribeInfo.isWakeRemote = dmSubscribeInfo.isWakeRemote; + subscribeInfo.capability = dmSubscribeInfo.capability; + subscribeInfo.capabilityData = nullptr; + subscribeInfo.dataLen = 0; + return SoftbusAdapter::StartDiscovery(pkgName, &subscribeInfo); +} + +int32_t IpcServerAdapter::StopDiscovery(std::string &pkgName, uint16_t subscribeId) +{ + DMLOG(DM_LOG_INFO, "In, pkgName: %s, subscribeId %d", pkgName.c_str(), (int32_t)subscribeId); + return SoftbusAdapter::StopDiscovery(pkgName, subscribeId); +} + +int32_t IpcServerAdapter::AuthenticateDevice(std::string &pkgName, const DmDeviceInfo &deviceInfo, + const DmAppImageInfo &imageInfo, std::string &extra) +{ + if (pkgName.empty() || extra.empty()) { + DMLOG(DM_LOG_ERROR, "invalid para"); + return DEVICEMANAGER_INVALID_VALUE; + } + nlohmann::json jsonObject = nlohmann::json::parse(extra, nullptr, false); + if (jsonObject.is_discarded()) { + DMLOG(DM_LOG_ERROR, "AuthenticateDevice extra jsonStr error"); + return DEVICEMANAGER_INVALID_VALUE; + } + int32_t ret = CheckParamValid(jsonObject, imageInfo); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "AuthenticateDevice para invalid, ret %d", ret); + return ret; + } + DMLOG(DM_LOG_INFO, "AuthenticateDevice In, pkgName: %s, deviceId %s", pkgName.c_str(), + GetAnonyString(deviceInfo.deviceId).c_str()); + + AuthManager::GetInstance().AuthDeviceGroup(pkgName, deviceInfo, imageInfo, extra); + return DEVICEMANAGER_OK; +} + +int32_t IpcServerAdapter::CheckAuthentication(std::string &authPara) +{ + if (authPara.empty()) { + DMLOG(DM_LOG_INFO, " DeviceManagerIpcAdapter::CheckAuthentication check authPara failed"); + return DEVICEMANAGER_INVALID_VALUE; + } + DMLOG(DM_LOG_INFO, " DeviceManagerIpcAdapter::CheckAuthentication"); + return AuthManager::GetInstance().CheckAuthentication(authPara); +} + +int32_t IpcServerAdapter::GetAuthenticationParam(std::string &pkgName, DmAuthParam &authParam) +{ + if (pkgName.empty()) { + DMLOG(DM_LOG_ERROR, "invalid para"); + return DEVICEMANAGER_INVALID_VALUE; + } + + DmAbilityManager::GetInstance().StartAbilityDone(); + AuthManager::GetInstance().GetAuthenticationParam(authParam); + return DEVICEMANAGER_OK; +} + +int32_t IpcServerAdapter::SetUserOperation(std::string &pkgName, int32_t action) +{ + if (pkgName.empty()) { + DMLOG(DM_LOG_ERROR, "invalid para"); + return DEVICEMANAGER_INVALID_VALUE; + } + + AuthManager::GetInstance().OnUserOperate(action); + return SUCCESS; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/ipc_server_listener_adapter.cpp b/services/devicemanagerservice/src/ipc/ipc_server_listener_adapter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..fe29635d25d6059c16d0f9af01d42132f7aabe7e --- /dev/null +++ b/services/devicemanagerservice/src/ipc/ipc_server_listener_adapter.cpp @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_listener_adapter.h" + +#include + +#include "securec.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "anonymous_string.h" + +#include "ipc_notify_auth_result_req.h" +#include "ipc_notify_check_auth_result_req.h" +#include "ipc_notify_device_found_req.h" +#include "ipc_notify_device_state_req.h" +#include "ipc_notify_discover_result_req.h" +#include "ipc_notify_dmfa_result_req.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcServerListenerAdapter); + +void IpcServerListenerAdapter::OnDeviceStateChange(DmDeviceState state, DmDeviceInfo &deviceInfo) +{ + DMLOG(DM_LOG_INFO, "OnDeviceStateChange"); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetDeviceState(state); + pReq->SetDeviceInfo(deviceInfo); + ipcServerListener_.SendAll(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp); +} + +void IpcServerListenerAdapter::OnDeviceFound(std::string &pkgName, uint16_t originId, + DmDeviceInfo &deviceInfo) +{ + DMLOG(DM_LOG_INFO, "call OnDeviceFound for %s, originId %d, deviceId %s", + pkgName.c_str(), originId, GetAnonyString(std::string(deviceInfo.deviceId)).c_str()); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetPkgName(pkgName); + pReq->SetSubscribeId(originId); + pReq->SetDeviceInfo(deviceInfo); + ipcServerListener_.SendRequest(SERVER_DEVICE_FOUND, pReq, pRsp); +} + +void IpcServerListenerAdapter::OnDiscoverFailed(std::string &pkgName, uint16_t originId, + DiscoveryFailReason failReason) +{ + DMLOG(DM_LOG_INFO, "OnDiscoverFailed"); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetPkgName(pkgName); + pReq->SetSubscribeId(originId); + pReq->SetResult(failReason); + ipcServerListener_.SendRequest(SERVER_DISCOVER_FINISH, pReq, pRsp); +} + +void IpcServerListenerAdapter::OnDiscoverySuccess(std::string &pkgName, uint16_t originId) +{ + DMLOG(DM_LOG_INFO, "OnDiscoverySuccess"); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetPkgName(pkgName); + pReq->SetSubscribeId(originId); + pReq->SetResult(DEVICEMANAGER_OK); + ipcServerListener_.SendRequest(SERVER_DISCOVER_FINISH, pReq, pRsp); +} + +void IpcServerListenerAdapter::OnAuthResult(std::string &pkgName, std::string &deviceId, int32_t pinToken, + uint32_t status, uint32_t reason) +{ + DMLOG(DM_LOG_INFO, "%s, package: %s, deviceId: %s", __FUNCTION__, pkgName.c_str(), + GetAnonyString(deviceId).c_str()); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetPkgName(pkgName); + pReq->SetDeviceId(deviceId); + pReq->SetPinToken(pinToken); + pReq->SetStatus(status); + pReq->SetReason(reason); + ipcServerListener_.SendRequest(SERVER_AUTH_RESULT, pReq, pRsp); +} + +void IpcServerListenerAdapter::OnCheckAuthResult(std::string &pkgName, std::string &authParam, int32_t resultCode, + int32_t flag) +{ + DMLOG(DM_LOG_INFO, "OnCheckResult, authParam: %s, errorCode: %d", + GetAnonyString(authParam).c_str(), resultCode); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetPkgName(pkgName); + pReq->SetDeviceId(authParam); + pReq->SetResult(resultCode); + pReq->SetFlag(flag); + ipcServerListener_.SendRequest(SERVER_CHECK_AUTH_RESULT, pReq, pRsp); +} + +void IpcServerListenerAdapter::OnFaCall(std::string &pkgName, std::string ¶mJson) +{ + DMLOG(DM_LOG_INFO, "OnFaCallSuccess"); + std::shared_ptr pReq = std::make_shared(); + std::shared_ptr pRsp = std::make_shared(); + + pReq->SetPkgName(pkgName); + pReq->SetJsonParam(paramJson); + ipcServerListener_.SendRequest(SERVER_DEVICEMANAGER_FA_NOTIFY, pReq, pRsp); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_cmd_parser.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_cmd_parser.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b4e185050bc6fee98770598afd4a61f5370033f3 --- /dev/null +++ b/services/devicemanagerservice/src/ipc/lite/ipc_cmd_parser.cpp @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_cmd_register.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +#include "ipc_def.h" +#include "ipc_notify_auth_result_req.h" +#include "ipc_notify_check_auth_result_req.h" +#include "ipc_notify_device_found_req.h" +#include "ipc_notify_device_state_req.h" +#include "ipc_notify_discover_result_req.h" +#include "ipc_server_adapter.h" +#include "ipc_server_stub.h" + +namespace OHOS { +namespace DistributedHardware { +ON_IPC_SET_REQUEST(SERVER_DEVICE_STATE_NOTIFY, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + int32_t deviceState = pReq->GetDeviceState(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushInt32(&request, deviceState); + IpcIoPushFlatObj(&request, &deviceInfo, sizeof(DmDeviceInfo)); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DEVICE_STATE_NOTIFY, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + uint16_t subscribeId = pReq->GetSubscribeId(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushUint16(&request, subscribeId); + IpcIoPushFlatObj(&request, &deviceInfo, sizeof(DmDeviceInfo)); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DEVICE_FOUND, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + uint16_t subscribeId = pReq->GetSubscribeId(); + int32_t result = pReq->GetResult(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushUint16(&request, subscribeId); + IpcIoPushInt32(&request, result); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DISCOVER_FINISH, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_AUTH_RESULT, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string deviceId = pReq->GetDeviceId(); + int32_t pinToken = pReq->GetPinToken(); + int32_t status = pReq->GetStatus(); + int32_t reason = pReq->GetReason(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushString(&request, deviceId.c_str()); + IpcIoPushInt32(&request, pinToken); + IpcIoPushInt32(&request, status); + IpcIoPushInt32(&request, reason); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_AUTH_RESULT, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_CHECK_AUTH_RESULT, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string deviceId = pReq->GetDeviceId(); + int32_t result = pReq->GetResult(); + int32_t flag = pReq->GetFlag(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushString(&request, deviceId.c_str()); + IpcIoPushInt32(&request, result); + IpcIoPushInt32(&request, flag); + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_CHECK_AUTH_RESULT, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DEVICEMANAGER_OK; +} + +ON_IPC_SERVER_CMD(GET_TRUST_DEVICE_LIST, IpcIo &req, IpcIo &reply) +{ + DMLOG(DM_LOG_INFO, "enter GetTrustedDeviceList."); + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&req, &len); + std::string extra = (const char *)IpcIoPopString(&req, &len); + DmDeviceInfo *info = nullptr; + int32_t infoNum = 0; + int32_t ret = IpcServerAdapter::GetInstance().GetTrustedDeviceList(pkgName, extra, &info, &infoNum); + IpcIoPushInt32(&reply, infoNum); + if (infoNum > 0) { + IpcIoPushFlatObj(&reply, info, sizeof(DmDeviceInfo) * infoNum); + free(info); + } + IpcIoPushInt32(&reply, ret); +} + +ON_IPC_SERVER_CMD(REGISTER_DEVICE_MANAGER_LISTENER, IpcIo &req, IpcIo &reply) +{ + RegisterDeviceManagerListener(&req, &reply); +} + +ON_IPC_SERVER_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, IpcIo &req, IpcIo &reply) +{ + UnRegisterDeviceManagerListener(&req, &reply); +} + +ON_IPC_SERVER_CMD(START_DEVICE_DISCOVER, IpcIo &req, IpcIo &reply) +{ + DMLOG(DM_LOG_INFO, "StartDeviceDiscovery service listener."); + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&req, &len); + uint32_t size = 0; + DmSubscribeInfo *pDmSubscribeInfo = (DmSubscribeInfo*)IpcIoPopFlatObj(&req, &size); + + int32_t ret = IpcServerAdapter::GetInstance().StartDeviceDiscovery(pkgName, *pDmSubscribeInfo); + IpcIoPushInt32(&reply, ret); +} + +ON_IPC_SERVER_CMD(STOP_DEVICE_DISCOVER, IpcIo &req, IpcIo &reply) +{ + DMLOG(DM_LOG_INFO, "StopDeviceDiscovery service listener."); + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&req, &len); + uint16_t subscribeId = IpcIoPopUint16(&req); + int32_t ret = IpcServerAdapter::GetInstance().StopDiscovery(pkgName, subscribeId); + IpcIoPushInt32(&reply, ret); +} + +ON_IPC_SERVER_CMD(AUTHENTICATE_DEVICE, IpcIo &req, IpcIo &reply) +{ + DMLOG(DM_LOG_INFO, "AuthenticateDevice service listener."); + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(&req, &len); + size_t extraLen = 0; + std::string extra = (const char *)IpcIoPopString(&req, &extraLen); + uint32_t size; + DmDeviceInfo *deviceInfo = (DmDeviceInfo*)IpcIoPopFlatObj(&req, &size); + DmAppImageInfo imageInfo(nullptr, 0, nullptr, 0); + int32_t ret = IpcServerAdapter::GetInstance().AuthenticateDevice(pkgName, *deviceInfo, imageInfo, extra); + IpcIoPushInt32(&reply, ret); +} + +ON_IPC_SERVER_CMD(CHECK_AUTHENTICATION, IpcIo &req, IpcIo &reply) +{ + DMLOG(DM_LOG_INFO, "CheckAuthentication service listener."); + size_t authParaLen = 0; + std::string authPara = (const char *)IpcIoPopString(&req, &authParaLen); + int32_t ret = IpcServerAdapter::GetInstance().CheckAuthentication(authPara); + IpcIoPushInt32(&reply, ret); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_server_listener.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_server_listener.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ad2141de87959ccf469b6ab1058d4747ec9a832c --- /dev/null +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_listener.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_listener.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" + +#include "ipc_cmd_register.h" +#include "ipc_def.h" +#include "ipc_server_listenermgr.h" +#include "ipc_server_adapter.h" + +namespace OHOS { +namespace DistributedHardware { +void IpcServerListener::CommonSvcToIdentity(CommonSvcId *svcId, SvcIdentity *identity) +{ + identity->handle = svcId->handle; + identity->token = svcId->token; + identity->cookie = svcId->cookie; +#ifdef __LINUX__ + identity->ipcContext = svcId->ipcCtx; +#endif +} + +int32_t IpcServerListener::GetIdentityByPkgName(std::string &name, SvcIdentity *svc) +{ + CommonSvcId svcId; + if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(name, &svcId) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "get identity failed."); + return DEVICEMANAGER_FAILED; + } + CommonSvcToIdentity(&svcId, svc); + return DEVICEMANAGER_OK; +} + +int32_t IpcServerListener::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + std::string pkgName = req->GetPkgName(); + SvcIdentity svc; + if (GetIdentityByPkgName(pkgName, &svc) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "ondevice found callback get listener failed."); + return DEVICEMANAGER_FAILED; + } + + IpcIo io; + uint8_t data[MAX_DM_IPC_LEN] = {0}; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, io, data, MAX_DM_IPC_LEN) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_DEBUG, "SetRequest failed cmdCode:%d", cmdCode); + return DEVICEMANAGER_FAILED; + } + if (::SendRequest(nullptr, svc, cmdCode, &io, nullptr, LITEIPC_FLAG_ONEWAY, nullptr) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_DEBUG, "SendRequest failed cmdCode:%d", cmdCode); + } + return DEVICEMANAGER_OK; +} + +int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + const std::map &listenerMap = IpcServerListenermgr::GetInstance().GetAllListeners(); + for (auto &kv : listenerMap) { + SvcIdentity svc; + IpcIo io; + uint8_t data[MAX_DM_IPC_LEN] = {0}; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, io, data, MAX_DM_IPC_LEN) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_DEBUG, "SetRequest failed cmdCode:%d", cmdCode); + continue; + } + CommonSvcId svcId = kv.second; + CommonSvcToIdentity(&svcId, &svc); + if (::SendRequest(nullptr, svc, cmdCode, &io, nullptr, LITEIPC_FLAG_ONEWAY, nullptr) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_DEBUG, "SendRequest failed cmdCode:%d", cmdCode); + } + } + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_server_listenermgr.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_server_listenermgr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..59aec4fda46252bc63c198880aee84efb89c16a7 --- /dev/null +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_listenermgr.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_listenermgr.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcServerListenermgr); + +int32_t IpcServerListenermgr::RegisterListener(std::string &pkgName, const CommonSvcId *svcId) +{ + if (pkgName == "" || svcId == nullptr) { + DMLOG(DM_LOG_ERROR, "invalid param"); + return DEVICEMANAGER_FAILED; + } + DMLOG(DM_LOG_INFO, "new listener register:%s", pkgName.c_str()); + std::lock_guard autoLock(lock_); + dmListenerMap_[pkgName] = *svcId; + return DEVICEMANAGER_OK; +} + +int32_t IpcServerListenermgr::GetListenerByPkgName(std::string &pkgName, CommonSvcId *svcId) +{ + if (pkgName == "" || svcId == nullptr) { + DMLOG(DM_LOG_ERROR, "invalid param"); + return DEVICEMANAGER_FAILED; + } + std::lock_guard autoLock(lock_); + std::map::iterator iter = dmListenerMap_.find(pkgName); + if (iter == dmListenerMap_.end()) { + DMLOG(DM_LOG_ERROR, "listener not found for pkg:%s", pkgName.c_str()); + return DEVICEMANAGER_FAILED; + } + *svcId = iter->second; + return DEVICEMANAGER_OK; +} + +int32_t IpcServerListenermgr::UnregisterListener(std::string &pkgName) +{ + std::lock_guard autoLock(lock_); + dmListenerMap_.erase(pkgName); + return DEVICEMANAGER_OK; +} + +const std::map &IpcServerListenermgr::GetAllListeners() +{ + return dmListenerMap_; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c31c4a7ac6fe563458ca5527a82fca62e9273dac --- /dev/null +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2021 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. + */ + +#include +#include + +#include "device_manager_log.h" +#include "device_manager_errno.h" + +#include "ipc_server_stub.h" +#include "ipc_server_adapter.h" + +using namespace OHOS::DistributedHardware; + +static void InitAll() +{ + const int32_t DM_SERVICE_INIT_DELAY = 5; + + sleep(DM_SERVICE_INIT_DELAY); + if (IpcServerStubInit() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "IpcServerStubInit failed"); + return; + } + if (IpcServerAdapter::GetInstance().ModuleInit() != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "module init failed"); + return; + } + DMLOG(DM_LOG_INFO, "DM ipc server Init success"); +} + +int32_t main(int32_t argc, char *argv[]) +{ + (void)argc; + (void)argv; + InitAll(); + while (1) { + pause(); + } + return 0; +} \ No newline at end of file diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a14342da7c0989d6bcd82d7e8c4a41f4e46d54c2 --- /dev/null +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_stub.h" + +#include "securec.h" + +#include "liteipc_adapter.h" +#include "ohos_init.h" +#include "samgr_lite.h" +#include "iproxy_server.h" + +#include "device_manager_log.h" +#include "device_manager_errno.h" +#include "dm_subscribe_info.h" + +#include "ipc_cmd_register.h" +#include "ipc_def.h" +#include "ipc_server_listenermgr.h" +#include "ipc_server_adapter.h" + +namespace { + const int32_t WAIT_FOR_SERVER = 2; + const int32_t STACK_SIZE = 0x800; + const int32_t QUEUE_SIZE = 20; +} + +using namespace OHOS::DistributedHardware; + +struct DefaultFeatureApi { + INHERIT_SERVER_IPROXY; +}; + +struct DeviceManagerSamgrService { + INHERIT_SERVICE; + INHERIT_IUNKNOWNENTRY(DefaultFeatureApi); + Identity identity; +}; + +static int32_t DeathCb(const IpcContext *context, void *ipcMsg, IpcIo *data, void *arg) +{ + (void)context; + (void)ipcMsg; + (void)data; + if (arg == NULL) { + DMLOG(DM_LOG_ERROR, "package name is NULL."); + return DEVICEMANAGER_INVALID_PARAM; + } + CommonSvcId svcId = {0}; + std::string pkgName = (const char *)arg; + if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(pkgName, &svcId) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "not found client by package name."); + free(arg); + arg = NULL; + return DEVICEMANAGER_FAILED; + } + IpcServerListenermgr::GetInstance().UnregisterListener(pkgName); + free(arg); + arg = NULL; +#ifdef __LINUX__ + BinderRelease(svcId.ipcCtx, svcId.handle); +#endif + SvcIdentity sid = {0}; + sid.handle = svcId.handle; + sid.token = svcId.token; + sid.cookie = svcId.cookie; + UnregisterDeathCallback(sid, svcId.cbId); + + return DEVICEMANAGER_OK; +} + +int32_t RegisterDeviceManagerListener(IpcIo *req, IpcIo *reply) +{ + DMLOG(DM_LOG_INFO, "register service listener."); + size_t len = 0; + int32_t ret = DEVICEMANAGER_OK; + uint8_t *name = IpcIoPopString(req, &len); + SvcIdentity *svc = IpcIoPopSvc(req); + if (name == NULL || svc == NULL || len == 0) { + DMLOG(DM_LOG_ERROR, "get para failed"); + IpcIoPushInt32(reply, ret); + return DEVICEMANAGER_OK; + } + + CommonSvcId svcId = {0}; + svcId.handle = svc->handle; + svcId.token = svc->token; + svcId.cookie = svc->cookie; + + SvcIdentity sid = *svc; +#ifdef __LINUX__ + svcId.ipcCtx = svc->ipcContext; + BinderAcquire(svcId.ipcCtx, svcId.handle); + free(svc); + svc = NULL; +#endif + + char *pkgName = (char *)malloc(len + 1); + if (pkgName == NULL) { + DMLOG(DM_LOG_ERROR, "malloc failed!"); + IpcIoPushInt32(reply, DEVICEMANAGER_FAILED); + return DEVICEMANAGER_FAILED; + } + if (strcpy_s(pkgName, len + 1, (const char *)name) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "strcpy_s failed!"); + free(pkgName); + IpcIoPushInt32(reply, DEVICEMANAGER_FAILED); + return DEVICEMANAGER_FAILED; + } + uint32_t cbId = 0; + RegisterDeathCallback(NULL, sid, DeathCb, pkgName, &cbId); + svcId.cbId = cbId; + std::string strPkgName = (const char *)name; + ret = IpcServerListenermgr::GetInstance().RegisterListener(strPkgName, &svcId); + IpcIoPushInt32(reply, ret); + return DEVICEMANAGER_OK; +} + +int32_t UnRegisterDeviceManagerListener(IpcIo *req, IpcIo *reply) +{ + DMLOG(DM_LOG_INFO, "unregister service listener."); + size_t len = 0; + std::string pkgName = (const char *)IpcIoPopString(req, &len); + if (pkgName == "" || len == 0) { + DMLOG(DM_LOG_ERROR, "get para failed"); + return DEVICEMANAGER_FAILED; + } + + CommonSvcId svcId = {0}; + if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(pkgName, &svcId) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "not found listener by package name."); + return DEVICEMANAGER_FAILED; + } + int32_t ret = IpcServerListenermgr::GetInstance().UnregisterListener(pkgName); + if (ret == DEVICEMANAGER_OK) { +#ifdef __LINUX__ + BinderRelease(svcId.ipcCtx, svcId.handle); +#endif + SvcIdentity sid = {0}; + sid.handle = svcId.handle; + sid.token = svcId.token; + sid.cookie = svcId.cookie; + ret = UnregisterDeathCallback(sid, svcId.cbId); + } + IpcIoPushInt32(reply, ret); + return DEVICEMANAGER_OK; +} + +static const char *GetName(Service *service) +{ + (void)service; + return DEVICE_MANAGER_SERVICE_NAME; +} + +static BOOL Initialize(Service *service, Identity identity) +{ + if (service == NULL) { + DMLOG(DM_LOG_WARN, "invalid param"); + return FALSE; + } + + DeviceManagerSamgrService *mgrService = (DeviceManagerSamgrService *)service; + mgrService->identity = identity; + return TRUE; +} + +static BOOL MessageHandle(Service *service, Request *request) +{ + if ((service == NULL) || (request == NULL)) { + DMLOG(DM_LOG_WARN, "invalid param"); + return FALSE; + } + return TRUE; +} + +static TaskConfig GetTaskConfig(Service *service) +{ + (void)service; + TaskConfig config = {LEVEL_HIGH, PRI_BELOW_NORMAL, STACK_SIZE, QUEUE_SIZE, SHARED_TASK}; + return config; +} + +static int32_t OnRemoteRequest(IServerProxy *iProxy, int funcId, void *origin, + IpcIo *req, IpcIo *reply) +{ + DMLOG(DM_LOG_INFO, "Receive funcId:%d", funcId); + (void)origin; + return IpcCmdRegister::GetInstance().OnIpcServerCmd(funcId, *req, *reply); +} + +static void HOS_SystemInit(void) +{ + SAMGR_Bootstrap(); + return; +} + +int32_t IpcServerStubInit(void) +{ + HOS_SystemInit(); + return DEVICEMANAGER_OK; +} + +static void DevMgrSvcInit(void) +{ + sleep(WAIT_FOR_SERVER); + static DeviceManagerSamgrService service = { + .GetName = GetName, + .Initialize = Initialize, + .MessageHandle = MessageHandle, + .GetTaskConfig = GetTaskConfig, + SERVER_IPROXY_IMPL_BEGIN, + .Invoke = OnRemoteRequest, + IPROXY_END, + }; + + if (!SAMGR_GetInstance()->RegisterService((Service *)&service)) { + DMLOG(DM_LOG_ERROR, "%s, RegisterService failed", DEVICE_MANAGER_SERVICE_NAME); + return; + } + if (!SAMGR_GetInstance()->RegisterDefaultFeatureApi(DEVICE_MANAGER_SERVICE_NAME, GET_IUNKNOWN(service))) { + DMLOG(DM_LOG_ERROR, "%s, RegisterDefaultFeatureApi failed", DEVICE_MANAGER_SERVICE_NAME); + return; + } + DMLOG(DM_LOG_INFO, "%s, init success", DEVICE_MANAGER_SERVICE_NAME); +} +SYSEX_SERVICE_INIT(DevMgrSvcInit); diff --git a/services/devicemanagerservice/src/ipc/standard/ipc_cmd_parser.cpp b/services/devicemanagerservice/src/ipc/standard/ipc_cmd_parser.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a2378158c817a443db992fb7213ae4e623af0b93 --- /dev/null +++ b/services/devicemanagerservice/src/ipc/standard/ipc_cmd_parser.cpp @@ -0,0 +1,364 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "constants.h" +#include "ipc_cmd_register.h" +#include "ipc_def.h" +#include "ipc_notify_auth_result_req.h" +#include "ipc_notify_check_auth_result_req.h" +#include "ipc_notify_device_found_req.h" +#include "ipc_notify_device_state_req.h" +#include "ipc_notify_discover_result_req.h" +#include "ipc_server_adapter.h" +#include "ipc_server_stub.h" +#include "ipc_notify_dmfa_result_req.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +namespace OHOS { +namespace DistributedHardware { +ON_IPC_SET_REQUEST(SERVER_DEVICE_STATE_NOTIFY, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + int32_t deviceState = pReq->GetDeviceState(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(deviceState)) { + DMLOG(DM_LOG_ERROR, "write state failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteRawData(&deviceInfo, sizeof(DmDeviceInfo))) { + DMLOG(DM_LOG_ERROR, "write deviceInfo failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + uint16_t subscribeId = pReq->GetSubscribeId(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt16(subscribeId)) { + DMLOG(DM_LOG_ERROR, "write subscribeId failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteRawData(&deviceInfo, sizeof(DmDeviceInfo))) { + DMLOG(DM_LOG_ERROR, "write deviceInfo failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DEVICE_FOUND, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + uint16_t subscribeId = pReq->GetSubscribeId(); + int32_t result = pReq->GetResult(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt16(subscribeId)) { + DMLOG(DM_LOG_ERROR, "write subscribeId failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DISCOVER_FINISH, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_AUTH_RESULT, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string deviceId = pReq->GetDeviceId(); + int32_t pinToken = pReq->GetPinToken(); + int32_t status = pReq->GetStatus(); + int32_t reason = pReq->GetReason(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteString(deviceId)) { + DMLOG(DM_LOG_ERROR, "write deviceId failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(pinToken)) { + DMLOG(DM_LOG_ERROR, "write pinToken failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(status)) { + DMLOG(DM_LOG_ERROR, "write status failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(reason)) { + DMLOG(DM_LOG_ERROR, "write reason failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_AUTH_RESULT, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_SET_REQUEST(SERVER_CHECK_AUTH_RESULT, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string deviceId = pReq->GetDeviceId(); + int32_t result = pReq->GetResult(); + int32_t flag = pReq->GetFlag(); + if (!data.WriteString(pkgName)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteString(deviceId)) { + DMLOG(DM_LOG_ERROR, "write deviceId failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteInt32(flag)) { + DMLOG(DM_LOG_ERROR, "write flag failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_CHECK_AUTH_RESULT, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(GET_TRUST_DEVICE_LIST, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + std::string extra = data.ReadString(); + DMLOG(DM_LOG_INFO, "pkgName:%s, extra:%s", pkgName.c_str(), extra.c_str()); + DmDeviceInfo *info = nullptr; + int32_t infoNum = 0; + int32_t result = IpcServerAdapter::GetInstance().GetTrustedDeviceList(pkgName, extra, &info, &infoNum); + reply.WriteInt32(infoNum); + if (infoNum > 0 && info != nullptr) { + if (!reply.WriteRawData(info, sizeof(DmDeviceInfo) * infoNum)) { + DMLOG(DM_LOG_ERROR, "write subscribeInfo failed"); + } + free(info); + } + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + sptr listener = data.ReadRemoteObject(); + int32_t result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener); + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + int32_t result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName); + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(START_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + DmSubscribeInfo *subscribeInfo = (DmSubscribeInfo *)data.ReadRawData(sizeof(DmSubscribeInfo)); + DMLOG(DM_LOG_INFO, "pkgName:%s, subscribeId: %d", pkgName.c_str(), subscribeInfo->subscribeId); + int32_t result = IpcServerAdapter::GetInstance().StartDeviceDiscovery(pkgName, *subscribeInfo); + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(STOP_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + uint16_t subscribeId = data.ReadInt32(); + DMLOG(DM_LOG_INFO, "pkgName:%s, subscribeId: %d", pkgName.c_str(), subscribeId); + int32_t result = IpcServerAdapter::GetInstance().StopDiscovery(pkgName, subscribeId); + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(AUTHENTICATE_DEVICE, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + std::string extra = data.ReadString(); + DmDeviceInfo *deviceInfo = (DmDeviceInfo *)data.ReadRawData(sizeof(DmDeviceInfo)); + int32_t appIconLen = data.ReadInt32(); + int32_t appThumbnailLen = data.ReadInt32(); + uint8_t *appIcon = appIconLen > 0? (uint8_t *)data.ReadRawData(appIconLen) : nullptr; + uint8_t *appThumbnail = appThumbnailLen > 0? (uint8_t *)data.ReadRawData(appThumbnailLen) : nullptr; + DmAppImageInfo imageInfo(appIcon, appIconLen, appThumbnail, appThumbnailLen); + int32_t result = IpcServerAdapter::GetInstance().AuthenticateDevice(pkgName, *deviceInfo, imageInfo, extra); + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(CHECK_AUTHENTICATION, MessageParcel &data, MessageParcel &reply) +{ + std::string authPara = data.ReadString(); + int32_t result = IpcServerAdapter::GetInstance().CheckAuthentication(authPara); + if (!reply.WriteInt32(result)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_GET_AUTHENTCATION_INFO, MessageParcel &data, MessageParcel &reply) +{ + std::string packName = data.ReadString(); + DmAuthParam authParam; + int32_t ret = DEVICEMANAGER_OK; + DMLOG(DM_LOG_ERROR, "DeviceManagerStub:: GET_AUTHENTCATION_INFO:pkgName:%s", packName.c_str()); + IpcServerAdapter::GetInstance().GetAuthenticationParam(packName, authParam); + if (authParam.direction == AUTH_SESSION_SIDE_CLIENT) { + if (!reply.WriteInt32(authParam.direction) || !reply.WriteInt32(authParam.authType) || + !reply.WriteInt32(authParam.pinToken)) { + DMLOG(DM_LOG_ERROR,"DeviceManagerStub::wirte client fail"); + ret = DEVICEMANAGER_WRITE_FAILED; + } + return ret; + } + + int32_t appIconLen = authParam.imageinfo.GetAppIconLen(); + int32_t appThumbnailLen = authParam.imageinfo.GetAppThumbnailLen(); + if (!reply.WriteInt32(authParam.direction) || !reply.WriteInt32(authParam.authType) || + !reply.WriteString(authParam.packageName) || !reply.WriteString(authParam.appName) || + !reply.WriteString(authParam.appDescription) || !reply.WriteInt32(authParam.business) || + !reply.WriteInt32(authParam.pincode) || !reply.WriteInt32(appIconLen) || + !reply.WriteInt32(appThumbnailLen)) { + DMLOG(DM_LOG_ERROR, "write reply failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + + if (appIconLen > 0 && authParam.imageinfo.GetAppIcon() != nullptr) { + if (!reply.WriteRawData(authParam.imageinfo.GetAppIcon(), appIconLen)){ + DMLOG(DM_LOG_ERROR, "write appIcon failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + } + + if (appThumbnailLen > 0 && authParam.imageinfo.GetAppThumbnail() != nullptr) { + if (!reply.WriteRawData(authParam.imageinfo.GetAppThumbnail(), appThumbnailLen)) { + DMLOG(DM_LOG_ERROR, "write appThumbnail failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + } + + return DEVICEMANAGER_OK; +} + +ON_IPC_CMD(SERVER_USER_AUTHORIZATION_OPERATION, MessageParcel &data, MessageParcel &reply) +{ + std::string packageName = data.ReadString(); + int32_t action = data.ReadInt32(); + int result = IpcServerAdapter::GetInstance().SetUserOperation(packageName, action); + + if (!reply.WriteInt32(action)) { + DMLOG(DM_LOG_ERROR, "write result failed"); + return DEVICEMANAGER_WRITE_FAILED; + } + return result; + +} +ON_IPC_SET_REQUEST(SERVER_DEVICEMANAGER_FA_NOTIFY, std::shared_ptr pBaseReq, MessageParcel& data) +{ + DMLOG(DM_LOG_INFO, "OnFaCallBack"); + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string packagname = pReq->GetPkgName(); + std::string paramJson = pReq->GetJsonParam(); + if (!data.WriteString(packagname)) { + DMLOG(DM_LOG_ERROR, "write pkgName failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + if (!data.WriteString(paramJson)) + { + DMLOG(DM_LOG_ERROR, "write paramJson failed"); + return DEVICEMANAGER_FLATTEN_OBJECT; + } + return DEVICEMANAGER_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DEVICEMANAGER_FA_NOTIFY, MessageParcel& reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/standard/ipc_server_client_proxy.cpp b/services/devicemanagerservice/src/ipc/standard/ipc_server_client_proxy.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6dc1a24c1a77d0a1799f0e00144a46f167aa756d --- /dev/null +++ b/services/devicemanagerservice/src/ipc/standard/ipc_server_client_proxy.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_client_proxy.h" + +#include "ipc_types.h" + +#include "ipc_cmd_register.h" +#include "ipc_def.h" +#include "device_manager_log.h" +#include "device_manager_errno.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcServerClientProxy::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + sptr remote = Remote(); + if (remote == nullptr) { + DMLOG(DM_LOG_ERROR, "remote service null"); + return DEVICEMANAGER_NULLPTR; + } + + MessageParcel data; + MessageParcel reply; + MessageOption option; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data) != DEVICEMANAGER_OK) { + return DEVICEMANAGER_FAILED; + } + if (remote->SendRequest(cmdCode, data, reply, option) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "SendRequest fail, cmd:%d", cmdCode); + return DEVICEMANAGER_IPC_FAILED; + } + return IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp b/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e08eaeab59977d4ef3f62d54608e448d65faa969 --- /dev/null +++ b/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_listener.h" +#include "ipc_server_stub.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcServerListener::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + std::string pkgName = req->GetPkgName(); + sptr listener = IpcServerStub::GetInstance().GetDmListener(pkgName); + if (listener == nullptr) { + DMLOG(DM_LOG_INFO, "cannot get listener for package:%s.", pkgName.c_str()); + return DEVICEMANAGER_NULLPTR; + } + return listener->SendCmd(cmdCode, req, rsp); +} + +int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + std::map> listeners = IpcServerStub::GetInstance().GetDmListener(); + for (auto iter : listeners) { + auto pkgName = iter.first; + auto remote = iter.second; + req->SetPkgName(pkgName); + sptr listener = iface_cast(remote); + listener->SendCmd(cmdCode, req, rsp); + } + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/standard/ipc_server_stub.cpp b/services/devicemanagerservice/src/ipc/standard/ipc_server_stub.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c259394f5a0bf9cb4e7d794b09482761d588a12c --- /dev/null +++ b/services/devicemanagerservice/src/ipc/standard/ipc_server_stub.cpp @@ -0,0 +1,197 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_server_stub.h" + +#include +#include + +#include "if_system_ability_manager.h" +#include "ipc_skeleton.h" +#include "ipc_types.h" +#include "iservice_registry.h" +#include "string_ex.h" +#include "system_ability_definition.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +#include "ipc_server_adapter.h" +#include "ipc_cmd_register.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcServerStub); + +const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(&IpcServerStub::GetInstance()); + +IpcServerStub::IpcServerStub() : SystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, true) +{ + registerToService_ = false; + state_ = ServiceRunningState::STATE_NOT_START; +} + +void IpcServerStub::OnStart() +{ + DMLOG(DM_LOG_INFO, "IpcServerStub::OnStart start"); + if (state_ == ServiceRunningState::STATE_RUNNING) { + DMLOG(DM_LOG_DEBUG, "IpcServerStub has already started."); + return; + } + if (!Init()) { + DMLOG(DM_LOG_ERROR, "failed to init IpcServerStub"); + return; + } + state_ = ServiceRunningState::STATE_RUNNING; +} + +bool IpcServerStub::Init() +{ + DMLOG(DM_LOG_INFO, "IpcServerStub::Init ready to init."); + if (!registerToService_) { + bool ret = Publish(this); + if (!ret) { + DMLOG(DM_LOG_ERROR, "IpcServerStub::Init Publish failed!"); + return false; + } + registerToService_ = true; + } + + std::thread {[] { + IpcServerAdapter::GetInstance().ModuleInit(); + }}.detach(); + return true; +} + +void IpcServerStub::OnStop() +{ + DMLOG(DM_LOG_INFO, "IpcServerStub::OnStop ready to stop service."); + state_ = ServiceRunningState::STATE_NOT_START; + registerToService_ = false; +} + +int32_t IpcServerStub::OnRemoteRequest(uint32_t code, + MessageParcel &data, MessageParcel &reply, MessageOption &option) +{ + DMLOG(DM_LOG_INFO, "code = %d, flags= %d.", code, option.GetFlags()); + int32_t ret = DEVICEMANAGER_OK; + ret = IpcCmdRegister::GetInstance().OnIpcCmd(code, data, reply); + if (ret == DEVICEMANAGER_IPC_NOT_REGISTER_FUNC) { + DMLOG(DM_LOG_WARN, "unsupport code: %d", code); + return IPCObjectStub::OnRemoteRequest(code, data, reply, option); + } + return ret; +} + +int32_t IpcServerStub::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + return DEVICEMANAGER_OK; +} + +ServiceRunningState IpcServerStub::QueryServiceState() const +{ + return state_; +} + +int32_t IpcServerStub::RegisterDeviceManagerListener(std::string &pkgName, sptr listener) +{ + if (pkgName.empty() || listener == nullptr) { + DMLOG(DM_LOG_ERROR, "Error: parameter invalid"); + return DEVICEMANAGER_NULLPTR; + } + + DMLOG(DM_LOG_INFO, "In, pkgName: %s", pkgName.c_str()); + std::lock_guard autoLock(listenerLock_); + auto iter = dmListener_.find(pkgName); + if (iter != dmListener_.end()) { + DMLOG(DM_LOG_INFO, "RegisterDeviceManagerListener: listener already exists"); + return DEVICEMANAGER_OK; + } + + sptr appRecipient = sptr(new AppDeathRecipient()); + if (!listener->AddDeathRecipient(appRecipient)) { + DMLOG(DM_LOG_ERROR, "RegisterDeviceManagerListener: AddDeathRecipient Failed"); + } + dmListener_[pkgName] = listener; + appRecipient_[pkgName] = appRecipient; + return DEVICEMANAGER_OK; +} + +int32_t IpcServerStub::UnRegisterDeviceManagerListener(std::string &pkgName) +{ + if (pkgName.empty()) { + DMLOG(DM_LOG_ERROR, "Error: parameter invalid"); + return DEVICEMANAGER_NULLPTR; + } + + DMLOG(DM_LOG_INFO, "In, pkgName: %s", pkgName.c_str()); + std::lock_guard autoLock(listenerLock_); + auto listenerIter = dmListener_.find(pkgName); + if (listenerIter == dmListener_.end()) { + DMLOG(DM_LOG_INFO, "UnRegisterDeviceManagerListener: listener not exists"); + return DEVICEMANAGER_OK; + } + + auto recipientIter = appRecipient_.find(pkgName); + if (recipientIter == appRecipient_.end()) { + DMLOG(DM_LOG_INFO, "UnRegisterDeviceManagerListener: appRecipient not exists"); + dmListener_.erase(pkgName); + return DEVICEMANAGER_OK; + } + + auto listener = listenerIter->second; + auto appRecipient = recipientIter->second; + listener->RemoveDeathRecipient(appRecipient); + appRecipient_.erase(pkgName); + dmListener_.erase(pkgName); + return DEVICEMANAGER_OK; +} + +const std::map> &IpcServerStub::GetDmListener() +{ + return dmListener_; +} + +const sptr IpcServerStub::GetDmListener(std::string pkgName) const +{ + auto iter = dmListener_.find(pkgName); + if (iter == dmListener_.end()) { + return nullptr; + } + auto remote = iter->second; + sptr dmListener = iface_cast(remote); + return dmListener; +} + +void AppDeathRecipient::OnRemoteDied(const wptr &remote) +{ + DMLOG(DM_LOG_WARN, "AppDeathRecipient: OnRemoteDied"); + std::map> listeners = IpcServerStub::GetInstance().GetDmListener(); + std::string pkgName; + for (auto iter : listeners) { + if (iter.second == remote.promote()) { + pkgName = iter.first; + break; + } + } + if (pkgName.empty()) { + DMLOG(DM_LOG_ERROR, "AppDeathRecipient: OnRemoteDied, no pkgName matched"); + return; + } + DMLOG(DM_LOG_INFO, "AppDeathRecipient: OnRemoteDied for %s", pkgName.c_str()); + IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/softbus/softbus_adapter.cpp b/services/devicemanagerservice/src/softbus/softbus_adapter.cpp deleted file mode 100644 index 17f72e881e8b197dd00c3dade2e07a4048ff6f03..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/softbus/softbus_adapter.cpp +++ /dev/null @@ -1,524 +0,0 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "softbus_adapter.h" - -#include -#include -#include -#include - -#include - -#include "dm_device_info.h" - -#include "anonymous_string.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" -#include "device_manager_service.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { -const std::string DEVICE_MANAGER_PACKAGE_NAME = "ohos.distributedhardware.devicemanager"; -const int32_t CHECK_INTERVAL = 100000; // 100ms -const int32_t SUBSCRIBE_ID_PREFIX_LEN = 16; -const int32_t SUBSCRIBE_ID_MASK = 0x0000FFFF; -const int32_t DISCOVER_DEVICEINFO_MAX_SIZE = 20; -} - -IMPLEMENT_SINGLE_INSTANCE(SoftbusAdapter); -void SoftbusAdapter::OnSoftBusDeviceOnline(NodeBasicInfo *info) -{ - if (info == nullptr) { - HILOGE("SoftbusAdapter::OnSoftBusDeviceOnline NodeBasicInfo is nullptr"); - return; - } - - std::string networkId = info->networkId; - HILOGI("device online, networkId: %{public}s", GetAnonyString(networkId).c_str()); - OnSoftBusDeviceStateChange(DmDeviceState::DEVICE_STATE_ONLINE, info); - - uint8_t udid[UDID_BUF_LEN] = {0}; - int32_t ret = GetNodeKeyInfo(DEVICE_MANAGER_PACKAGE_NAME.c_str(), info->networkId, - NodeDeivceInfoKey::NODE_KEY_UDID, udid, sizeof(udid)); - if (ret != ERR_OK) { - HILOGE("GetNodeKeyInfo failed"); - return; - } - std::string deviceId = (char *)udid; - SoftbusAdapter::GetInstance().RemoveDiscoverDeviceInfo(deviceId); -} - -void SoftbusAdapter::OnSoftbusDeviceOffline(NodeBasicInfo *info) -{ - if (info == nullptr) { - HILOGE("SoftbusAdapter::OnSoftbusDeviceOffline NodeBasicInfo is nullptr"); - return; - } - - std::string networkId = info->networkId; - HILOGI("device offline, networkId: %{public}s", GetAnonyString(networkId).c_str()); - OnSoftBusDeviceStateChange(DmDeviceState::DEVICE_STATE_OFFLINE, info); -} - -void SoftbusAdapter::OnSoftBusDeviceStateChange(DmDeviceState state, NodeBasicInfo *info) -{ - DmDeviceInfo deviceInfo; - deviceInfo.deviceId = info->networkId; - deviceInfo.deviceName = info->deviceName; - deviceInfo.deviceTypeId = (DMDeviceType)info->deviceTypeId; - - std::map> listeners = DeviceManagerService::GetInstance().GetDmListener(); - for (auto iter : listeners) { - auto packageName = iter.first; - auto remote = iter.second; - sptr dmListener = iface_cast(remote); - if (state == DmDeviceState::DEVICE_STATE_ONLINE) { - HILOGI("SoftbusAdapter::OnSoftBusDeviceStateChange listenr handle device online."); - dmListener->OnDeviceOnline(packageName, deviceInfo); - } else { - HILOGI("SoftbusAdapter::OnSoftBusDeviceStateChange listenr handle device offline."); - dmListener->OnDeviceOffline(packageName, deviceInfo); - } - } -} - -void SoftbusAdapter::OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info) -{ - HILOGI("SoftbusAdapter::OnSoftbusDeviceInfoChanged."); - // currently do nothing - (void)type; - (void)info; -} - -void SoftbusAdapter::OnSoftbusDeviceFound(const DeviceInfo *device) -{ - if (device == nullptr) { - HILOGE("deviceinfo is null"); - return; - } - - std::string deviceId = device->devId; - HILOGI("SoftbusAdapter::OnSoftbusDeviceFound device %{public}s found.", GetAnonyString(deviceId).c_str()); - if (IsDeviceOnLine(deviceId)) { - return; - } - - SoftbusAdapter::GetInstance().SaveDiscoverDeviceInfo(device); - DmDeviceInfo deviceInfo; - deviceInfo.deviceId = deviceId; - deviceInfo.deviceName = device->devName; - deviceInfo.deviceTypeId = (DMDeviceType)device->devType; - - // currently, only care ddmpCapability - if (!((device->capabilityBitmap[0] >> DDMP_CAPABILITY_BITMAP) & 0x1)) { - HILOGE("capBitmap Invalid, not contain ddmpCap"); - return; - } - - auto subscribeInfos = SoftbusAdapter::GetInstance().GetsubscribeInfos(); - for (auto iter = subscribeInfos.begin(); iter != subscribeInfos.end(); iter++) { - auto subInfovector = iter->second; - for (auto vectorIter = subInfovector.begin(); vectorIter != subInfovector.end(); ++vectorIter) { - auto info = vectorIter->get(); - HILOGI("subscribe info capability:%{public}s.", info->info.capability); - if (strcmp(DM_CAPABILITY_DDMP.c_str(), info->info.capability) != 0) { - HILOGE("subscribe info capability invalid."); - } - std::string packageName = iter->first; - sptr listener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (listener == nullptr) { - HILOGI("cannot get listener for package:%{public}s.", packageName.c_str()); - continue; - } - - uint16_t originId = (uint16_t)(((uint32_t)info->info.subscribeId) & SUBSCRIBE_ID_MASK); - HILOGI("call OnDeviceFound for %{public}s, originId %{public}d, deviceId %{public}s", - packageName.c_str(), originId, GetAnonyString(deviceInfo.deviceId).c_str()); - listener->OnDeviceFound(packageName, originId, deviceInfo); - } - } -} - -void SoftbusAdapter::OnSoftbusDiscoverFailed(int subscribeId, DiscoveryFailReason failReason) -{ - HILOGI("In, subscribeId %{public}d, failReason %{public}d", subscribeId, (int32_t)failReason); - std::string packageName; - if (!SoftbusAdapter::GetInstance().GetPackageNameBySubscribeId(subscribeId, packageName)) { - HILOGE("OnSoftbusDiscoverFailed: packageName not found"); - return; - } - sptr listener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (listener == nullptr) { - HILOGE("OnSoftbusDiscoverFailed: listener not found for packageName %{public}s", packageName.c_str()); - return; - } - uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); - listener->OnDiscoverFailed(packageName, originId, (int32_t)failReason); -} - -void SoftbusAdapter::OnSoftbusDiscoverySuccess(int subscribeId) -{ - HILOGI("In, subscribeId %{public}d", subscribeId); - std::string packageName; - if (!SoftbusAdapter::GetInstance().GetPackageNameBySubscribeId(subscribeId, packageName)) { - HILOGE("OnSoftbusDiscoverySuccess: packageName not found"); - return; - } - sptr listener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (listener == nullptr) { - HILOGE("OnSoftbusDiscoverySuccess: listener not found for packageName %{public}s", packageName.c_str()); - return; - } - uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); - listener->OnDiscoverySuccess(packageName, originId); -} - -void SoftbusAdapter::OnSoftbusJoinLNNResult(ConnectionAddr *addr, const char *networkId, int32_t retCode) -{ - (void)addr; - if (retCode != 0) { - HILOGE("OnSoftbusJoinLNNResult: failed, retCode %{public}d", retCode); - return; - } - - if (networkId == nullptr) { - HILOGE("OnSoftbusJoinLNNResult: success, but networkId is nullptr"); - return; - } - - std::string netIdStr = networkId; - HILOGI("OnSoftbusJoinLNNResult: success, networkId %{public}s, retCode %{public}d", - GetAnonyString(netIdStr).c_str(), retCode); -} - -void SoftbusAdapter::OnSoftbusLeaveLNNResult(const char *networkId, int32_t retCode) -{ - if (retCode != 0) { - HILOGE("OnSoftbusLeaveLNNResult: failed, retCode %{public}d", retCode); - return; - } - - if (networkId == nullptr) { - HILOGE("OnSoftbusLeaveLNNResult: success, but networkId is nullptr"); - return; - } - - std::string netIdStr = networkId; - HILOGI("OnSoftbusLeaveLNNResult: success, networkId %{public}s, retCode %{public}d", - GetAnonyString(netIdStr).c_str(), retCode); -} - -int32_t SoftbusAdapter::GetSoftbusTrustDevices(const std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - // extra not used yet - (void) packageName; - (void) extra; - - HILOGI("GetSoftbusTrustDevices start, packageName: %{public}s", packageName.c_str()); - NodeBasicInfo *info = nullptr; - int32_t infoNum = 0; - int32_t ret = GetAllNodeDeviceInfo(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &info, &infoNum); - if (ret != 0) { - HILOGE("GetAllNodeDeviceInfo failed with ret %{public}d", ret); - return ret; - } - - for (int32_t i = 0; i < infoNum; i++) { - NodeBasicInfo *nodeBasicInfo = info + i; - if (nodeBasicInfo == nullptr) { - HILOGE("nodeBasicInfo is empty for index %{public}d, infoNum %{public}d.", i, infoNum); - continue; - } - DmDeviceInfo deviceInfo; - deviceInfo.deviceId = nodeBasicInfo->networkId; - deviceInfo.deviceName = nodeBasicInfo->deviceName; - deviceInfo.deviceTypeId = (DMDeviceType)nodeBasicInfo->deviceTypeId; - deviceList.push_back(deviceInfo); - } - FreeNodeInfo(info); - HILOGI("success, packageName: %{public}s, deviceCount %{public}d", packageName.c_str(), deviceList.size()); - return ERR_OK; -} - -bool SoftbusAdapter::IsDeviceOnLine(std::string &deviceId) -{ - std::vector deviceList; - std::string extra = ""; - if (GetSoftbusTrustDevices(DEVICE_MANAGER_PACKAGE_NAME, extra, deviceList) != ERR_OK) { - HILOGE("SoftbusAdapter::IsDeviceOnLine GetSoftbusTrustDevices failed"); - return false; - } - - for (auto iter = deviceList.begin(); iter != deviceList.end(); ++iter) { - std::string& networkId = iter->deviceId; - if (networkId == deviceId) { - HILOGI("SoftbusAdapter::IsDeviceOnLine devccie %{public}s online", GetAnonyString(deviceId).c_str()); - return true; - } - - uint8_t udid[UDID_BUF_LEN] = {0}; - int32_t ret = GetNodeKeyInfo(DEVICE_MANAGER_PACKAGE_NAME.c_str(), networkId.c_str(), - NodeDeivceInfoKey::NODE_KEY_UDID, udid, sizeof(udid)); - if (ret != ERR_OK) { - HILOGE("SoftbusAdapter::IsDeviceOnLine GetNodeKeyInfo failed"); - return false; - } - - if (strcmp((char *)udid, deviceId.c_str()) == 0) { - HILOGI("SoftbusAdapter::IsDeviceOnLine devccie %{public}s online", GetAnonyString(deviceId).c_str()); - return true; - } - } - return false; -} - -void SoftbusAdapter::RegSoftBusDeviceStateListener() -{ - int32_t ret; - int32_t retryTimes = 0; - do { - ret = RegNodeDeviceStateCb(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &softbusNodeStateCb); - if (ret != ERR_OK) { - ++retryTimes; - HILOGE("RegNodeDeviceStateCb failed with ret %{public}d, retryTimes %{public}d", ret, retryTimes); - usleep(CHECK_INTERVAL); - } - } while (ret != ERR_OK); - HILOGI("RegNodeDeviceStateCb success."); -} - -int32_t SoftbusAdapter::StartSoftbusDiscovery(std::string &packageName, DmSubscribeInfo &info) -{ - std::shared_ptr subinfo = nullptr; - if (subscribeInfos_.find(packageName) == subscribeInfos_.end()) { - subscribeInfos_[packageName] = {}; - } - - auto iter = subscribeInfos_.find(packageName); - std::vector> &subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - for (; vectorIter != subinfoVector.end(); ++vectorIter) { - if (vectorIter->get()->subscribeIdOrigin == info.subscribeId) { - subinfo = *vectorIter; - break; - } - } - - if (subinfo == nullptr) { - subinfo = std::make_shared(); - subinfo->subscribeIdOrigin = info.subscribeId; - subinfo->subscribeIdPrefix = subscribeIdPrefix++; - subinfo->info.subscribeId = (subinfo->subscribeIdPrefix << SUBSCRIBE_ID_PREFIX_LEN) | info.subscribeId; - subinfo->info.mode = (DiscoverMode)info.mode; - subinfo->info.medium = (ExchanageMedium)info.medium; - subinfo->info.freq = (ExchangeFreq)info.freq; - subinfo->info.isSameAccount = info.isSameAccount; - subinfo->info.isWakeRemote = info.isWakeRemote; - subinfo->info.capability = info.capability.c_str(); - subinfo->info.capabilityData = nullptr; - subinfo->info.dataLen = 0; - } - - if (vectorIter == subinfoVector.end()) { - subinfoVector.push_back(subinfo); - } - - HILOGI("StartDiscovery, packageName: %{public}s, subscribeId %{public}d, prefix %{public}d, origin %{public}d", - packageName.c_str(), subinfo->info.subscribeId, subinfo->subscribeIdPrefix, subinfo->subscribeIdOrigin); - int ret = StartDiscovery(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &subinfo->info, &softbusDiscoverCallback); - if (ret != ERR_OK) { - HILOGE("StartDiscovery failed with ret %{public}d.", ret); - } - return ret; -} - -bool SoftbusAdapter::GetPackageNameBySubscribeId(int32_t adapterId, std::string &packageName) -{ - for (auto iter = subscribeInfos_.begin(); iter != subscribeInfos_.end(); ++iter) { - std::vector> &subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - for (; vectorIter != subinfoVector.end(); ++vectorIter) { - if (vectorIter->get()->info.subscribeId == adapterId) { - packageName = iter->first; - return true; - } - } - } - return false; -} - -bool SoftbusAdapter::GetsubscribeIdAdapter(std::string packageName, int16_t originId, int32_t &adapterId) -{ - HILOGI("GetsubscribeIdAdapter in, packageName: %{public}s, originId:%{public}d", packageName.c_str(), - (int32_t)originId); - auto iter = subscribeInfos_.find(packageName); - if (iter == subscribeInfos_.end()) { - HILOGE("subscribeInfo not find for packageName: %{public}s", packageName.c_str()); - return false; - } - - std::vector> &subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - for (; vectorIter != subinfoVector.end(); ++vectorIter) { - if (vectorIter->get()->subscribeIdOrigin == originId) { - HILOGE("find adapterId:%{public}d for packageName: %{public}s, originId:%{public}d", - vectorIter->get()->info.subscribeId, packageName.c_str(), (int32_t)originId); - adapterId = vectorIter->get()->info.subscribeId; - return true; - } - } - HILOGE("subscribe not find. packageName: %{public}s, originId:%{public}d", packageName.c_str(), (int32_t)originId); - return false; -} - -int32_t SoftbusAdapter::StopSoftbusDiscovery(std::string &packageName, uint16_t subscribeId) -{ - int32_t subscribeIdAdapter = -1; - if (!GetsubscribeIdAdapter(packageName, subscribeId, subscribeIdAdapter)) { - HILOGE("StopDiscovery failed, subscribeId not match"); - return ERR_INVALID_OPERATION; - } - - HILOGI("StopDiscovery begin, packageName: %{public}s, subscribeId:%{public}d, subscribeIdAdapter:%{public}d", - packageName.c_str(), (int32_t)subscribeId, subscribeIdAdapter); - int ret = StopDiscovery(DEVICE_MANAGER_PACKAGE_NAME.c_str(), subscribeIdAdapter); - if (ret != ERR_OK) { - HILOGE("StopDiscovery failed with ret %{public}d", ret); - return ret; - } - - auto iter = subscribeInfos_.find(packageName); - auto subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - while (vectorIter != subinfoVector.end()) { - if (vectorIter->get()->subscribeIdOrigin == subscribeId) { - vectorIter = subinfoVector.erase(vectorIter); - break; - } else { - ++vectorIter; - } - } - if (subinfoVector.empty()) { - subscribeInfos_.erase(packageName); - } - HILOGI("SoftbusAdapter::StopSoftbusDiscovery completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t SoftbusAdapter::SoftbusJoinLnn(std::string devId) -{ - auto iter = discoverDeviceInfoMap_.find(devId); - if (iter == discoverDeviceInfoMap_.end()) { - HILOGE("SoftbusAdapter::SoftbusJoinLnn deviceInfo not found: %{public}s", GetAnonyString(devId).c_str()); - return ERR_INVALID_OPERATION; - } - - DeviceInfo *deviceInfo = iter->second.get(); - if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { - HILOGE("deviceInfo addrNum not valid, addrNum %{public}d", deviceInfo->addrNum); - return ERR_DEVICEMANAGER_OPERATION_FAILED; - } - - for (unsigned int i = 0; i < deviceInfo->addrNum; i++) { - // currently, only support CONNECT_ADDR_WLAN - if (deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_WLAN && - deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_ETH) { - continue; - } - - HILOGI("SoftbusAdapter::SoftbusJoinLnn call softbus JoinLNN."); - return JoinLNN(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &deviceInfo->addr[i], OnSoftbusJoinLNNResult); - } - - return ERR_DEVICEMANAGER_OPERATION_FAILED; -} - -int32_t SoftbusAdapter::SoftbusLeaveLnn(std::string networkId) -{ - return LeaveLNN(networkId.c_str(), OnSoftbusLeaveLNNResult); -} - -int32_t SoftbusAdapter::GetConnectionIpAddr(std::string deviceId, std::string &ipAddr) -{ - auto iter = discoverDeviceInfoMap_.find(deviceId); - if (iter == discoverDeviceInfoMap_.end()) { - HILOGE("deviceInfo not found by deviceId %{public}s", GetAnonyString(deviceId).c_str()); - return ERR_INVALID_OPERATION; - } - - DeviceInfo *deviceInfo = iter->second.get(); - if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { - HILOGE("deviceInfo addrNum not valid, addrNum %{public}d", deviceInfo->addrNum); - return ERR_DEVICEMANAGER_OPERATION_FAILED; - } - - for (unsigned int i = 0; i < deviceInfo->addrNum; ++i) { - // currently, only support CONNECT_ADDR_WLAN - if (deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_WLAN && - deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_ETH) { - continue; - } - ipAddr = deviceInfo->addr[i].info.ip.ip; - HILOGI("SoftbusAdapter::GetConnectionIpAddr get ip ok."); - return ERR_OK; - } - HILOGE("failed to get ipAddr for deviceId %{public}s", GetAnonyString(deviceId).c_str()); - return ERR_DEVICEMANAGER_OPERATION_FAILED; -} - -const std::map>>& SoftbusAdapter::GetsubscribeInfos() -{ - return subscribeInfos_; -} - -void SoftbusAdapter::SaveDiscoverDeviceInfo(const DeviceInfo *deviceInfo) -{ - std::shared_ptr info = std::make_shared(); - DeviceInfo *infoPtr = info.get(); - if (memcpy_s(infoPtr, sizeof(DeviceInfo), deviceInfo, sizeof(DeviceInfo)) != 0) { - HILOGE("SoftbusAdapter::SaveDiscoverDeviceInfo failed."); - return; - } - - std::string deviceId = deviceInfo->devId; - discoverDeviceInfoMap_[deviceId] = info; - discoverDeviceInfoVector_.push_back(info); - - // Remove the earliest element when reached the max size - if (discoverDeviceInfoVector_.size() == DISCOVER_DEVICEINFO_MAX_SIZE) { - auto iter = discoverDeviceInfoVector_.begin(); - std::string delDevId = iter->get()->devId; - discoverDeviceInfoMap_.erase(delDevId); - discoverDeviceInfoVector_.erase(iter); - } -} - -void SoftbusAdapter::RemoveDiscoverDeviceInfo(const std::string deviceId) -{ - discoverDeviceInfoMap_.erase(deviceId); - auto iter = discoverDeviceInfoVector_.begin(); - while (iter != discoverDeviceInfoVector_.end()) { - if (strcmp(iter->get()->devId, deviceId.c_str()) == 0) { - iter = discoverDeviceInfoVector_.erase(iter); - } else { - ++iter; - } - } -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/include/util/anonymous_string.h b/utils/include/anonymous_string.h similarity index 97% rename from services/devicemanagerservice/include/util/anonymous_string.h rename to utils/include/anonymous_string.h index dd58b7384e585b4ec46c3ed93eefb7fb9a70474a..4144e517c2700242a3f6168ac1eb807a98208563 100644 --- a/services/devicemanagerservice/include/util/anonymous_string.h +++ b/utils/include/anonymous_string.h @@ -1,26 +1,26 @@ -/* - * Copyright (c) 2021 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 ANONYMOUS_STRING_H -#define ANONYMOUS_STRING_H -#include - -namespace OHOS { -namespace DistributedHardware { -std::string GetAnonyString(const std::string &value); -std::string GetAnonyInt32(const int32_t value); -} -} +/* + * Copyright (c) 2021 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 ANONYMOUS_STRING_H +#define ANONYMOUS_STRING_H +#include + +namespace OHOS { +namespace DistributedHardware { +std::string GetAnonyString(const std::string &value); +std::string GetAnonyInt32(const int32_t value); +} +} #endif \ No newline at end of file diff --git a/utils/include/cipher/encrypt_utils.h b/utils/include/cipher/encrypt_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..db19b2364713391934bd468802c90c03659bdd11 --- /dev/null +++ b/utils/include/cipher/encrypt_utils.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_ENCRYPT_UTILS_H +#define OHOS_DEVICE_MANAGER_ENCRYPT_UTILS_H + +#include +#include + +namespace OHOS { +namespace DistributedHardware { +class EncryptUtils { +public: + static int32_t MbedtlsBase64Encode(uint8_t *dst, size_t dlen, size_t *olen, + const uint8_t *src, size_t slen); + static int32_t MbedtlsBase64Decode(uint8_t *dst, size_t dlen, size_t *olen, + const uint8_t *src, size_t slen); + static int32_t GenRandInt(int32_t randMin, int32_t randMax); + static int64_t GenRandLongLong(int64_t randMin, int64_t randMax); + static int32_t GetRandomData(uint8_t *randStr, uint32_t len); + static int32_t MbedtlsEncrypt(const uint8_t *plainText, int32_t plainTextLen, uint8_t *cipherText, + int32_t cipherTextLen, int32_t *outLen); + static int32_t MbedtlsDecrypt(const uint8_t *cipherText, int32_t cipherTextLen, uint8_t *plainText, + int32_t plainTextLen, int32_t *outLen); + /** + * szOut最后一位为结束符，比如 szOutLen=4 可能返回 "abc" + * @param szOutLen 至少2 + * @param numberOnly 是否只生成数据 如果为true 则期望返回随机数字 如果为否，则期望返回随机字符 + */ + static bool MbedtlsGenRandomStr(char *szOut, int32_t szOutLen, bool numberOnly); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_ENCRYPT_UTILS_H \ No newline at end of file diff --git a/utils/include/ipc/lite/ipc_cmd_register.h b/utils/include/ipc/lite/ipc_cmd_register.h new file mode 100644 index 0000000000000000000000000000000000000000..6b52515aa332d2e63c2a66fe1f071b3cfd58a902 --- /dev/null +++ b/utils/include/ipc/lite/ipc_cmd_register.h @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H +#define OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H + +#include +#include + +#include "liteipc_adapter.h" +#include "single_instance.h" + +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +#define ON_IPC_SET_REQUEST(cmdCode, paraA, paraB, paraC, paraD) \ + static int32_t IpcSetRequest##cmdCode(paraA, paraB, paraC, paraD); \ + struct IpcRegisterSetRequestFunc##cmdCode { \ + IpcRegisterSetRequestFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterSetRequestFunc(cmdCode, IpcSetRequest##cmdCode); \ + } \ + }; \ + IpcRegisterSetRequestFunc##cmdCode g_IpcRegisterSetRequestFunc##cmdCode; \ + static int32_t IpcSetRequest##cmdCode(paraA, paraB, paraC, paraD) \ + +#define ON_IPC_READ_RESPONSE(cmdCode, paraA, paraB) \ + static int32_t IpcReadResponse##cmdCode(paraA, paraB); \ + struct IpcRegisterReadResponseFunc##cmdCode { \ + IpcRegisterReadResponseFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterReadResponseFunc(cmdCode, IpcReadResponse##cmdCode); \ + } \ + }; \ + IpcRegisterReadResponseFunc##cmdCode g_IpcRegisterReadResponseFunc##cmdCode; \ + static int32_t IpcReadResponse##cmdCode(paraA, paraB) \ + +#define ON_IPC_CMD(cmdCode, paraA, paraB, paraC) \ + static void IpcCmdProcess##cmdCode(paraA, paraB, paraC); \ + struct IpcRegisterCmdProcessFunc##cmdCode { \ + IpcRegisterCmdProcessFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterCmdProcessFunc(cmdCode, IpcCmdProcess##cmdCode); \ + } \ + }; \ + IpcRegisterCmdProcessFunc##cmdCode g_IpcRegisterCmdProcessFunc##cmdCode; \ + static void IpcCmdProcess##cmdCode(paraA, paraB, paraC) \ + +#define ON_IPC_SERVER_CMD(cmdCode, paraA, paraB) \ + static void IpcServerCmdProcess##cmdCode(paraA, paraB); \ + class IpcRegisterServerCmdProcessFunc##cmdCode { \ + public: \ + IpcRegisterServerCmdProcessFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterServerCmdProcessFunc(cmdCode, IpcServerCmdProcess##cmdCode); \ + } \ + }; \ + IpcRegisterServerCmdProcessFunc##cmdCode g_IpcRegisterServerCmdProcessFunc##cmdCode; \ + static void IpcServerCmdProcess##cmdCode(paraA, paraB) + +using SetIpcRequestFunc = int32_t (*)(std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t bufferLen); +using ReadResponseFunc = int32_t (*)(IpcIo &reply, std::shared_ptr pBaseRsp); +using OnIpcCmdFunc = void (*)(IpcIo &reply, const IpcContext &ctx, void *ipcMsg); +using OnIpcServerCmdFunc = void (*)(IpcIo &req, IpcIo &reply); + +class IpcCmdRegister { +DECLARE_SINGLE_INSTANCE(IpcCmdRegister); +public: + void RegisterSetRequestFunc(int32_t cmdCode, SetIpcRequestFunc setIpcRequestFunc) + { + setIpcRequestFuncMap_.emplace(cmdCode, setIpcRequestFunc); + }; + void RegisterReadResponseFunc(int32_t cmdCode, ReadResponseFunc readResponseFunc) + { + readResponseFuncMap_.emplace(cmdCode, readResponseFunc); + }; + void RegisterCmdProcessFunc(int32_t cmdCode, OnIpcCmdFunc onIpcCmdFunc) + { + onIpcCmdFuncMap_.emplace(cmdCode, onIpcCmdFunc); + }; + void RegisterServerCmdProcessFunc(int32_t cmdCode, OnIpcServerCmdFunc onIpcServerCmdFunc) + { + onIpcServerCmdFuncMap_.emplace(cmdCode, onIpcServerCmdFunc); + }; + int32_t SetRequest(int32_t cmdCode, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen); + int32_t ReadResponse(int32_t cmdCode, IpcIo &reply, std::shared_ptr pBaseRsp); + int32_t OnIpcCmd(int32_t cmdCode, IpcIo &reply, const IpcContext &ctx, void *ipcMsg); + int32_t OnIpcServerCmd(int32_t cmdCode, IpcIo &req, IpcIo &reply); +private: + std::unordered_map setIpcRequestFuncMap_; + std::unordered_map readResponseFuncMap_; + std::unordered_map onIpcCmdFuncMap_; + std::unordered_map onIpcServerCmdFuncMap_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H \ No newline at end of file diff --git a/utils/include/ipc/standard/ipc_cmd_register.h b/utils/include/ipc/standard/ipc_cmd_register.h new file mode 100644 index 0000000000000000000000000000000000000000..dc852f57ed3ccada2095610cc06bfb000aa9d46e --- /dev/null +++ b/utils/include/ipc/standard/ipc_cmd_register.h @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H +#define OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H + +#include +#include + +#include "iremote_broker.h" +#include "single_instance.h" + +#include "ipc_types.h" +#include "ipc_req.h" +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +#define ON_IPC_SET_REQUEST(cmdCode, paraA, paraB) \ + static int32_t IpcSetRequest##cmdCode(paraA, paraB); \ + struct IpcRegisterSetRequestFunc##cmdCode { \ + IpcRegisterSetRequestFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterSetRequestFunc(cmdCode, IpcSetRequest##cmdCode); \ + } \ + }; \ + IpcRegisterSetRequestFunc##cmdCode g_IpcRegisterSetRequestFunc##cmdCode; \ + static int32_t IpcSetRequest##cmdCode(paraA, paraB) \ + +#define ON_IPC_READ_RESPONSE(cmdCode, paraA, paraB) \ + static int32_t IpcReadResponse##cmdCode(paraA, paraB); \ + struct IpcRegisterReadResponseFunc##cmdCode { \ + IpcRegisterReadResponseFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterReadResponseFunc(cmdCode, IpcReadResponse##cmdCode); \ + } \ + }; \ + IpcRegisterReadResponseFunc##cmdCode g_IpcRegisterReadResponseFunc##cmdCode; \ + static int32_t IpcReadResponse##cmdCode(paraA, paraB) \ + +#define ON_IPC_CMD(cmdCode, paraA, paraB) \ + static int32_t IpcCmdProcess##cmdCode(paraA, paraB); \ + struct IpcRegisterCmdProcessFunc##cmdCode { \ + IpcRegisterCmdProcessFunc##cmdCode() \ + { \ + IpcCmdRegister::GetInstance().RegisterCmdProcessFunc(cmdCode, IpcCmdProcess##cmdCode); \ + } \ + }; \ + IpcRegisterCmdProcessFunc##cmdCode g_IpcRegisterCmdProcessFunc##cmdCode; \ + static int32_t IpcCmdProcess##cmdCode(paraA, paraB) + +using SetIpcRequestFunc = int32_t (*)(std::shared_ptr pBaseReq, MessageParcel &data); +using ReadResponseFunc = int32_t (*)(MessageParcel &reply, std::shared_ptr pBaseRsp); +using OnIpcCmdFunc = int32_t (*)(MessageParcel &data, MessageParcel &reply); + +class IpcCmdRegister { +DECLARE_SINGLE_INSTANCE(IpcCmdRegister); +public: + void RegisterSetRequestFunc(int32_t cmdCode, SetIpcRequestFunc setIpcRequestFunc) + { + setIpcRequestFuncMap_.emplace(cmdCode, setIpcRequestFunc); + }; + void RegisterReadResponseFunc(int32_t cmdCode, ReadResponseFunc readResponseFunc) + { + readResponseFuncMap_.emplace(cmdCode, readResponseFunc); + }; + void RegisterCmdProcessFunc(int32_t cmdCode, OnIpcCmdFunc onIpcCmdFunc) + { + onIpcCmdFuncMap_.emplace(cmdCode, onIpcCmdFunc); + }; + int32_t SetRequest(int32_t cmdCode, std::shared_ptr pBaseReq, MessageParcel &data); + int32_t ReadResponse(int32_t cmdCode, MessageParcel &reply, std::shared_ptr pBaseRsp); + int32_t OnIpcCmd(int32_t cmdCode, MessageParcel &data, MessageParcel &reply); +private: + std::unordered_map setIpcRequestFuncMap_; + std::unordered_map readResponseFuncMap_; + std::unordered_map onIpcCmdFuncMap_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H \ No newline at end of file diff --git a/utils/include/log/dm_log.h b/utils/include/log/dm_log.h new file mode 100644 index 0000000000000000000000000000000000000000..1db27040a36fc6ec7ba8285d0550be0256432300 --- /dev/null +++ b/utils/include/log/dm_log.h @@ -0,0 +1,31 @@ +/* + * Copyright (c) 2021 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 OHOS_DM_LOG_H +#define OHOS_DM_LOG_H + +namespace OHOS { +namespace DistributedHardware { +typedef enum { + DM_LOG_DEBUG, + DM_LOG_INFO, + DM_LOG_WARN, + DM_LOG_ERROR, +} DMLogLevel; + +void DMLog(DMLogLevel logLevel, const char *fmt, ...); +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_LOG_H diff --git a/services/devicemanagerservice/src/util/anonymous_string.cpp b/utils/src/anonymous_string.cpp similarity index 95% rename from services/devicemanagerservice/src/util/anonymous_string.cpp rename to utils/src/anonymous_string.cpp index 69ed71a76e9f1167ac00b12cb7ad4216ce1c0531..c3fdd4f3ec754f6fe1286911b1f764394de1772b 100644 --- a/services/devicemanagerservice/src/util/anonymous_string.cpp +++ b/utils/src/anonymous_string.cpp @@ -1,71 +1,68 @@ -/* - * Copyright (c) 2021 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. - */ - -#include "anonymous_string.h" - -#include "securec.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - const int INT32_STRING_LENGTH = 40; - const int INT32_SHORT_ID_LENGTH = 20; - const int INT32_PLAINTEXT_LENGTH = 4; - const int INT32_MIN_ID_LENGTH = 3; -} - -std::string GetAnonyString(const std::string &value) -{ - std::string res; - std::string tmpStr("******"); - int32_t strLen = value.length(); - if (strLen < INT32_MIN_ID_LENGTH) { - return tmpStr; - } - - if (strLen <= INT32_SHORT_ID_LENGTH) { - res += value[0]; - res += tmpStr; - res += value[strLen - 1]; - } else { - res.append(value, 0, INT32_PLAINTEXT_LENGTH); - res += tmpStr; - res.append(value, strLen - INT32_PLAINTEXT_LENGTH, INT32_PLAINTEXT_LENGTH); - } - - return res; -} - -std::string GetAnonyInt32(const int32_t value) -{ - char tempBuffer[INT32_STRING_LENGTH] = ""; - int32_t secRet = sprintf_s(tempBuffer, INT32_STRING_LENGTH, "%d", value); - if (secRet <= 0) { - std::string nullString(""); - return nullString; - } - int32_t length = strlen(tempBuffer); - for (int32_t i = 1; i < length - 1; i++) { - tempBuffer[i] = '*'; - } - if (length == 0x01) { - tempBuffer[0] = '*'; - } - - std::string tempSting(tempBuffer); - return tempSting; -} -} +/* + * Copyright (c) 2021 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. + */ + +#include "anonymous_string.h" + +#include "securec.h" + +namespace OHOS { +namespace DistributedHardware { +std::string GetAnonyString(const std::string &value) +{ + const int INT32_SHORT_ID_LENGTH = 20; + const int INT32_PLAINTEXT_LENGTH = 4; + const int INT32_MIN_ID_LENGTH = 3; + std::string res; + std::string tmpStr("******"); + int32_t strLen = value.length(); + if (strLen < INT32_MIN_ID_LENGTH) { + return tmpStr; + } + + if (strLen <= INT32_SHORT_ID_LENGTH) { + res += value[0]; + res += tmpStr; + res += value[strLen - 1]; + } else { + res.append(value, 0, INT32_PLAINTEXT_LENGTH); + res += tmpStr; + res.append(value, strLen - INT32_PLAINTEXT_LENGTH, INT32_PLAINTEXT_LENGTH); + } + + return res; +} + +std::string GetAnonyInt32(const int32_t value) +{ + const int INT32_STRING_LENGTH = 40; + char tempBuffer[INT32_STRING_LENGTH] = ""; + int32_t secRet = sprintf_s(tempBuffer, INT32_STRING_LENGTH, "%d", value); + if (secRet <= 0) { + std::string nullString(""); + return nullString; + } + int32_t length = strlen(tempBuffer); + for (int32_t i = 1; i < length - 1; i++) { + tempBuffer[i] = '*'; + } + if (length == 0x01) { + tempBuffer[0] = '*'; + } + + std::string tempSting(tempBuffer); + return tempSting; +} +} } \ No newline at end of file diff --git a/utils/src/cipher/encrypt_utils.cpp b/utils/src/cipher/encrypt_utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..11797a01ec9a89a5c91bd517ab8a58781fd7f0c5 --- /dev/null +++ b/utils/src/cipher/encrypt_utils.cpp @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "encrypt_utils.h" + +#include "mbedtls/base64.h" +#include "mbedtls/gcm.h" +#include "mbedtls/md.h" + +#include "mbedtls/ctr_drbg.h" +#include "mbedtls/entropy.h" + +#include +#include +#include +#include "device_manager_errno.h" +#include "device_manager_log.h" +#include "securec.h" + +namespace OHOS { +namespace DistributedHardware { +int32_t EncryptUtils::MbedtlsBase64Encode(uint8_t *dst, size_t dlen, size_t *olen, + const uint8_t *src, size_t slen) +{ + return mbedtls_base64_encode(dst, dlen, olen, src, slen); +} + +int32_t EncryptUtils::MbedtlsBase64Decode(uint8_t *dst, size_t dlen, size_t *olen, + const uint8_t *src, size_t slen) +{ + return mbedtls_base64_decode(dst, dlen, olen, src, slen); +} + +int32_t EncryptUtils::GenRandInt(int32_t randMin, int32_t randMax) +{ + std::random_device randDevice; + std::mt19937 genRand(randDevice()); + std::uniform_int_distribution disRand(randMin, randMax); + return disRand(genRand); +} + +int64_t EncryptUtils::GenRandLongLong(int64_t randMin, int64_t randMax) +{ + std::random_device randDevice; + std::mt19937 genRand(randDevice()); + std::uniform_int_distribution disRand(randMin, randMax); + return disRand(genRand); +} + +int32_t EncryptUtils::GetRandomData(uint8_t *randStr, uint32_t len) +{ + mbedtls_entropy_context *entropy = nullptr; + mbedtls_ctr_drbg_context *ctrDrbg = nullptr; + int32_t ret = DEVICEMANAGER_FAILED; + do { + if (randStr == nullptr || len == 0) { + break; + } + entropy = (mbedtls_entropy_context *)malloc(sizeof(mbedtls_entropy_context)); + if (entropy == nullptr) { + break; + } + ctrDrbg = (mbedtls_ctr_drbg_context *)malloc(sizeof(mbedtls_ctr_drbg_context)); + if (ctrDrbg == nullptr) { + break; + } + mbedtls_ctr_drbg_init(ctrDrbg); + mbedtls_entropy_init(entropy); + ret = mbedtls_ctr_drbg_seed(ctrDrbg, mbedtls_entropy_func, entropy, nullptr, 0); + if (ret != 0) { + break; + } + ret = mbedtls_ctr_drbg_random(ctrDrbg, randStr, len); + if (ret != 0) { + break; + } + ret = DEVICEMANAGER_OK; + } while (0); + if (entropy != nullptr) { + free(entropy); + } + if (ctrDrbg != nullptr) { + free(ctrDrbg); + } + return ret; +} + +int32_t EncryptUtils::MbedtlsEncrypt(const uint8_t *plainText, int plainTextLen, uint8_t *cipherText, + int cipherTextLen, int *outLen) +{ + if (memcpy_s(cipherText, cipherTextLen, plainText, plainTextLen) != DEVICEMANAGER_OK) { + return DEVICEMANAGER_COPY_FAILED; + } + *outLen = plainTextLen; + return DEVICEMANAGER_OK; +} + +int32_t EncryptUtils::MbedtlsDecrypt(const uint8_t *cipherText, int32_t cipherTextLen, uint8_t *plainText, + int32_t plainTextLen, int32_t *outLen) +{ + (void)outLen; + if (memcpy_s(plainText, plainTextLen, cipherText, cipherTextLen) != DEVICEMANAGER_OK) { + return DEVICEMANAGER_COPY_FAILED; + } + return DEVICEMANAGER_OK; +} + +bool EncryptUtils::MbedtlsGenRandomStr(char *szOut, int32_t szOutLen, bool numberOnly) +{ + if (szOut == nullptr || szOutLen <= 2) { + return false; + } + szOut[--szOutLen] = 0; + GetRandomData((uint8_t*)szOut, szOutLen); + const int NUMBER_COUNT = 10; + const int ALPHA_COUNT = 26; + int M = numberOnly ? NUMBER_COUNT : (NUMBER_COUNT + 2 * ALPHA_COUNT); + for (int i = 0; i < szOutLen; i++) { + // 0~9,A~Z,a~z + unsigned int idx = ((unsigned int)szOut[i] % M); + char base; + if (idx < NUMBER_COUNT) { + base = '0'; + } else if (idx >= NUMBER_COUNT && idx < (NUMBER_COUNT + ALPHA_COUNT)) { + base = 'A'; + idx -= NUMBER_COUNT; + } else { + base = 'a'; + idx -= (NUMBER_COUNT + ALPHA_COUNT); + } + szOut[i] = base + idx; + } + return true; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/utils/src/ipc/lite/ipc_cmd_register.cpp b/utils/src/ipc/lite/ipc_cmd_register.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8faa2a22bf2e70fcb9473c2235a9ad4ca12085a9 --- /dev/null +++ b/utils/src/ipc/lite/ipc_cmd_register.cpp @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_cmd_register.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcCmdRegister); + +int32_t IpcCmdRegister::SetRequest(int32_t cmdCode, std::shared_ptr pBaseReq, IpcIo &request, + uint8_t *buffer, size_t buffLen) +{ + auto setRequestMapIter = setIpcRequestFuncMap_.find(cmdCode); + if (setRequestMapIter == setIpcRequestFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register SetRequestFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + return (setRequestMapIter->second)(pBaseReq, request, buffer, buffLen); +} + +int32_t IpcCmdRegister::ReadResponse(int32_t cmdCode, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + auto readResponseMapIter = readResponseFuncMap_.find(cmdCode); + if (readResponseMapIter == readResponseFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register ReadResponseFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + return (readResponseMapIter->second)(reply, pBaseRsp); +} + +int32_t IpcCmdRegister::OnIpcCmd(int32_t cmdCode, IpcIo &reply, const IpcContext &ctx, void *ipcMsg) +{ + auto onIpcCmdMapIter = onIpcCmdFuncMap_.find(cmdCode); + if (onIpcCmdMapIter == onIpcCmdFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register OnIpcCmdFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + (onIpcCmdMapIter->second)(reply, ctx, ipcMsg); + return DEVICEMANAGER_OK; +} + +int32_t IpcCmdRegister::OnIpcServerCmd(int32_t cmdCode, IpcIo &req, IpcIo &reply) +{ + auto onIpcServerCmdMapIter = onIpcServerCmdFuncMap_.find(cmdCode); + if (onIpcServerCmdMapIter == onIpcServerCmdFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register OnIpcCmdFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + (onIpcServerCmdMapIter->second)(req, reply); + return DEVICEMANAGER_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/utils/src/ipc/standard/ipc_cmd_register.cpp b/utils/src/ipc/standard/ipc_cmd_register.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e958dfd0498f15838b8cb7c6b7afaad37e841d25 --- /dev/null +++ b/utils/src/ipc/standard/ipc_cmd_register.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2021 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. + */ + +#include "ipc_cmd_register.h" + +#include "device_manager_errno.h" +#include "device_manager_log.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(IpcCmdRegister); + +int32_t IpcCmdRegister::SetRequest(int32_t cmdCode, std::shared_ptr pBaseReq, MessageParcel &data) +{ + auto setRequestMapIter = setIpcRequestFuncMap_.find(cmdCode); + if (setRequestMapIter == setIpcRequestFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register SetRequestFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + return (setRequestMapIter->second)(pBaseReq, data); +} + +int32_t IpcCmdRegister::ReadResponse(int32_t cmdCode, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + auto readResponseMapIter = readResponseFuncMap_.find(cmdCode); + if (readResponseMapIter == readResponseFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register ReadResponseFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + return (readResponseMapIter->second)(reply, pBaseRsp); +} + +int32_t IpcCmdRegister::OnIpcCmd(int32_t cmdCode, MessageParcel &data, MessageParcel &reply) +{ + auto onIpcCmdMapIter = onIpcCmdFuncMap_.find(cmdCode); + if (onIpcCmdMapIter == onIpcCmdFuncMap_.end()) { + DMLOG(DM_LOG_ERROR, "cmdCode:%d not register OnIpcCmdFunc", cmdCode); + return DEVICEMANAGER_IPC_NOT_REGISTER_FUNC; + } + return (onIpcCmdMapIter->second)(data, reply); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_proxy.h b/utils/src/log/dm_log.cpp similarity index 31% rename from interfaces/inner_kits/native_cpp/include/device_manager_proxy.h rename to utils/src/log/dm_log.cpp index 8d8a9755fa193ec5ae9de2c37d2013db1015fc41..538594b1564ab13ca0afc2e82cc10013465aabf6 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_proxy.h +++ b/utils/src/log/dm_log.cpp @@ -1,49 +1,89 @@ -/* - * Copyright (c) 2021 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 OHOS_DEVICE_MANAGER_PROXY_H -#define OHOS_DEVICE_MANAGER_PROXY_H - -#include "idevice_manager.h" -#include "iremote_proxy.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerProxy : public IRemoteProxy { -public: - explicit DeviceManagerProxy(const sptr& impl) : IRemoteProxy(impl) {}; - ~DeviceManagerProxy() {}; - - int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) override; - int32_t RegisterDeviceManagerListener(std::string &packageName, sptr listener) override; - int32_t UnRegisterDeviceManagerListener(std::string &packageName) override; - int32_t RegisterDeviceStateCallback(std::string &packageName, std::string &extra) override; - int32_t UnRegisterDeviceStateCallback(std::string &packageName) override; - int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) override; - int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) override; - int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra) override; - -private: - template - int32_t GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos); - bool WriteInterfaceToken(MessageParcel &data); - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_PROXY_H +/* + * Copyright (c) 2021 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. + */ + +#include "dm_log.h" + +#include "securec.h" + +#include "constants.h" + +#ifdef HI_LOG_ENABLE +#include "hilog/log.h" +#else +#include + +#endif + +namespace OHOS { +namespace DistributedHardware { +static void DMLogOut(DMLogLevel logLevel, const char *logBuf) +{ +#ifdef HI_LOG_ENABLE + LogLevel hiLogLevel = LOG_INFO; + switch (logLevel) { + case DM_LOG_DEBUG: + hiLogLevel = LOG_DEBUG; + break; + case DM_LOG_INFO: + hiLogLevel = LOG_INFO; + break; + case DM_LOG_WARN: + hiLogLevel = LOG_WARN; + break; + case DM_LOG_ERROR: + hiLogLevel = LOG_ERROR; + break; + default: + break; + } + (void)HiLogPrint(LOG_CORE, hiLogLevel, LOG_DOMAIN, "", "%{public}s", logBuf); +#else + switch (logLevel) { + case DM_LOG_DEBUG: + printf("[D]%s\n", logBuf); + break; + case DM_LOG_INFO: + printf("[I]%s\n", logBuf); + break; + case DM_LOG_WARN: + printf("[W]%s\n", logBuf); + break; + case DM_LOG_ERROR: + printf("[E]%s\n", logBuf); + break; + default: + break; + } +#endif +} + +void DMLog(DMLogLevel logLevel, const char *fmt, ...) +{ + char logBuf[LOG_MAX_LEN] = {0}; + va_list arg; + int32_t ret = 0; + + (void)memset_s(&arg, sizeof(va_list), 0, sizeof(va_list)); + va_start(arg, fmt); + ret = vsprintf_s(logBuf, sizeof(logBuf), fmt, arg); + va_end(arg); + if (ret < 0) { + DMLogOut(logLevel, "DM log length error."); + return; + } + DMLogOut(logLevel, logBuf); +} +} // namespace DistributedHardware +} // namespace OHOS