diff --git a/BUILD.gn b/BUILD.gn index 103ee5a70e69c1309143f9098d8f0df71bab2161..7e5dfc76c562adc8cc23b22f6b9a1ff6c989cacb 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -11,13 +11,13 @@ # See the License for the specific language governing permissions and # limitations under the License. +import("//build/lite/config/component/lite_component.gni") + if (defined(ohos_lite)) { - import("//build/lite/config/component/lite_component.gni") lite_component("devicemanager_lite") { - features = [ - "utils:devicemanagerutils", - "services/devicemanagerservice:devicemanagerservice", - "interfaces/inner_kits/native_cpp:devicemanagersdk", - ] + if (ohos_kernel_type == "liteos_m") { + } else { + features = [] + } } } diff --git a/common/include/constants.h b/common/include/constants.h deleted file mode 100644 index f8cf91ac7973277f053df97a9bfe7613f6064e6f..0000000000000000000000000000000000000000 --- a/common/include/constants.h +++ /dev/null @@ -1,167 +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_CONSTANTS_H -#define OHOS_DEVICE_MANAGER_CONSTANTS_H - -#include -#include - -namespace OHOS { -namespace DistributedHardware { - const std::string TARGET_PKG_NAME_KEY = "targetPkgName"; - const std::string HOST_PKG_NAME_KEY = "hostPackageName"; - - const int32_t LOG_MAX_LEN = 512; - const int32_t MIN_PIN_TOKEN = 10000000; - const int32_t MAX_PIN_TOKEN = 90000000; - const int32_t MIN_PIN_CODE = 100000; - const int32_t MAX_PIN_CODE = 999999; - const int32_t TOKEN_LEN = 9; - - const int32_t FAIL = -1; - const int32_t SUCCESS = 0; - const int32_t ERROR_INPUT_PARA_EMPTY = 2000; - const int32_t ERROR_INPUT_PARA_INVALID = 2001; - const int32_t ERROR_TARGET_PKG_NAME_NULL = 2002; - const int32_t ERROR_PKG_NAME_NOT_ON_DISCOVERY = 2003; - const int32_t ERROR_START_REMOTE_DM = 2006; - const int32_t ERROR_OPEN_CHANNEL_FAIL = 2008; - const int32_t ERROR_SEND_COMMAND_FAIL = 2009; - const int32_t ERROR_CHANNEL_BROKEN = 2010; - const int32_t ERROR_DUPLICATE_REQUEST = 2011; - const int32_t ERROR_TIME_OUT = 2012; - const int32_t ERROR_REQUEST_CANCEL = 2013; - const int32_t ERROR_USER_REJECT = 2015; - const int32_t ERROR_USER_BUSY = 2016; - const int32_t ERROR_API_NOT_SUPPORT = 2018; - const int32_t ERROR_SESSION_NOT_EXIT = 2019; - const int32_t ERROR_CREAT_GROUP_FAIL = 2020; - const int32_t ERROR_JOIN_GROUP_FAIL = 2021; - const int32_t ERROR_GET_LOCAL_DEVICE_INFO_FAIL = 2022; - const int32_t ERROR_CHECK_AUTH_FAIL = 2023; - const int32_t ERROR_NETWORK_UNAVAILABLE = 2028; - const int32_t ERROR_DEVICE_INFO_NULL = 2030; - const int32_t ERROR_APP_NAME_NULL = 2031; - const int32_t ERROR_APP_DESCRIPTION_INVALID = 2032; - const int32_t ERROR_APP_ICON_INVALID = 2033; - const int32_t ERROR_APP_THUMBNAIL_INVALID = 2034; - const int32_t ERROR_FA_START_FAIL = 2100; - - const int32_t ENCRYPT_TAG_LEN = 32; - - const std::string TAG_REQUESTER = "REQUESTER"; - const std::string TAG_TOKEN = "TOKEN"; - const std::string TAG_HOST = "HOST"; - const std::string TAG_TARGET = "TARGET"; - const std::string TAG_VISIBILITY = "VISIBILITY"; - const std::string TAG_GROUPIDS = "GROUPIDLIST"; - const std::string TAG_REPLY = "REPLY"; - const std::string TAG_NET_ID = "NETID"; - const std::string TAG_GROUP_ID = "GROUPID"; - const std::string TAG_GROUP_NAME = "GROUPNAME"; - const std::string TAG_REQUEST_ID = "REQUESTID"; - const std::string TAG_DEVICE_ID = "DEVICEID"; - const std::string TAG_DEVICE_TYPE = "DEVICETYPE"; - const std::string TAG_APP_NAME = "APPNAME"; - const std::string TAG_APP_DESCRIPTION = "APPDESC"; - const std::string TAG_APP_ICON = "APPICON"; - const std::string TAG_APP_THUMBNAIL = "APPTHUM"; - const std::string TAG_INDEX = "INDEX"; - const std::string TAG_SLICE_NUM = "SLICE"; - const std::string TAG_THUMBNAIL_SIZE = "THUMSIZE"; - const std::string TAG_AUTH_TYPE = "AUTHTYPE"; - - const std::string TAG_VER = "ITF_VER"; - const std::string TAG_TYPE = "MSG_TYPE"; - const std::string DM_ITF_VER = "1.0"; - const std::string TAG = "DM_MSG_CODEC"; - - // GroupConstants - const int32_t GROUP_VISIBILITY_IS_PUBLIC = -1; - const int32_t GROUP_VISIBILITY_IS_PRIVATE = 0; - const std::string REQUEST_AUTH_ADD_ID = "REQUEST_AUTH_ADD_ID"; - const std::string INVITATE_AUTH_ADD_ID = "INVITE_AUTH_ADD_ID"; - const int32_t PIN_CODE_INVALID = -1; - - // AuthConstants - const int32_t AUTH_SESSION_SIDE_SERVER = 0; - const int32_t AUTH_SESSION_SIDE_CLIENT = 1; - const int32_t SESSION_TYPE_IS_DEVICE_AUTH = 0; - const int32_t SESSION_TYPE_IS_APP_AUTH = 1; - const int32_t SESSION_REPLY_UNKNOWN = -1; - const int32_t SESSION_REPLY_ACCEPT = 0; - const int32_t SESSION_REPLY_CANCEL = 1; - const int32_t SESSION_REPLY_TIMEOUT = 2; - const int32_t SESSION_REPLY_AUTH_CONFIRM_TIMEOUT = 2; - const int32_t SESSION_REPLY_CANCEL_PINCODE_DISPLAY = 3; - const int32_t SESSION_REPLY_CANCEL_PINCODE_INPUT = 4; - const int32_t SESSION_REPLY_CREAT_GROUP_FAILED = 7; - const int32_t REQUEST_OPERATION = 0; - const int32_t QR_OPERATION = 1; - const int32_t PIN_OPERATION = 2; - const int32_t START_ACTIVITY_DIALOG = 1; - const int32_t START_ACTIVITY_QR = 2; - const int32_t START_ACTIVITY_FINISH = 3; - const int32_t START_ACTIVITY_PIN = 4; - const int32_t AUTH_STATUS_SKIP = 3; - const int32_t DEFAULT_PIN_CODE = 0; - const int32_t DEFAULT_PIN_TOKEN = 0; - const std::string DEVICE_NAME_KEY = "deviceName"; - const std::string DISPLAY_TIME_KEY = "displayTime"; - const std::string QR_BITMAP_KEY = "qrBitMap"; - const std::string PIN_CODE_KEY = "pinCode"; - const std::string START_ACTIVITY_KEY = "startActivityType"; - const std::string AUTH_TYPE = "authType"; - const std::string TOKEN = "token"; - const std::string PIN_TOKEN = "pinToken"; - const int32_t MSG_TYPE_TO_REMOTE = 0; - const int32_t MSG_TYPE_TO_CLOSED_CHANNEL = 1; - const std::string APP_NAME_KEY = "appName"; - const std::string APP_DESCRIPTION_KEY = "appDescription"; - const std::string APP_ICON_KEY = "appIcon"; - const std::string APP_THUMBNAIL_KEY = "appThumbnail"; - const std::string CANCEL_DISPLAY_KEY = "cancelPinCodeDisplay"; - const int32_t SLICE_NUM_INVALID = -1; - const int32_t AUTH_TYPE_QR = 0; - const int32_t AUTH_TYPE_PIN = 1; - const std::string DISPLAY_OWNER = "displayOwner"; - const int32_t DISPLAY_OWNER_SYSTEM = 0; - const int32_t DISPLAY_OWNER_OTHER = 1; - - // DmService constants - const int32_t MSG_MAX_SIZE = 45 * 1024; - const int32_t DES_SLICE_MAX_NUM = 5; - const int32_t ABILITY_ON = 1; - const int32_t ABILITY_INVALID = -1; - const int32_t DES_MAX_LEN = 256; - const int32_t ICON_MAX_LEN = 32 * 1024; - const int32_t THUMB_MAX_LEN = 153 * 1024; - - const int32_t DEVICE_UUID_LENGTH = 65; - const int32_t GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP = 1; - const int32_t GROUP_TYPE_PEER_TO_PEER_GROUP = 256; - - const int32_t GROUP_VISIBILITY_PUBLIC = -1; - - const int32_t BUSINESS_FA_MIRGRATION = 0; - const int32_t BUSINESS_RESOURCE_ACCESS = 1; - - // Base64 Constants - const int32_t BASE64_BYTE_LEN_3 = 3; - const int32_t BASE64_BYTE_LEN_4 = 4; -} -} -#endif diff --git a/common/include/device_manager_errno.h b/common/include/device_manager_errno.h deleted file mode 100644 index ab01276d9caf79af8b33f8c61d4cf5e826505ece..0000000000000000000000000000000000000000 --- a/common/include/device_manager_errno.h +++ /dev/null @@ -1,61 +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_ERRNO_H -#define OHOS_DEVICE_MANAGER_ERRNO_H - -namespace OHOS { -namespace DistributedHardware { -enum { - DEVICEMANAGER_FAILED = (-10000), - DEVICEMANAGER_SERVICE_NOT_READY, - DEVICEMANAGER_DEVICE_ALREADY_TRUSTED, - DEVICEMANAGER_GET_TRUSTED_DEVICE_FAILED, - DEVICEMANAGER_ALREADY_INIT, - DEVICEMANAGER_INIT_FAILED, - DEVICEMANAGER_MALLOC_ERROR, - DEVICEMANAGER_LOCK_ERROR, - DEVICEMANAGER_INVALID_PARAM, - DEVICEMANAGER_INVALID_VALUE, - DEVICEMANAGER_COPY_FAILED, - DEVICEMANAGER_NULLPTR, - DEVICEMANAGER_DISCOVERY_FAILED, - DEVICEMANAGER_FLATTEN_OBJECT, - DEVICEMANAGER_WRITE_FAILED, - DEVICEMANAGER_IPC_FAILED, - DEVICEMANAGER_IPC_TRANSACTION_FAILED, - DEVICEMANAGER_IPC_NOT_REGISTER_FUNC, - HICHAIN_GROUP_CREATE_FAILED, - HICHAIN_MEMBER_ADD_FAILED, - HICHAIN_CREATE_CHANNEL_FAILED, - MSG_DECODE_PARA_FAILED, - ENCRYPT_UTILS_INVALID_PARAM, - ENCRYPT_UTILS_GCM_SETKEY_FAILED, - ENCRYPT_UTILS_GCM_CRYPT_FAILED, - ENCRYPT_UTILS_GCM_AUTH_DECRYPT_FAILED, - ENCRYPT_UTILS_AES_GCM_ENCRYPT_FAILED, - ENCRYPT_UTILS_AES_GCM_DECRYPT_FAILED, - ERR_GEN_RANDOM_PINTOKEN_FAILED, - PIN_CODE_CHECK_FAILED, - PIN_TOKEN_CHECK_FAILED, - DEVICEMANAGER_CREATE_SESSION_SERVER_FAILED, - DEVICEMANAGER_OPEN_SESSION_FAILED, - AUTH_PARA_INVALID, - ENCODE_DATA_ERROR, - DEVICEMANAGER_OK = 0 -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_ERRNO_H diff --git a/common/include/dm_constants.h b/common/include/dm_constants.h new file mode 100644 index 0000000000000000000000000000000000000000..74fd7604f834fb2ddad57f37546d9b847ede12bf --- /dev/null +++ b/common/include/dm_constants.h @@ -0,0 +1,177 @@ +/* + * 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_CONSTANTS_H +#define OHOS_DM_CONSTANTS_H + +#include + +namespace OHOS { +namespace DistributedHardware { +const std::string DM_PKG_NAME = "ohos.distributedhardware.devicemanager"; +const std::string DM_SESSION_NAME = "ohos.distributedhardware.devicemanager.resident"; + +const std::string DISCOVER_STATUS_KEY = "persist.distributed_hardware.device_manager.discover_status"; +const std::string DISCOVER_STATUS_ON = "1"; +const std::string DISCOVER_STATUS_OFF = "0"; +const std::string AUTH_LOAD_JSON_KEY = "devicemanager_auth_components"; +const std::string ADAPTER_LOAD_JSON_KEY = "devicemanager_adapter_components"; +const std::string AUTH_JSON_TYPE_KEY = "AUTHENTICATE"; +const std::string CPYPTO_JSON_TYPE_KEY = "CPYPTO"; +const std::string PROFILE_JSON_TYPE_KEY = "PROFILE"; +const std::string DECISION_JSON_TYPE_KEY = "DECISION"; + +const int32_t DM_NAPI_SUBSCRIBE_CAPABILITY_DDMP = 0; +const int32_t DM_NAPI_SUBSCRIBE_CAPABILITY_OSD = 1; +const int32_t LOG_MAX_LEN = 512; +const int32_t MIN_PIN_TOKEN = 10000000; +const int32_t MAX_PIN_TOKEN = 90000000; +const int32_t MIN_PIN_CODE = 100000; +const int32_t MAX_PIN_CODE = 999999; +const int32_t DISCOVER_STATUS_LEN = 20; +const int32_t COMMON_CALLBACK_MAX_SIZE = 200; + +enum { + DM_OK = 0, + DM_FAILED = 1000, + DM_TIME_OUT, + DM_NOT_INIT, + DM_INT_MULTIPLE, + DM_INIT_FAILED, + DM_UNINIT_FAILED, + DM_POINT_NULL, + DM_INPUT_PARA_EMPTY, + DM_NOT_SYSTEM_APP, + DM_INVALID_VALUE, + DM_FLATTEN_OBJECT, + DM_MALLOC_ERROR, + DM_COPY_FAILED, + DM_WRITE_FAILED, + DM_DISCOVERY_FAILED, + DM_MAKE_SHARED_FAIL, + DM_SERVICE_NOT_READY, + DM_DEVICE_ALREADY_TRUSTED, + DM_IPC_FAILED = 2000, + DM_IPC_TRANSACTION_FAILED, + DM_IPC_FLATTEN_OBJECT, + DM_IPC_COPY_FAILED, + DM_IPC_SEND_REQUEST_FAILED, + DM_IPC_NOT_REGISTER_FUNC, + DM_IPC_RESPOND_ERROR, + DM_DISCOVERY_REPEATED, + DM_AUTH_NOT_SUPPORT, + DM_AUTH_BUSINESS_BUSY, + DM_AUTH_INPUT_FAILED, + DM_AUTH_STATE_FAILED, + DM_AUTH_DEVICE_AUTHED, + DM_AUTH_OPEN_SESSION_FAILED, + DM_AUTH_PEER_REJECT, + DM_AUTH_NOT_AUTH, + DM_SOFTBUS_FAILED = 3000, + DM_SOFTBUS_CREATE_SESSION_SERVER_FAILED, + DM_HICHAIN_FAILED = 4000, + DM_HICHAIN_GROUP_CREATE_FAILED, + DM_HICHAIN_MEMBER_ADD_FAILED, + DM_HICHAIN_CREATE_CHANNEL_FAILED, +}; +const std::string TARGET_PKG_NAME_KEY = "targetPkgName"; +const std::string HOST_PKG_NAME_KEY = "hostPackageName"; +const std::string TAG_REQUESTER = "REQUESTER"; +const std::string TAG_TOKEN = "TOKEN"; +const std::string TAG_HOST = "HOST"; +const std::string TAG_TARGET = "TARGET"; +const std::string TAG_VISIBILITY = "VISIBILITY"; +const std::string TAG_GROUPIDS = "GROUPIDLIST"; +const std::string TAG_REPLY = "REPLY"; +const std::string TAG_NET_ID = "NETID"; +const std::string TAG_GROUP_ID = "groupId"; +const std::string TAG_GROUP_NAME = "GROUPNAME"; +const std::string TAG_REQUEST_ID = "REQUESTID"; +const std::string TAG_DEVICE_ID = "DEVICEID"; +const std::string TAG_LOCAL_DEVICE_ID = "LOCALDEVICEID"; +const std::string TAG_DEVICE_TYPE = "DEVICETYPE"; +const std::string TAG_APP_NAME = "APPNAME"; +const std::string TAG_APP_DESCRIPTION = "APPDESC"; +const std::string TAG_APP_ICON = "APPICON"; +const std::string TAG_APP_THUMBNAIL = "APPTHUM"; +const std::string TAG_INDEX = "INDEX"; +const std::string TAG_SLICE_NUM = "SLICE"; +const std::string TAG_THUMBNAIL_SIZE = "THUMSIZE"; +const std::string TAG_AUTH_TYPE = "AUTHTYPE"; +const std::string TAG_CRYPTO_SUPPORT = "CRYPTOSUPPORT"; +const std::string TAG_CRYPTO_NAME = "CRYPTONAME"; +const std::string TAG_CRYPTO_VERSION = "CRYPTOVERSION"; +const std::string TAG_VER = "ITF_VER"; +const std::string TAG_TYPE = "MSG_TYPE"; +const std::string DM_ITF_VER_1_0 = "1.0"; +const std::string DM_ITF_VER = "1.1"; +const std::string TAG = "DM_MSG_CODEC"; +const std::string APP_NAME_KEY = "appName"; +const std::string APP_DESCRIPTION_KEY = "appDescription"; +const std::string APP_ICON_KEY = "appIcon"; +const std::string APP_THUMBNAIL_KEY = "appThumbnailKey"; +const std::string APP_THUMBNAIL_LEN = "appThumbnailLen"; +const std::string APP_THUMBNAIL = "appThumbnail"; +const std::string CANCEL_DISPLAY_KEY = "cancelPinCodeDisplay"; +const int32_t MSG_MAX_SIZE = 45 * 1024; +const int32_t AUTH_REPLY_ACCEPT = 0; +const int32_t ENCRYPT_TAG_LEN = 32; + +// pin +const int32_t DISPLAY_OWNER_SYSTEM = 0; +const int32_t DISPLAY_OWNER_OTHER = 1; +const int32_t BUSINESS_FA_MIRGRATION = 0; +const int32_t BUSINESS_RESOURCE_ACCESS = 1; + +// json +const std::string AUTH_TYPE = "authType"; +const std::string TOKEN = "token"; +const std::string PIN_TOKEN = "pinToken"; +const std::string PIN_CODE_KEY = "pinCode"; +const int32_t AUTH_TYPE_PIN = 1; +const int32_t AUTH_TYPE_SCAN = 2; +const int32_t AUTH_TYPE_TOUCH = 3; +const int32_t DEFAULT_PIN_CODE = 0; +const int32_t DEFAULT_PIN_TOKEN = 0; + +// Softbus +const int32_t SOFTBUS_CHECK_INTERVAL = 100000; // 100ms +const uint32_t SOFTBUS_SUBSCRIBE_ID_PREFIX_LEN = 16; +const int32_t SOFTBUS_SUBSCRIBE_ID_MASK = 0x0000FFFF; +const int32_t SOFTBUS_DISCOVER_DEVICE_INFO_MAX_SIZE = 20; +const int32_t AUTH_SESSION_SIDE_SERVER = 0; +const int32_t AUTH_SESSION_SIDE_CLIENT = 1; +const static char *DM_CAPABILITY_OSD = "osdCapability"; + +// HiChain +const int32_t DEVICE_UUID_LENGTH = 65; +const int32_t GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP = 1; +const int32_t GROUP_TYPE_PEER_TO_PEER_GROUP = 256; +const int32_t GROUP_VISIBILITY_PUBLIC = -1; +const int64_t MIN_REQUEST_ID = 1000000000; +const int64_t MAX_REQUEST_ID = 9999999999; +const int32_t FIELD_EXPIRE_TIME_VALUE = 7; +const int32_t GROUP_VISIBILITY_IS_PUBLIC = -1; +const int32_t GROUP_VISIBILITY_IS_PRIVATE = 0; +const std::string DEVICE_ID = "DEVICE_ID"; +const std::string WIFI_IP = "WIFI_IP"; +const std::string WIFI_PORT = "WIFI_PORT"; +const std::string BR_MAC = "BR_MAC"; +const std::string BLE_MAC = "BLE_MAC"; +const std::string ETH_IP = "ETH_IP"; +const std::string ETH_PORT = "ETH_PORT"; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/common/include/ipc/ipc_def.h b/common/include/ipc/ipc_def.h index b4dff8d420f6d77fb04309215b3ac18a8eb9e7a5..ec3a93d3ed6518238ae44a76ae77333986ef9723 100644 --- a/common/include/ipc/ipc_def.h +++ b/common/include/ipc/ipc_def.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -21,35 +21,39 @@ namespace DistributedHardware { #define DEVICE_MANAGER_SERVICE_NAME "dev_mgr_svc" #define MAX_DM_IPC_LEN 2048 -#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_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_IPC_INTERFACE(className) \ - DECLARE_IPC_MODEL(className) +#define DECLARE_IPC_INTERFACE(className) DECLARE_IPC_MODEL(className) enum IpcCmdID { REGISTER_DEVICE_MANAGER_LISTENER = 0, UNREGISTER_DEVICE_MANAGER_LISTENER, GET_TRUST_DEVICE_LIST, + GET_LOCAL_DEVICE_INFO, + GET_UDID_BY_NETWORK, + GET_UUID_BY_NETWORK, START_DEVICE_DISCOVER, STOP_DEVICE_DISCOVER, AUTHENTICATE_DEVICE, - CHECK_AUTHENTICATION, + UNAUTHENTICATE_DEVICE, + VERIFY_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, + SERVER_VERIFY_AUTH_RESULT, + SERVER_GET_DMFA_INFO, + SERVER_USER_AUTH_OPERATION, + SERVER_DEVICE_FA_NOTIFY, }; } // namespace DistributedHardware } // namespace OHOS diff --git a/common/include/ipc/model/ipc_authenticate_device_req.h b/common/include/ipc/model/ipc_authenticate_device_req.h index f4f066b3f20642a2ec71be913384dd209d18f17a..cb91c7743fc3c09b9fc8eaa625418f290d29fbce 100644 --- a/common/include/ipc/model/ipc_authenticate_device_req.h +++ b/common/include/ipc/model/ipc_authenticate_device_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,20 +13,19 @@ * 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" +#ifndef OHOS_DM_IPC_AUTHENTICATE_DEVICE_REQ_H +#define OHOS_DM_IPC_AUTHENTICATE_DEVICE_REQ_H #include "dm_device_info.h" -#include "dm_app_image_info.h" +#include "ipc_req.h" namespace OHOS { namespace DistributedHardware { class IpcAuthenticateDeviceReq : public IpcReq { -DECLARE_IPC_MODEL(IpcAuthenticateDeviceReq); + DECLARE_IPC_MODEL(IpcAuthenticateDeviceReq); + public: - const DmDeviceInfo& GetDeviceInfo() const + const DmDeviceInfo &GetDeviceInfo() const { return deviceInfo_; } @@ -36,30 +35,31 @@ public: deviceInfo_ = deviceInfo; } - const DmAppImageInfo& GetAppImageInfo() const + int32_t GetAuthType() { - return appImageInfo_; + return authType_; } - void SetAppImageInfo(const DmAppImageInfo &appImageInfo) + void SetAuthType(int32_t authType) { - appImageInfo_ = appImageInfo; + authType_ = authType; } - const std::string& GetExtra() const + const std::string &GetExtra() const { return extra_; } - void SetExtra(std::string &extra) + void SetExtra(const std::string &extra) { extra_ = extra; } + private: DmDeviceInfo deviceInfo_; - DmAppImageInfo appImageInfo_; + int32_t authType_; std::string extra_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_AUTHENTICATE_DEVICE_REQ_H +#endif // OHOS_DM_IPC_AUTHENTICATE_DEVICE_REQ_H diff --git a/common/include/ipc/model/ipc_get_dmfaparam_rsp.h b/common/include/ipc/model/ipc_get_dmfaparam_rsp.h new file mode 100644 index 0000000000000000000000000000000000000000..ed4b8958a739583da1f031d154208c1b02f7e39b --- /dev/null +++ b/common/include/ipc/model/ipc_get_dmfaparam_rsp.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_GET_DM_FA_PARAM_RSP_H +#define OHOS_DEVICE_MANAGER_IPC_GET_DM_FA_PARAM_RSP_H + +#include "dm_device_info.h" +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetDmFaParamRsp : public IpcRsp { + DECLARE_IPC_MODEL(IpcGetDmFaParamRsp); + +public: + const DmAuthParam GetDmAuthParam() const + { + return dmFaParam_; + } + + void SetDmAuthParam(const DmAuthParam &dmFaParam) + { + dmFaParam_ = dmFaParam; + } + +private: + DmAuthParam dmFaParam_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_GET_DM_FA_PARAM_RSP_H \ No newline at end of file diff --git a/common/include/ipc/model/ipc_get_authenticationparam_rsp.h b/common/include/ipc/model/ipc_get_info_by_network_req.h similarity index 61% rename from common/include/ipc/model/ipc_get_authenticationparam_rsp.h rename to common/include/ipc/model/ipc_get_info_by_network_req.h index b12c39f68c1c7f1b6e99b8da9a1bc53de1e30751..786b7d58fdc3e5d9d24b7654ae9031b57f1ae920 100644 --- a/common/include/ipc/model/ipc_get_authenticationparam_rsp.h +++ b/common/include/ipc/model/ipc_get_info_by_network_req.h @@ -13,29 +13,30 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_GET_AUTH_PARAM_RSP_H -#define OHOS_DEVICE_MANAGER_IPC_GET_AUTH_PARAM_RSP_H +#ifndef OHOS_DEVICE_MANAGER_IPC_GET_INFO_BY_NETWORK_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_GET_INFO_BY_NETWORK_REQ_H -#include "ipc_rsp.h" -#include "dm_device_info.h" +#include "ipc_req.h" namespace OHOS { namespace DistributedHardware { -class IpcGetAuthParamRsp : public IpcRsp { -DECLARE_IPC_MODEL(IpcGetAuthParamRsp); +class IpcGetInfoByNetWorkReq : public IpcReq { + DECLARE_IPC_MODEL(IpcGetInfoByNetWorkReq); + public: - const DmAuthParam& GetAuthParam() const + const std::string GetNetWorkId() const { - return authParam_; + return netWorkId_; } - void SetAuthParam(DmAuthParam &authParam) + void SetNetWorkId(const std::string &netWorkId) { - authParam_ = authParam; + netWorkId_ = netWorkId; } + private: - DmAuthParam authParam_; + std::string netWorkId_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_GET_AUTH_PARAM_RSP_H \ No newline at end of file +#endif // OHOS_DEVICE_MANAGER_IPC_GET_INFO_BY_NETWORK_REQ_H \ No newline at end of file diff --git a/common/include/ipc/model/ipc_get_info_by_network_rsp.h b/common/include/ipc/model/ipc_get_info_by_network_rsp.h new file mode 100644 index 0000000000000000000000000000000000000000..18dd12b4fb68e466e1f8a9b2368f439028f8936a --- /dev/null +++ b/common/include/ipc/model/ipc_get_info_by_network_rsp.h @@ -0,0 +1,54 @@ +/* + * 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_INFO_BY_NETWORK_RSP_H +#define OHOS_DEVICE_MANAGER_IPC_GET_INFO_BY_NETWORK_RSP_H + +#include + +#include "ipc_rsp.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetInfoByNetWorkRsp : public IpcRsp { + DECLARE_IPC_MODEL(IpcGetInfoByNetWorkRsp); + +public: + const std::string GetUdid() const + { + return udid_; + } + + void SetUdid(const std::string &udid) + { + udid_ = udid; + } + const std::string GetUuid() const + { + return uuid_; + } + + void SetUuid(const std::string &uuid) + { + uuid_ = uuid; + } + +private: + std::string udid_; + std::string uuid_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_IPC_GET_INFO_BY_NETWORK_RSP_H \ No newline at end of file diff --git a/common/include/ipc/model/ipc_get_local_device_info_rsp.h b/common/include/ipc/model/ipc_get_local_device_info_rsp.h new file mode 100644 index 0000000000000000000000000000000000000000..7494da0fe71fbdf215069007cd30843a1c16710b --- /dev/null +++ b/common/include/ipc/model/ipc_get_local_device_info_rsp.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_DM_IPC_GET_LOCAL_DEVICE_INFO_RSP_H +#define OHOS_DM_IPC_GET_LOCAL_DEVICE_INFO_RSP_H + +#include "dm_device_info.h" +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcGetLocalDeviceInfoRsp : public IpcRsp { + DECLARE_IPC_MODEL(IpcGetLocalDeviceInfoRsp); + +public: + const DmDeviceInfo &GetLocalDeviceInfo() const + { + return localDeviceInfo_; + } + + void SetLocalDeviceInfo(const DmDeviceInfo &localDeviceInfo) + { + localDeviceInfo_ = localDeviceInfo; + } + +private: + DmDeviceInfo localDeviceInfo_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_GET_LOCAL_DEVICE_INFO_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 index 695d87186f2d9b7074bf830e450be09e08873d21..d4a0a85a52dfe35084555a8585a3ddb437d4e49d 100644 --- a/common/include/ipc/model/ipc_get_trustdevice_req.h +++ b/common/include/ipc/model/ipc_get_trustdevice_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,28 +13,30 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_GET_TRUST_DEVICE_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_GET_TRUST_DEVICE_REQ_H +#ifndef OHOS_DM_IPC_GET_TRUST_DEVICE_REQ_H +#define OHOS_DM_IPC_GET_TRUST_DEVICE_REQ_H #include "ipc_req.h" namespace OHOS { namespace DistributedHardware { -class IpcGetTrustdeviceReq : public IpcReq { -DECLARE_IPC_MODEL(IpcGetTrustdeviceReq); +class IpcGetTrustDeviceReq : public IpcReq { + DECLARE_IPC_MODEL(IpcGetTrustDeviceReq); + public: - const std::string& GetExtra() const + const std::string &GetExtra() const { return extra_; } - void SetExtra(std::string &extra) + void SetExtra(const std::string &extra) { extra_ = extra; } + private: std::string extra_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_GET_TRUST_DEVICE_REQ_H +#endif // OHOS_DM_IPC_GET_TRUST_DEVICE_REQ_H diff --git a/common/include/ipc/model/ipc_get_trustdevice_rsp.h b/common/include/ipc/model/ipc_get_trustdevice_rsp.h index 6df09e883003d1276d506e7839c437f1f1d3afd5..67260f38b35f9ebe5bd1208d7c7813438a2c1a98 100644 --- a/common/include/ipc/model/ipc_get_trustdevice_rsp.h +++ b/common/include/ipc/model/ipc_get_trustdevice_rsp.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,32 +13,33 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_GET_TRUSTDEVICE_RSP_H -#define OHOS_DEVICE_MANAGER_IPC_GET_TRUSTDEVICE_RSP_H +#ifndef OHOS_DM_IPC_GET_TRUST_DEVICE_RSP_H +#define OHOS_DM_IPC_GET_TRUST_DEVICE_RSP_H #include #include "dm_device_info.h" - #include "ipc_rsp.h" namespace OHOS { namespace DistributedHardware { -class IpcGetTrustdeviceRsp : public IpcRsp { -DECLARE_IPC_MODEL(IpcGetTrustdeviceRsp); +class IpcGetTrustDeviceRsp : public IpcRsp { + DECLARE_IPC_MODEL(IpcGetTrustDeviceRsp); + public: std::vector GetDeviceVec() const { return deviceVec_; } - void SetDeviceVec(std::vector& 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 +#endif // OHOS_DM_IPC_GET_TRUST_DEVICE_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 index afee8f6646ae85b00b0d3f09b2cf9c6fbbe786d7..7c9034b166587d4d9b2a9e0318b06278e9735d15 100644 --- a/common/include/ipc/model/ipc_notify_auth_result_req.h +++ b/common/include/ipc/model/ipc_notify_auth_result_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H +#ifndef OHOS_DM_IPC_NOTIFY_AUTH_RESULT_REQ_H +#define OHOS_DM_IPC_NOTIFY_AUTH_RESULT_REQ_H #include @@ -23,26 +23,27 @@ namespace OHOS { namespace DistributedHardware { class IpcNotifyAuthResultReq : public IpcReq { -DECLARE_IPC_MODEL(IpcNotifyAuthResultReq); + DECLARE_IPC_MODEL(IpcNotifyAuthResultReq); + public: std::string GetDeviceId() const { return deviceId_; } - void SetDeviceId(std::string& deviceId) + void SetDeviceId(const std::string &deviceId) { deviceId_ = deviceId; } - int32_t GetPinToken() const + std::string GetPinToken() const { - return pinToken_; + return token_; } - void SetPinToken(int32_t pinToken) + void SetToken(const std::string &token) { - pinToken_ = pinToken; + token_ = token; } int32_t GetStatus() const @@ -64,12 +65,13 @@ public: { reason_ = reason; } + private: std::string deviceId_; - int32_t pinToken_ {0}; - int32_t status_ {0}; - int32_t reason_ {0}; + std::string token_; + int32_t status_{0}; + int32_t reason_{0}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H +#endif // OHOS_DM_IPC_NOTIFY_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 index 6c094766023c581bcf8aca1ff6117cd70e4f34e0..d52c13f93cab958e622316a8fa0f92f4b729c159 100644 --- a/common/include/ipc/model/ipc_notify_device_found_req.h +++ b/common/include/ipc/model/ipc_notify_device_found_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,24 +13,24 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_FOUND_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_FOUND_REQ_H +#ifndef OHOS_DM_IPC_NOTIFY_DEVICE_FOUND_REQ_H +#define OHOS_DM_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); + DECLARE_IPC_MODEL(IpcNotifyDeviceFoundReq); + public: - const DmDeviceInfo& GetDeviceInfo() const + const DmDeviceInfo &GetDeviceInfo() const { return dmDeviceInfo_; } - void SetDeviceInfo(DmDeviceInfo& dmDeviceInfo) + void SetDeviceInfo(const DmDeviceInfo &dmDeviceInfo) { dmDeviceInfo_ = dmDeviceInfo; } @@ -44,10 +44,11 @@ public: { subscribeId_ = subscribeId; } + private: - uint16_t subscribeId_ {0}; + uint16_t subscribeId_{0}; DmDeviceInfo dmDeviceInfo_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_FOUND_REQ_H +#endif // OHOS_DM_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 index 0f20867c5b8c96ee0ba062c32205829991eafd69..19cfb68da4ac99cb2c52fe0b59ccacc449fc2e5f 100644 --- a/common/include/ipc/model/ipc_notify_device_state_req.h +++ b/common/include/ipc/model/ipc_notify_device_state_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,17 +13,17 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_STATE_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_STATE_REQ_H +#ifndef OHOS_DM_IPC_NOTIFY_DEVICE_STATE_REQ_H +#define OHOS_DM_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); + DECLARE_IPC_MODEL(IpcNotifyDeviceStateReq); + public: int32_t GetDeviceState() const { @@ -35,19 +35,20 @@ public: deviceState_ = deviceState; } - const DmDeviceInfo& GetDeviceInfo() const + const DmDeviceInfo &GetDeviceInfo() const { return dmDeviceInfo_; } - void SetDeviceInfo(DmDeviceInfo& dmDeviceInfo) + void SetDeviceInfo(const DmDeviceInfo &dmDeviceInfo) { dmDeviceInfo_ = dmDeviceInfo; } + private: - int32_t deviceState_ {0}; + int32_t deviceState_{0}; DmDeviceInfo dmDeviceInfo_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DEVICE_STATE_REQ_H +#endif // OHOS_DM_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 index ea6776ed04730e7d71488d2fbec674435414a2a6..8c9588399e421092114625c04307bbe0de26ef1f 100644 --- a/common/include/ipc/model/ipc_notify_discover_result_req.h +++ b/common/include/ipc/model/ipc_notify_discover_result_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,17 +13,16 @@ * 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 +#ifndef OHOS_DM_IPC_NOTIFY_DISCOVER_RESULT_REQ_H +#define OHOS_DM_IPC_NOTIFY_DISCOVER_RESULT_REQ_H #include "ipc_req.h" namespace OHOS { namespace DistributedHardware { class IpcNotifyDiscoverResultReq : public IpcReq { -DECLARE_IPC_MODEL(IpcNotifyDiscoverResultReq); + DECLARE_IPC_MODEL(IpcNotifyDiscoverResultReq); + public: uint16_t GetSubscribeId() const { @@ -44,10 +43,11 @@ public: { result_ = result; } + private: - uint16_t subscribeId_ {0}; - int32_t result_ {0}; + uint16_t subscribeId_{0}; + int32_t result_{0}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DISCOVER_RESULT_REQ_H +#endif // OHOS_DM_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 index e6012aa7af825489250a554935e2985a2ce55ab4..006c0966efffee5d98839e298c8078f17b568f06 100644 --- a/common/include/ipc/model/ipc_notify_dmfa_result_req.h +++ b/common/include/ipc/model/ipc_notify_dmfa_result_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -16,27 +16,27 @@ #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); + DECLARE_IPC_MODEL(IpcNotifyDMFAResultReq); + public: std::string GetJsonParam() const { return JsonParam_; } - void SetJsonParam(std::string& JsonParam) + void SetJsonParam(const std::string &JsonParam) { JsonParam_ = JsonParam; } + private: std::string JsonParam_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_AUTH_RESULT_REQ_H +#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_DMFA_RESULT_REQ_H diff --git a/common/include/ipc/model/ipc_notify_check_auth_result_req.h b/common/include/ipc/model/ipc_notify_verify_auth_result_req.h similarity index 72% rename from common/include/ipc/model/ipc_notify_check_auth_result_req.h rename to common/include/ipc/model/ipc_notify_verify_auth_result_req.h index 0e153d560df96374e761fd468375decf4f23a42d..df01942ff6096c00afecd1cc0177dac5dde19c12 100644 --- a/common/include/ipc/model/ipc_notify_check_auth_result_req.h +++ b/common/include/ipc/model/ipc_notify_verify_auth_result_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * 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 +#ifndef OHOS_DM_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H +#define OHOS_DM_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H #include @@ -22,15 +22,16 @@ namespace OHOS { namespace DistributedHardware { -class IpcNotifyCheckAuthResultReq : public IpcReq { -DECLARE_IPC_MODEL(IpcNotifyCheckAuthResultReq); +class IpcNotifyVerifyAuthResultReq : public IpcReq { + DECLARE_IPC_MODEL(IpcNotifyVerifyAuthResultReq); + public: std::string GetDeviceId() const { return deviceId_; } - void SetDeviceId(std::string& deviceId) + void SetDeviceId(const std::string &deviceId) { deviceId_ = deviceId; } @@ -54,11 +55,12 @@ public: { flag_ = flag; } + private: std::string deviceId_; - int32_t result_ {0}; - int32_t flag_ {0}; + int32_t result_{0}; + int32_t flag_{0}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H +#endif // OHOS_DM_IPC_NOTIFY_CHECK_AUTH_RESULT_REQ_H diff --git a/common/include/ipc/model/ipc_register_listener_req.h b/common/include/ipc/model/ipc_register_listener_req.h index 67690a5b8985ff94ad03a15e0aef22c5f1606115..539b0e58bb5630151b4a6c7ffd98e266163bec02 100644 --- a/common/include/ipc/model/ipc_register_listener_req.h +++ b/common/include/ipc/model/ipc_register_listener_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_REGISTER_LISTENER_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_REGISTER_LISTENER_REQ_H +#ifndef OHOS_DM_IPC_REGISTER_LISTENER_REQ_H +#define OHOS_DM_IPC_REGISTER_LISTENER_REQ_H #include "ipc_req.h" @@ -27,7 +27,8 @@ namespace OHOS { namespace DistributedHardware { class IpcRegisterListenerReq : public IpcReq { -DECLARE_IPC_MODEL(IpcRegisterListenerReq); + DECLARE_IPC_MODEL(IpcRegisterListenerReq); + public: #ifdef LITE_DEVICE SvcIdentity GetSvcIdentity() const @@ -59,4 +60,4 @@ private: }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_REGISTER_LISTENER_REQ_H +#endif // OHOS_DM_IPC_REGISTER_LISTENER_REQ_H diff --git a/common/include/ipc/model/ipc_req.h b/common/include/ipc/model/ipc_req.h index ac6e99d80dc009ca69191f95deaa9f8a360c9067..7ecadbf3c5f09e5bcfab5485c64d823098a812db 100644 --- a/common/include/ipc/model/ipc_req.h +++ b/common/include/ipc/model/ipc_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_REQ_H +#ifndef OHOS_DM_IPC_REQ_H +#define OHOS_DM_IPC_REQ_H #include @@ -23,20 +23,22 @@ namespace OHOS { namespace DistributedHardware { class IpcReq { -DECLARE_IPC_MODEL(IpcReq); + DECLARE_IPC_MODEL(IpcReq); + public: - const std::string& GetPkgName() const + const std::string &GetPkgName() const { return pkgName_; } - void SetPkgName(std::string &pkgName) + void SetPkgName(const std::string &pkgName) { pkgName_ = pkgName; } + private: std::string pkgName_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_REQ_H +#endif // OHOS_DM_IPC_REQ_H diff --git a/common/include/ipc/model/ipc_rsp.h b/common/include/ipc/model/ipc_rsp.h index 14394280be0cfa596b6d903c9249b5c35af8d6b9..251d6097bc37e274d5a0ee3f9f83f851a72d612d 100644 --- a/common/include/ipc/model/ipc_rsp.h +++ b/common/include/ipc/model/ipc_rsp.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_RSP_H -#define OHOS_DEVICE_MANAGER_IPC_RSP_H +#ifndef OHOS_DM_IPC_RSP_H +#define OHOS_DM_IPC_RSP_H #include @@ -23,7 +23,8 @@ namespace OHOS { namespace DistributedHardware { class IpcRsp { -DECLARE_IPC_MODEL(IpcRsp); + DECLARE_IPC_MODEL(IpcRsp); + public: int32_t GetErrCode() const { @@ -34,9 +35,10 @@ public: { errCode_ = errCode; } + private: int32_t errCode_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_RSP_H +#endif // OHOS_DM_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 index e2f51db3f24940f296c6d6b72d75fc3354f51121..9b6e85fe7d3d4756f658628c2443da441af2af9b 100644 --- a/common/include/ipc/model/ipc_set_useroperation_req.h +++ b/common/include/ipc/model/ipc_set_useroperation_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,13 +15,15 @@ #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" +#include "ipc_req.h" namespace OHOS { namespace DistributedHardware { class IpcGetOperationReq : public IpcReq { -DECLARE_IPC_MODEL(IpcGetOperationReq); + DECLARE_IPC_MODEL(IpcGetOperationReq); + public: int32_t GetOperation() const { @@ -34,7 +36,7 @@ public: } private: - int32_t action_ {0}; + int32_t action_{0}; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/common/include/ipc/model/ipc_start_discovery_req.h b/common/include/ipc/model/ipc_start_discovery_req.h index 341641e61ca71525da598fcca5f45c0c726c6f26..e145ac89da93dc401b830063cea7c055eb9a5826 100644 --- a/common/include/ipc/model/ipc_start_discovery_req.h +++ b/common/include/ipc/model/ipc_start_discovery_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,30 +13,42 @@ * 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" +#ifndef OHOS_DM_IPC_START_DISCOVERY_REQ_H +#define OHOS_DM_IPC_START_DISCOVERY_REQ_H #include "dm_subscribe_info.h" +#include "ipc_req.h" namespace OHOS { namespace DistributedHardware { class IpcStartDiscoveryReq : public IpcReq { -DECLARE_IPC_MODEL(IpcStartDiscoveryReq); + DECLARE_IPC_MODEL(IpcStartDiscoveryReq); + public: - const DmSubscribeInfo& GetSubscribeInfo() const + const DmSubscribeInfo &GetSubscribeInfo() const { return subscribeInfo_; } - void SetSubscribeInfo(DmSubscribeInfo &subscribeInfo) + void SetSubscribeInfo(const DmSubscribeInfo &subscribeInfo) { subscribeInfo_ = subscribeInfo; } + + const std::string &GetExtra() const + { + return extra_; + } + + void SetExtra(const std::string &extra) + { + extra_ = extra; + } + private: + std::string extra_; DmSubscribeInfo subscribeInfo_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_START_DISCOVERY_REQ_H +#endif // OHOS_DM_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 index bf1de6b173a3db1aef4dc91b63a8be7ac7fe71a0..10c547e885307e0f3cc35be5b32ce459a6af0b95 100644 --- a/common/include/ipc/model/ipc_stop_discovery_req.h +++ b/common/include/ipc/model/ipc_stop_discovery_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_STOP_DISCOVERY_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_STOP_DISCOVERY_REQ_H +#ifndef OHOS_DM_IPC_STOP_DISCOVERY_REQ_H +#define OHOS_DM_IPC_STOP_DISCOVERY_REQ_H #include @@ -23,7 +23,8 @@ namespace OHOS { namespace DistributedHardware { class IpcStopDiscoveryReq : public IpcReq { -DECLARE_IPC_MODEL(IpcStopDiscoveryReq); + DECLARE_IPC_MODEL(IpcStopDiscoveryReq); + public: uint16_t GetSubscribeId() const { @@ -34,9 +35,10 @@ public: { subscribeId_ = subscribeId; } + private: - uint16_t subscribeId_ {0}; + uint16_t subscribeId_{0}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_STOP_DISCOVERY_REQ_H +#endif // OHOS_DM_IPC_STOP_DISCOVERY_REQ_H diff --git a/common/include/ipc/model/ipc_unauthenticate_device_req.h b/common/include/ipc/model/ipc_unauthenticate_device_req.h new file mode 100644 index 0000000000000000000000000000000000000000..78244377a778b8b4ee298fe313c3085698055dcb --- /dev/null +++ b/common/include/ipc/model/ipc_unauthenticate_device_req.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_DM_IPC_UNAUTHENTICATE_DEVICE_REQ_H +#define OHOS_DM_IPC_UNAUTHENTICATE_DEVICE_REQ_H + +#include "dm_device_info.h" +#include "ipc_req.h" + +namespace OHOS { +namespace DistributedHardware { +class IpcUnAuthenticateDeviceReq : public IpcReq { + DECLARE_IPC_MODEL(IpcUnAuthenticateDeviceReq); + +public: + const DmDeviceInfo &GetDeviceInfo() const + { + return deviceInfo_; + } + + void SetDeviceInfo(const DmDeviceInfo &deviceInfo) + { + deviceInfo_ = deviceInfo; + } + +private: + DmDeviceInfo deviceInfo_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_UNAUTHENTICATE_DEVICE_REQ_H diff --git a/common/include/ipc/model/ipc_check_authenticate_req.h b/common/include/ipc/model/ipc_verify_authenticate_req.h similarity index 66% rename from common/include/ipc/model/ipc_check_authenticate_req.h rename to common/include/ipc/model/ipc_verify_authenticate_req.h index ea136b42103c505cd5ef3b802c5d264afcd94bc1..3c2df5547c858c3564730b5a86e44842e2693c14 100644 --- a/common/include/ipc/model/ipc_check_authenticate_req.h +++ b/common/include/ipc/model/ipc_verify_authenticate_req.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,28 +13,30 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CHECK_AUTHENTICATE_REQ_H -#define OHOS_DEVICE_MANAGER_IPC_CHECK_AUTHENTICATE_REQ_H +#ifndef OHOS_DEVICE_MANAGER_IPC_VERIFY_AUTHENTICATE_REQ_H +#define OHOS_DEVICE_MANAGER_IPC_VERIFY_AUTHENTICATE_REQ_H #include "ipc_req.h" namespace OHOS { namespace DistributedHardware { -class IpcCheckAuthenticateReq : public IpcReq { -DECLARE_IPC_MODEL(IpcCheckAuthenticateReq); +class IpcVerifyAuthenticateReq : public IpcReq { + DECLARE_IPC_MODEL(IpcVerifyAuthenticateReq); + public: - const std::string& GetAuthPara() const + const std::string &GetAuthPara() const { return authPara_; } - void SetAuthPara(std::string &authPara) + void SetAuthPara(const std::string &authPara) { authPara_ = authPara; } + private: std::string authPara_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CHECK_AUTHENTICATE_REQ_H +#endif // OHOS_DEVICE_MANAGER_IPC_VERIFY_AUTHENTICATE_REQ_H diff --git a/common/include/single_instance.h b/common/include/single_instance.h index a76aa07e23b65ea091822daf34b94eb39d18a826..0bfa9e404ea7e90fbae0732e10d1bf9f22216b7d 100644 --- a/common/include/single_instance.h +++ b/common/include/single_instance.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,34 +13,34 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_SINGLE_INSTANCE_H -#define OHOS_DEVICE_MANAGER_SINGLE_INSTANCE_H +#ifndef OHOS_DM_SINGLE_INSTANCE_H +#define OHOS_DM_SINGLE_INSTANCE_H namespace OHOS { namespace DistributedHardware { #define DECLARE_SINGLE_INSTANCE_BASE(className) \ -public: \ - static className & GetInstance(); \ +public: \ + static className &GetInstance(); \ + \ private: \ - className(const className&) = delete; \ - className& operator= (const className&) = delete; \ - className(className&&) = delete; \ - className& operator= (className&&) = delete; \ - + 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() = default; -#define IMPLEMENT_SINGLE_INSTANCE(className) \ -className & className::GetInstance() \ -{ \ - static auto instance = new className(); \ - return *instance; \ -} +#define IMPLEMENT_SINGLE_INSTANCE(className) \ + className &className::GetInstance() \ + { \ + static auto instance = new className(); \ + return *instance; \ + } }; // namespace DistributedHardware }; // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SINGLE_INSTANCE_H \ No newline at end of file +#endif // OHOS_DM_SINGLE_INSTANCE_H \ No newline at end of file diff --git a/devicemanager.gni b/devicemanager.gni index e8576d35d8e156e023ffc44a33b454bbe4a97304..7487a8b3207ca8007a54e97034d8c74366cb9653 100644 --- a/devicemanager.gni +++ b/devicemanager.gni @@ -11,14 +11,18 @@ # See the License for the specific language governing permissions and # limitations under the License. +#------------------------device manager------------------------------# devicemanager_path = "//foundation/distributedhardware/devicemanager" common_path = "${devicemanager_path}/common" - utils_path = "${devicemanager_path}/utils" +services_path = "${devicemanager_path}/services/devicemanagerservice" +innerkits_path = "${devicemanager_path}/interfaces/inner_kits" +ext_path = "${devicemanager_path}/ext" -services_path = "${devicemanager_path}/services" +#--------------------------softbus----------------------------------# -innerkits_path = "${devicemanager_path}/interfaces/inner_kits" +#---------------------------hichan----------------------------------# +#----------------------compilation options--------------------------# dm_ldflags = [ "-lpthread" ] diff --git a/display/build.gradle b/display/build.gradle index 12771702eb7daa36a5b439b1544c19e756d9b64a..151e80b67a03ddf9df7f7f3ad9e78826244b994c 100644 --- a/display/build.gradle +++ b/display/build.gradle @@ -1,57 +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. - */ - - // Top-level build file where you can add configuration options common to all sub-projects/modules. -apply plugin: 'com.huawei.ohos.app' - -ohos { - compileSdkVersion 6 - defaultConfig { - compatibleSdkVersion 6 - } -} - -buildscript { - repositories { - maven { - url 'http://repo.ark.tools.huawei.com/artifactory/maven-public/' - } - maven { - url 'https://mirrors.huaweicloud.com/repository/maven/' - } - maven { - url 'https://developer.huawei.com/repo/' - } - jcenter() - } - dependencies { - classpath 'com.huawei.ohos:hap:2.4.4.3-RC' - } -} - -allprojects { - repositories { - maven { - url 'http://repo.ark.tools.huawei.com/artifactory/maven-public/' - } - maven { - url 'https://mirrors.huaweicloud.com/repository/maven/' - } - maven { - url 'https://developer.huawei.com/repo/' - } - jcenter() - } +/* + * 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. + */ + + // Top-level build file where you can add configuration options common to all sub-projects/modules. +apply plugin: 'com.huawei.ohos.app' + +ohos { + compileSdkVersion 6 + defaultConfig { + compatibleSdkVersion 6 + } +} + +buildscript { + repositories { + maven { + url 'http://repo.ark.tools.huawei.com/artifactory/maven-public/' + } + maven { + url 'https://mirrors.huaweicloud.com/repository/maven/' + } + maven { + url 'https://developer.huawei.com/repo/' + } + jcenter() + } + dependencies { + classpath 'com.huawei.ohos:hap:2.4.4.3-RC' + } +} + +allprojects { + repositories { + maven { + url 'http://repo.ark.tools.huawei.com/artifactory/maven-public/' + } + maven { + url 'https://mirrors.huaweicloud.com/repository/maven/' + } + maven { + url 'https://developer.huawei.com/repo/' + } + jcenter() + } } \ No newline at end of file diff --git a/display/entry/build.gradle b/display/entry/build.gradle index 498918b6ffda790cc9f1417435f6e2f7f7bbdf64..1f560cd47c2b0a5ce96a574a892a6d06ceb4e6f9 100644 --- a/display/entry/build.gradle +++ b/display/entry/build.gradle @@ -1,42 +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. - */ - - apply plugin: 'com.huawei.ohos.hap' -apply plugin: 'com.huawei.ohos.decctest' -//For instructions on signature configuration, see https://developer.harmonyos.com/cn/docs/documentation/doc-guides/ide_debug_device-0000001053822404#section1112183053510 -ohos { - compileSdkVersion 6 - defaultConfig { - compatibleSdkVersion 6 - } - buildTypes { - release { - proguardOpt { - proguardEnabled false - rulesFiles 'proguard-rules.pro' - } - } - } - -} - -dependencies { - implementation fileTree(dir: 'libs', include: ['*.jar', '*.har']) - testImplementation 'junit:junit:4.13' - ohosTestImplementation 'com.huawei.ohos.testkit:runner:1.0.0.200' -} -decc { - supportType = ['html', 'xml'] -} +/* + * 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. + */ + + apply plugin: 'com.huawei.ohos.hap' +apply plugin: 'com.huawei.ohos.decctest' +//For instructions on signature configuration, see https://developer.harmonyos.com/cn/docs/documentation/doc-guides/ide_debug_device-0000001053822404#section1112183053510 +ohos { + compileSdkVersion 6 + defaultConfig { + compatibleSdkVersion 6 + } + buildTypes { + release { + proguardOpt { + proguardEnabled false + rulesFiles 'proguard-rules.pro' + } + } + } + +} + +dependencies { + implementation fileTree(dir: 'libs', include: ['*.jar', '*.har']) + testImplementation 'junit:junit:4.13' + ohosTestImplementation 'com.huawei.ohos.testkit:runner:1.0.0.200' +} +decc { + supportType = ['html', 'xml'] +} diff --git a/display/entry/src/main/config.json b/display/entry/src/main/config.json index faf4f0465602f1eb9a90f2c46297be006e2c77ff..946df5f473995fef4fb85e1ec0a6565594868a82 100644 --- a/display/entry/src/main/config.json +++ b/display/entry/src/main/config.json @@ -1,61 +1,61 @@ -{ - "app": { - "bundleName": "com.ohos.devicemanagerui", - "vendor": "ohos", - "version": { - "code": 1000000, - "name": "1.0.0" - } - }, - "deviceConfig": {}, - "module": { - "package": "com.ohos.devicemanagerui", - "name": ".MyApplication", - "mainAbility": "com.ohos.devicemanagerui.MainAbility", - "deviceType": [ - "phone", - "tablet", - "tv", - "wearable" - ], - "distro": { - "deliveryWithInstall": true, - "moduleName": "entry", - "moduleType": "entry", - "installationFree": false - }, - "abilities": [ - { - "skills": [ - { - "entities": [ - "entity.system.home" - ], - "actions": [ - "action.system.home" - ] - } - ], - "visible": true, - "name": "com.ohos.devicemanagerui.MainAbility", - "icon": "$media:icon", - "description": "$string:mainability_description", - "label": "$string:entry_MainAbility", - "type": "page", - "launchType": "standard" - } - ], - "js": [ - { - "pages": [ - "pages/index/index" - ], - "name": "default", - "window": { - "designWidth": 720, - "autoDesignWidth": true - } - } - ] - } +{ + "app": { + "bundleName": "com.ohos.devicemanagerui", + "vendor": "ohos", + "version": { + "code": 1000000, + "name": "1.0.0" + } + }, + "deviceConfig": {}, + "module": { + "package": "com.ohos.devicemanagerui", + "name": ".MyApplication", + "mainAbility": "com.ohos.devicemanagerui.MainAbility", + "deviceType": [ + "phone", + "tablet", + "tv", + "wearable" + ], + "distro": { + "deliveryWithInstall": true, + "moduleName": "entry", + "moduleType": "entry", + "installationFree": false + }, + "abilities": [ + { + "skills": [ + { + "entities": [ + "entity.system.home" + ], + "actions": [ + "action.system.home" + ] + } + ], + "visible": true, + "name": "com.ohos.devicemanagerui.MainAbility", + "icon": "$media:icon", + "description": "$string:mainability_description", + "label": "$string:entry_MainAbility", + "type": "page", + "launchType": "standard" + } + ], + "js": [ + { + "pages": [ + "pages/index/index" + ], + "name": "default", + "window": { + "designWidth": 720, + "autoDesignWidth": true + } + } + ] + } } \ No newline at end of file diff --git a/display/entry/src/main/resources/base/element/string.json b/display/entry/src/main/resources/base/element/string.json index c0dd3a09e5dcefc69f22b5e00e92296f1c3f55a5..0bae6bd40f7360d5d818998221b199d3ec0f69c0 100644 --- a/display/entry/src/main/resources/base/element/string.json +++ b/display/entry/src/main/resources/base/element/string.json @@ -1,12 +1,12 @@ -{ - "string": [ - { - "name": "entry_MainAbility", - "value": "entry_MainAbility" - }, - { - "name": "mainability_description", - "value": "JS_Empty Ability" - } - ] +{ + "string": [ + { + "name": "entry_MainAbility", + "value": "entry_MainAbility" + }, + { + "name": "mainability_description", + "value": "JS_Empty Ability" + } + ] } \ No newline at end of file diff --git a/display/settings.gradle b/display/settings.gradle index 28d595f2fba0d06b2025da200383d15f87c4e9f0..4773db73233a570c2d0c01a22e75321acfbf7a07 100644 --- a/display/settings.gradle +++ b/display/settings.gradle @@ -1 +1 @@ -include ':entry' +include ':entry' diff --git a/ext/pin_auth/BUILD.gn b/ext/pin_auth/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..333c13403fb44328a48c1a22d7527e4044ba557a --- /dev/null +++ b/ext/pin_auth/BUILD.gn @@ -0,0 +1,67 @@ +# 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. + +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} + +import("//foundation/distributedhardware/devicemanager/devicemanager.gni") + +if (defined(ohos_lite)) { +} else { + ohos_shared_library("devicemanagerext_pin_auth") { + include_dirs = [ + "include", + "${common_path}/include", + "${services_path}/include/adapter", + "${ext_path}/pin_auth/include/ability", + "${services_path}/include/authentication", + "${utils_path}/include", + ] + + sources = [ + "src/ability/standard/dm_ability_manager.cpp", + "src/pin_auth.cpp", + "src/pin_auth_ui.cpp", + ] + + deps = [ + "${utils_path}:devicemanagerutils", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//utils/native/base:utils", + ] + + external_deps = [ + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "startup_l2:syspara", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"devicemanagerext\"", + "LOG_DOMAIN=0xD004100", + ] + + subsystem_name = "distributedhardware" + + part_name = "device_manager_base" + } +} diff --git a/ext/pin_auth/include/ability/dm_ability_manager.h b/ext/pin_auth/include/ability/dm_ability_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..225fefc6218fcd9c761be7cc5fd260fce4155e1d --- /dev/null +++ b/ext/pin_auth/include/ability/dm_ability_manager.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_DM_ABILITY_MANAGER_H +#define OHOS_DM_ABILITY_MANAGER_H + +#include + +#include +#include +#include + +namespace OHOS { +namespace DistributedHardware { +enum AbilityRole { ABILITY_ROLE_PASSIVE = 0, ABILITY_ROLE_INITIATIVE = 1, ABILITY_ROLE_UNKNOWN = 2 }; + +enum AbilityStatus { ABILITY_STATUS_FAILED = 0, ABILITY_STATUS_SUCCESS = 1, ABILITY_STATUS_START = 2 }; + +enum FaAction { + USER_OPERATION_TYPE_ALLOW_AUTH = 0, + USER_OPERATION_TYPE_CANCEL_AUTH = 1, + USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT = 2, + USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY = 3, + USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT = 4 +}; + +class DmAbilityManager { +public: + AbilityRole GetAbilityRole(); + AbilityStatus StartAbility(AbilityRole role); + void StartAbilityDone(); + +private: + void waitForTimeout(uint32_t timeout_s); + +private: + sem_t mSem_; + AbilityStatus mStatus_; + AbilityRole mAbilityStatus_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_ABILITY_MANAGER_H diff --git a/ext/pin_auth/include/pin_auth.h b/ext/pin_auth/include/pin_auth.h new file mode 100644 index 0000000000000000000000000000000000000000..2129c94a1a5cd949d018fdb30bcca668f5efc474 --- /dev/null +++ b/ext/pin_auth/include/pin_auth.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_DM_PIN_AUTH_H +#define OHOS_DM_PIN_AUTH_H + +#include +#include + +#include "authentication.h" +#include "dm_ability_manager.h" +#include "pin_auth_ui.h" + +namespace OHOS { +namespace DistributedHardware { +class PinAuth : public IAuthentication { +public: + PinAuth(); + ~PinAuth(); + int32_t ShowAuthInfo() override; + int32_t StartAuth(std::shared_ptr dmAbilityManager) override; + int32_t VerifyAuthentication(std::string pinToken, int32_t code, const std::string &authParam) override; + +private: + int32_t times_ = 0; + std::shared_ptr pinAuthUi_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_PIN_AUTH_H diff --git a/ext/pin_auth/include/pin_auth_ui.h b/ext/pin_auth/include/pin_auth_ui.h new file mode 100644 index 0000000000000000000000000000000000000000..f8910cba26fe134c29fd199449c8ba622da6018d --- /dev/null +++ b/ext/pin_auth/include/pin_auth_ui.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_DM_PIN_AUTH_UI_H +#define OHOS_DM_PIN_AUTH_UI_H + +#include + +#include "dm_ability_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class PinAuthUi { +public: + PinAuthUi(); + int32_t ShowPinDialog(); + int32_t InputPinDialog(std::shared_ptr dmAbilityManager); + +private: + int32_t StartFaUiService(std::shared_ptr dmAbilityManager); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_PIN_AUTH_UI_H diff --git a/ext/pin_auth/src/ability/lite/dm_ability_manager.cpp b/ext/pin_auth/src/ability/lite/dm_ability_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4511233054cf77cb9b67fbfe9e753b86725007c3 --- /dev/null +++ b/ext/pin_auth/src/ability/lite/dm_ability_manager.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 "dm_ability_manager.h" + +namespace OHOS { +namespace DistributedHardware { +AbilityRole DmAbilityManager::GetAbilityRole() +{ + return mAbilityStatus_; +} + +AbilityStatus DmAbilityManager::StartAbility(AbilityRole role) +{ + // not support for L1 yet, do nothing. just save status and role + mAbilityStatus_ = role; + mStatus_ = AbilityStatus::ABILITY_STATUS_SUCCESS; + return mStatus_; +} + +void DmAbilityManager::waitForTimeout(uint32_t timeout_s) +{ + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + ts.tv_sec += timeout_s; + sem_timedwait(&mSem_, &ts); +} + +void DmAbilityManager::StartAbilityDone() +{ + mStatus_ = AbilityStatus::ABILITY_STATUS_SUCCESS; + sem_post(&mSem_); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/ext/pin_auth/src/ability/standard/dm_ability_manager.cpp b/ext/pin_auth/src/ability/standard/dm_ability_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e2b026f1cab3f551dab8d12e5f645c5b8ad9a237 --- /dev/null +++ b/ext/pin_auth/src/ability/standard/dm_ability_manager.cpp @@ -0,0 +1,74 @@ +/* + * 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_ability_manager.h" + +#include "ability_manager_client.h" +#include "ability_manager_service.h" +#include "ability_record.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "parameter.h" +#include "semaphore.h" + +namespace OHOS { +namespace DistributedHardware { +namespace { +const int32_t ABILITY_START_TIMEOUT = 3; // 3 second +const std::string bundleUiName = "com.ohos.devicemanagerui"; +const std::string abilityUiName = "com.ohos.devicemanagerui.MainAbility"; +} // namespace + +AbilityRole DmAbilityManager::GetAbilityRole() +{ + return mAbilityStatus_; +} + +AbilityStatus DmAbilityManager::StartAbility(AbilityRole role) +{ + mAbilityStatus_ = role; + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + std::string deviceId = localDeviceId; + mStatus_ = ABILITY_STATUS_START; + AAFwk::Want want; + AppExecFwk::ElementName element(deviceId, bundleUiName, abilityUiName); + want.SetElement(element); + AAFwk::AbilityManagerClient::GetInstance()->Connect(); + ErrCode result = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want); + if (result != OHOS::ERR_OK) { + LOGE("Start Ability faild"); + mStatus_ = ABILITY_STATUS_FAILED; + return mStatus_; + } + waitForTimeout(ABILITY_START_TIMEOUT); + return mStatus_; +} + +void DmAbilityManager::waitForTimeout(uint32_t timeout_s) +{ + struct timespec ts; + clock_gettime(CLOCK_REALTIME, &ts); + ts.tv_sec += timeout_s; + sem_timedwait(&mSem_, &ts); +} + +void DmAbilityManager::StartAbilityDone() +{ + mStatus_ = ABILITY_STATUS_SUCCESS; + sem_post(&mSem_); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/ext/pin_auth/src/pin_auth.cpp b/ext/pin_auth/src/pin_auth.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5e123b0c550dc0f5b51059b318390dee00151e73 --- /dev/null +++ b/ext/pin_auth/src/pin_auth.cpp @@ -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. + */ + +#include "pin_auth.h" + +#include + +#include "dm_constants.h" +#include "dm_log.h" +#include "nlohmann/json.hpp" + +namespace OHOS { +namespace DistributedHardware { +const int32_t MAX_VERIFY_TIMES = 3; +PinAuth::PinAuth() +{ + LOGI("PinAuth constructor"); +} + +PinAuth::~PinAuth() +{ +} + +int32_t PinAuth::ShowAuthInfo() +{ + return pinAuthUi_->ShowPinDialog(); +} + +int32_t PinAuth::StartAuth(std::shared_ptr dmAbilityManager) +{ + times_ = 0; + return pinAuthUi_->InputPinDialog(dmAbilityManager); +} + +int32_t PinAuth::VerifyAuthentication(std::string pinToken, int32_t code, const std::string &authParam) +{ + times_ += 1; + nlohmann::json jsonObject = nlohmann::json::parse(authParam, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("DecodeRequestAuth jsonStr error"); + return DM_FAILED; + } + if (!jsonObject.contains(PIN_CODE_KEY) && !jsonObject.contains(PIN_TOKEN)) { + LOGE("err json string, first time"); + return DM_FAILED; + } + int32_t inputPinCode = jsonObject[PIN_CODE_KEY]; + int32_t inputPinToken = jsonObject[PIN_TOKEN]; + if (code == inputPinCode && stoi(pinToken) == inputPinToken) { + return DM_OK; + } else if (code != inputPinCode && times_ < MAX_VERIFY_TIMES) { + return DM_AUTH_INPUT_FAILED; + } else { + return DM_FAILED; + } +} + +extern "C" IAuthentication *CreatePinAuthObject(void) +{ + return new PinAuth; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/ext/pin_auth/src/pin_auth_ui.cpp b/ext/pin_auth/src/pin_auth_ui.cpp new file mode 100644 index 0000000000000000000000000000000000000000..15dd767ab0e8f131ec31534c4810684219c87ea5 --- /dev/null +++ b/ext/pin_auth/src/pin_auth_ui.cpp @@ -0,0 +1,54 @@ +/* + * 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 "pin_auth_ui.h" + +#include "dm_ability_manager.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { + +PinAuthUi::PinAuthUi() +{ + LOGI("AuthUi constructor"); +} + +int32_t PinAuthUi::ShowPinDialog() +{ + return DM_OK; +} + +int32_t PinAuthUi::InputPinDialog(std::shared_ptr dmAbilityManager) +{ + if (dmAbilityManager == nullptr) { + LOGE("PinAuthUi::dmAbilityManager is null"); + return DM_FAILED; + } + return StartFaUiService(dmAbilityManager); +} + +int32_t PinAuthUi::StartFaUiService(std::shared_ptr dmAbilityManager) +{ + AbilityStatus status = dmAbilityManager->StartAbility(AbilityRole::ABILITY_ROLE_INITIATIVE); + if (status != AbilityStatus::ABILITY_STATUS_SUCCESS) { + LOGE("PinAuthUi::StartFaService timeout"); + return DM_FAILED; + } + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/ext/profile/BUILD.gn b/ext/profile/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..552653a03c2077c3eea4b5b85534e18fc34c5e57 --- /dev/null +++ b/ext/profile/BUILD.gn @@ -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. + +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} + +import("//foundation/distributedhardware/devicemanager/devicemanager.gni") + +if (defined(ohos_lite)) { +} else { + ohos_shared_library("devicemanagerext_profile") { + include_dirs = [ + "include", + "${common_path}/include", + "${common_path}/include/ipc", + "${common_path}/include/ipc/model", + "${ext_path}/profile/include", + "${services_path}/include", + "${services_path}/include/adapter", + "${services_path}/include/dependency/softbus", + "${services_path}/include/ipc/standard", + "${services_path}/include/devicestate", + "${utils_path}/include", + "${utils_path}/include/ipc/standard", + "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/ipc", + "${innerkits_path}/native_cpp/include/ipc/standard", + "//foundation/communication/dsoftbus/interfaces/kits/bus_center", + "//foundation/communication/dsoftbus/interfaces/kits/common", + "//foundation/communication/dsoftbus/interfaces/kits/discovery", + "//foundation/communication/dsoftbus/interfaces/kits/transport", + "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", + ] + + sources = [ + "src/device_profile_adapter.cpp", + "src/profile_connector.cpp", + ] + + deps = [ + "${services_path}:devicemanagerservice", + "${utils_path}:devicemanagerutils", + "//utils/native/base:utils", + ] + + external_deps = [ + "device_profile_core:distributed_device_profile_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"devicemanagerext\"", + "LOG_DOMAIN=0xD004100", + ] + + subsystem_name = "distributedhardware" + + part_name = "device_manager_base" + } +} diff --git a/ext/profile/include/device_profile_adapter.h b/ext/profile/include/device_profile_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..d27b71fd0375ae56b9181df3f208e91862cee1fa --- /dev/null +++ b/ext/profile/include/device_profile_adapter.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_DM_ADAPTER_DEVICE_PROFILE_H +#define OHOS_DM_ADAPTER_DEVICE_PROFILE_H + +#include +#include + +#include "profile_adapter.h" +#include "profile_connector.h" + +namespace OHOS { +namespace DistributedHardware { +class DeviceProfileAdapter : public IProfileAdapter, public IProfileConnectorCallback { + +public: + DeviceProfileAdapter(); + ~DeviceProfileAdapter(); + int32_t RegisterProfileListener(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback); + int32_t UnRegisterProfileListener(const std::string &pkgName); + int32_t OnProfileClientDeviceReady(const std::string &pkgName, const std::string &deviceId); + void OnProfileChanged(const std::string &pkgName, const std::string &deviceId); + void OnProfileComplete(const std::string &pkgName, const std::string &deviceId); + +private: + std::shared_ptr deviceProfileAdapterCallback_; + static std::shared_ptr profileConnector_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_ADAPTER_DEVICE_PROFILE_H diff --git a/services/devicemanagerservice/include/ipc/ipc_server_adapter.h b/ext/profile/include/profile_connector.h similarity index 38% rename from services/devicemanagerservice/include/ipc/ipc_server_adapter.h rename to ext/profile/include/profile_connector.h index deec8bfeef5a3b54cb4be23625f6b43e8b51fa10..d83f90749172988bf2b9f64a2339ab2752a6ab72 100644 --- a/services/devicemanagerservice/include/ipc/ipc_server_adapter.h +++ b/ext/profile/include/profile_connector.h @@ -13,38 +13,44 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_ADAPTER_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_ADAPTER_H +#ifndef OHOS_DM_PROFILE_CONNECTOR_H +#define OHOS_DM_PROFILE_CONNECTOR_H +#include +#include +#include #include +#include -#include "dm_app_image_info.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" - -#include "hichain_connector.h" - +#include "distributed_device_profile_client.h" +#include "profile_connector_callback.h" #include "single_instance.h" -#include "softbus_adapter.h" namespace OHOS { namespace DistributedHardware { -class IpcServerAdapter { -DECLARE_SINGLE_INSTANCE(IpcServerAdapter); +using namespace OHOS::DeviceProfile; + +class ProfileEventCallback : public IProfileEventCallback { +public: + void OnSyncCompleted(const SyncResult &syncResults); + int32_t RegisterProfileCallback(const std::string &pkgName, std::shared_ptr callback); + int32_t UnRegisterProfileCallback(const std::string &pkgName); + 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); + static std::map> profileConnectorCallback_; +}; + +class ProfileConnector : public IProfileEventCallback { +public: + int32_t RegisterProfileCallback(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback); + int32_t UnRegisterProfileCallback(const std::string &pkgName); + int32_t SubscribeProfileEvents(const std::list &serviceIds, const std::string &deviceId); + int32_t UnSubscribeProfileEvents(); + private: - int32_t CheckParamValid(nlohmann::json &extraJson, const DmAppImageInfo &imageInfo); + static std::shared_ptr profileEventCallback_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_ADAPTER_H +#endif // OHOS_DM_PROFILE_CONNECTOR_H \ No newline at end of file diff --git a/utils/include/log/dm_log.h b/ext/profile/include/profile_connector_callback.h similarity index 65% rename from utils/include/log/dm_log.h rename to ext/profile/include/profile_connector_callback.h index 1db27040a36fc6ec7ba8285d0550be0256432300..70738fbfee2a1e1fbeb13b7cb233c386a46518fb 100644 --- a/utils/include/log/dm_log.h +++ b/ext/profile/include/profile_connector_callback.h @@ -13,19 +13,16 @@ * limitations under the License. */ -#ifndef OHOS_DM_LOG_H -#define OHOS_DM_LOG_H +#ifndef OHOS_DM_PROFILE_CONNECTOR_CALLBACK_H +#define OHOS_DM_PROFILE_CONNECTOR_CALLBACK_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, ...); +class IProfileConnectorCallback { +public: + virtual void OnProfileChanged(const std::string &pkgName, const std::string &deviceId) = 0; + virtual void OnProfileComplete(const std::string &pkgName, const std::string &deviceId) = 0; +}; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DM_LOG_H +#endif // OHOS_DM_PROFILE_CONNECTOR_CALLBACK_H \ No newline at end of file diff --git a/ext/profile/src/device_profile_adapter.cpp b/ext/profile/src/device_profile_adapter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..61d82e4925f9211eba990961152f3df1a8426926 --- /dev/null +++ b/ext/profile/src/device_profile_adapter.cpp @@ -0,0 +1,77 @@ +/* + * 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_profile_adapter.h" + +#include "dm_constants.h" +#include "dm_device_state_manager.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +std::shared_ptr DeviceProfileAdapter::profileConnector_ = std::make_shared(); + +DeviceProfileAdapter::DeviceProfileAdapter() +{ +} + +DeviceProfileAdapter::~DeviceProfileAdapter() +{ +} + +int32_t DeviceProfileAdapter::RegisterProfileListener(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback) +{ + LOGI("DeviceProfileAdapter::RegisterProfileListener"); + deviceProfileAdapterCallback_ = callback; + profileConnector_->RegisterProfileCallback(pkgName, deviceId, std::shared_ptr(this)); + return DM_OK; +} + +int32_t DeviceProfileAdapter::UnRegisterProfileListener(const std::string &pkgName) +{ + LOGI("DeviceProfileAdapter::RegisterProfileListener"); + deviceProfileAdapterCallback_ = nullptr; + profileConnector_->UnRegisterProfileCallback(pkgName); + return DM_OK; +} + +int32_t DeviceProfileAdapter::OnProfileClientDeviceReady(const std::string &pkgName, const std::string &deviceId) +{ + LOGI("DeviceProfileAdapter::OnProfileClientDeviceReady"); + if (nullptr != deviceProfileAdapterCallback_) { + deviceProfileAdapterCallback_->OnProfileReady(pkgName, deviceId); + } else { + LOGI("deviceProfileAdapterCallback_ is nullptr"); + } + return DM_OK; +} + +void DeviceProfileAdapter::OnProfileChanged(const std::string &pkgName, const std::string &deviceId) +{ + OnProfileClientDeviceReady(pkgName, deviceId); +} + +void DeviceProfileAdapter::OnProfileComplete(const std::string &pkgName, const std::string &deviceId) +{ + OnProfileClientDeviceReady(pkgName, deviceId); +} + +extern "C" IProfileAdapter *CreateDeviceProfileObject(void) +{ + return new DeviceProfileAdapter; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/ext/profile/src/profile_connector.cpp b/ext/profile/src/profile_connector.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a1a271064c04aaaf665821083fcd0d13849e4f04 --- /dev/null +++ b/ext/profile/src/profile_connector.cpp @@ -0,0 +1,106 @@ +/* + * 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 "profile_connector.h" + +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { + +std::map> ProfileEventCallback::profileConnectorCallback_ = {}; +std::shared_ptr ProfileConnector::profileEventCallback_ = + std::make_shared(); + +int32_t ProfileConnector::RegisterProfileCallback(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback) +{ + LOGI("ProfileConnector::RegisterProfileCallback"); + profileEventCallback_->RegisterProfileCallback(pkgName, callback); + SubscribeProfileEvents({"system", "device", "fakeStorage", "fakeSystem"}, deviceId); + return DM_OK; +} + +int32_t ProfileConnector::UnRegisterProfileCallback(const std::string &pkgName) +{ + LOGI("ProfileConnector::UnRegisterProfileCallback"); + profileEventCallback_->UnRegisterProfileCallback(pkgName); + return DM_OK; +} + +int32_t ProfileConnector::SubscribeProfileEvents(const std::list &serviceIds, const std::string &deviceId) +{ + ExtraInfo extraInfo; + extraInfo["deviceId"] = deviceId; + extraInfo["serviceIds"] = serviceIds; + + std::list subscribeInfos; + + SubscribeInfo eventSync; + eventSync.profileEvent = ProfileEvent::EVENT_SYNC_COMPLETED; + subscribeInfos.emplace_back(eventSync); + + std::list failedEvents; + u_int32_t errCode; + errCode = DistributedDeviceProfileClient::GetInstance().SubscribeProfileEvents(subscribeInfos, + profileEventCallback_, failedEvents); + LOGI("ProfileConnector::SubscribeProfileEvents result=%d", errCode); + return DM_OK; +} + +int32_t ProfileConnector::UnSubscribeProfileEvents() +{ + std::list profileEvents; + profileEvents.emplace_back(ProfileEvent::EVENT_PROFILE_CHANGED); + profileEvents.emplace_back(ProfileEvent::EVENT_SYNC_COMPLETED); + std::list failedEvents; + u_int32_t errCode; + errCode = DistributedDeviceProfileClient::GetInstance().UnsubscribeProfileEvents( + profileEvents, profileEventCallback_, failedEvents); + LOGI("ProfileConnector::UnSubscribeProfileEvents result=%d", errCode); + return DM_OK; +} + +int32_t ProfileEventCallback::RegisterProfileCallback(const std::string &pkgName, + std::shared_ptr callback) +{ + LOGI("ProfileEventCallback::RegisterProfileCallback"); + profileConnectorCallback_.emplace(pkgName, callback); + return DM_OK; +} + +int32_t ProfileEventCallback::UnRegisterProfileCallback(const std::string &pkgName) +{ + LOGI("ProfileEventCallback::UnRegisterProfileCallback"); + profileConnectorCallback_.erase(pkgName); + return DM_OK; +} + +void ProfileEventCallback::OnSyncCompleted(const SyncResult &syncResults) +{ + std::string deviceId; + u_int32_t SyncStatus; + for (auto &iterResult : syncResults) { + deviceId = iterResult.first; + SyncStatus = iterResult.second; + } + LOGI("ProfileEventCallback::OnSyncCompleted, deviceId = %s", deviceId.c_str()); + for (auto &iter : profileConnectorCallback_) { + iter.second->OnProfileComplete(iter.first, deviceId); + } +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn index 2903afc98ca439d4afdc1314540806a5b77ff1c4..302fbe79db5513410338e5b502d31b0a72be7d64 100644 --- a/interfaces/inner_kits/native_cpp/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/BUILD.gn @@ -20,68 +20,24 @@ import("//foundation/distributedhardware/devicemanager/devicemanager.gni") if (defined(ohos_lite)) { shared_library("devicemanagersdk") { - include_dirs = [ - "include", - "include/ipc", - "include/ipc/lite", - "include/notify", - "${utils_path}/include/log", - "${utils_path}/include/ipc/lite", - "${common_path}/include/ipc", - "${common_path}/include/ipc/model", - "${common_path}/include", - ] - include_dirs += [ - "//utils/native/lite/include", - "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits/hilog", - "//third_party/bounds_checking_function/include", - "//foundation/communication/ipc_lite/interfaces/kits", - "//foundation/distributedschedule/samgr_lite/interfaces/kits/samgr", - "//third_party/json/include", - ] - - sources = [ - "src/device_manager.cpp", - "src/device_manager_impl.cpp", - "src/ipc/ipc_client_proxy.cpp", - "src/ipc/lite/ipc_client_manager.cpp", - "src/ipc/lite/ipc_client_server_proxy.cpp", - "src/ipc/lite/ipc_client_stub.cpp", - "src/ipc/lite/ipc_cmd_parser.cpp", - "src/notify/device_manager_notify.cpp", - ] - - defines = [ - "LITE_DEVICE", - "HI_LOG_ENABLE", - "DH_LOG_TAG=\"devicemanagerkit\"", - "LOG_DOMAIN=0xD004100", - ] - - deps = [ - "${utils_path}:devicemanagerutils", - "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", - "//foundation/communication/ipc_lite:liteipc_adapter", - "//foundation/distributedschedule/samgr_lite/samgr:samgr", - "//third_party/bounds_checking_function:libsec_shared", - "//utils/native/lite:utils", - ] } } else { ohos_shared_library("devicemanagersdk") { include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", "include", - "include/ipc/standard", "include/ipc", + "include/ipc/standard", "include/notify", - "${utils_path}/include/log", + "${common_path}/include", "${common_path}/include/ipc", "${common_path}/include/ipc/model", + "${utils_path}/include", "${utils_path}/include/ipc/standard", - "${common_path}/include", "//third_party/json/include", + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_base/include", + "//foundation/appexecfwk/standard/interfaces/innerkits/appexecfwk_core/include/bundlemgr", ] sources = [ @@ -97,6 +53,7 @@ if (defined(ohos_lite)) { deps = [ "${utils_path}:devicemanagerutils", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", "//utils/native/base:utils", ] diff --git a/interfaces/inner_kits/native_cpp/include/device_manager.h b/interfaces/inner_kits/native_cpp/include/device_manager.h index 060fe2df84dc9751ed456cd4e37333945d48b4fd..9e76a136103750e228535c364432533b4e55de33 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager.h +++ b/interfaces/inner_kits/native_cpp/include/device_manager.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,43 +13,48 @@ * limitations under the License. */ -#ifndef DEVICE_MANAGER_H -#define DEVICE_MANAGER_H +#ifndef OHOS_DEVICE_MANAGER_H +#define OHOS_DEVICE_MANAGER_H -#include -#include #include +#include +#include #include "device_manager_callback.h" +#include "dm_device_info.h" #include "dm_subscribe_info.h" -#include "dm_app_image_info.h" namespace OHOS { namespace DistributedHardware { class DeviceManager { public: static DeviceManager &GetInstance(); + public: - virtual int32_t InitDeviceManager(std::string &pkgName, std::shared_ptr dmInitCallback) = 0; - virtual int32_t UnInitDeviceManager(std::string &pkgName) = 0; - virtual int32_t GetTrustedDeviceList(std::string &pkgName, std::string &extra, - std::vector &deviceList) = 0; - virtual int32_t RegisterDevStateCallback(std::string &pkgName, std::string &extra, - std::shared_ptr callback) = 0; - virtual int32_t UnRegisterDevStateCallback(std::string &pkgName) = 0; - virtual int32_t StartDeviceDiscovery(std::string &pkgName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback) = 0; - virtual int32_t StopDeviceDiscovery(std::string &pkgName, uint16_t subscribeId) = 0; - virtual int32_t AuthenticateDevice(std::string &pkgName, const DmDeviceInfo &deviceInfo, - const DmAppImageInfo &imageInfo, std::string &extra, std::shared_ptr callback) = 0; - virtual int32_t CheckAuthentication(std::string &pkgName, std::string &authPara, - std::shared_ptr callback) = 0; - virtual int32_t GetAuthenticationParam(std::string &pkgName, DmAuthParam &authParam) = 0; - virtual int32_t SetUserOperation(std::string &pkgName, int32_t action) = 0; - virtual int32_t RegisterDeviceManagerFaCallback(std::string &packageName, - std::shared_ptr callback) = 0; - virtual int32_t UnRegisterDeviceManagerFaCallback(std::string &pkgName) = 0; + virtual int32_t InitDeviceManager(const std::string &pkgName, std::shared_ptr dmInitCallback) = 0; + virtual int32_t UnInitDeviceManager(const std::string &pkgName) = 0; + virtual int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList) = 0; + virtual int32_t GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &deviceInfo) = 0; + virtual int32_t RegisterDevStateCallback(const std::string &pkgName, const std::string &extra, + std::shared_ptr callback) = 0; + virtual int32_t UnRegisterDevStateCallback(const std::string &pkgName) = 0; + virtual int32_t StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra, std::shared_ptr callback) = 0; + virtual int32_t StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId) = 0; + virtual int32_t AuthenticateDevice(const std::string &pkgName, int32_t authType, const DmDeviceInfo &deviceInfo, + const std::string &extra, std::shared_ptr callback) = 0; + virtual int32_t UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId) = 0; + virtual int32_t VerifyAuthentication(const std::string &pkgName, const std::string &authPara, + std::shared_ptr callback) = 0; + virtual int32_t RegisterDeviceManagerFaCallback(const std::string &pkgName, + std::shared_ptr callback) = 0; + virtual int32_t UnRegisterDeviceManagerFaCallback(const std::string &pkgName) = 0; + virtual int32_t GetFaParam(const std::string &pkgName, DmAuthParam &faParam) = 0; + virtual int32_t SetUserOperation(const std::string &pkgName, int32_t action) = 0; + virtual int32_t GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &udid) = 0; + virtual int32_t GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &uuid) = 0; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_H +#endif // DEVICE_MANAGER_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h b/interfaces/inner_kits/native_cpp/include/device_manager_callback.h index 786e8ca850fc4f068c007bfa59dd0a9a664009ca..f175f2344d7e95d5829510acb3b98fd9be1bb8b7 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h +++ b/interfaces/inner_kits/native_cpp/include/device_manager_callback.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_CALLBACK_H -#define OHOS_DEVICE_MANAGER_CALLBACK_H +#ifndef OHOS_DM_CALLBACK_H +#define OHOS_DM_CALLBACK_H #include #include @@ -25,44 +25,56 @@ namespace OHOS { namespace DistributedHardware { class DmInitCallback { public: - virtual ~DmInitCallback() {} + virtual ~DmInitCallback() + { + } virtual void OnRemoteDied() = 0; }; class DeviceStateCallback { public: - virtual ~DeviceStateCallback() {} + 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; + virtual void OnDeviceReady(const DmDeviceInfo &deviceInfo) = 0; }; -class DiscoverCallback { +class DiscoveryCallback { public: - virtual ~DiscoverCallback() {} + virtual ~DiscoveryCallback() + { + } virtual void OnDiscoverySuccess(uint16_t subscribeId) = 0; - virtual void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) = 0; + virtual void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) = 0; virtual void OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) = 0; }; class AuthenticateCallback { public: - virtual ~AuthenticateCallback() {} - virtual void OnAuthResult(std::string &deviceId, int32_t pinToken, int32_t status, int32_t reason) = 0; + virtual ~AuthenticateCallback() + { + } + virtual void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, + int32_t reason) = 0; }; -class CheckAuthCallback { +class VerifyAuthCallback { public: - virtual ~CheckAuthCallback() {} - virtual void OnCheckAuthResult(std::string &deviceId, int32_t resultCode, int32_t flag) = 0; + virtual ~VerifyAuthCallback() + { + } + virtual void OnVerifyAuthResult(const std::string &deviceId, int32_t resultCode, int32_t flag) = 0; }; - class DeviceManagerFaCallback { public: - virtual ~DeviceManagerFaCallback() {} - virtual void OnCall(std::string ¶mJson) = 0; + virtual ~DeviceManagerFaCallback() + { + } + virtual void OnCall(const std::string ¶mJson) = 0; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_CALLBACK_H +#endif // OHOS_DM_CALLBACK_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h index 8e46f12fbdc37183b413d657298d81731a5e8555..46d8c3222c242a4e50e3d987e67de17c24e3c86d 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h +++ b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -16,41 +16,57 @@ #ifndef OHOS_DEVICE_MANAGER_IMPL_H #define OHOS_DEVICE_MANAGER_IMPL_H -#include - #include "device_manager.h" - -#include "ipc_client_proxy.h" #include "ipc_client_manager.h" - -#include "single_instance.h" +#include "ipc_client_proxy.h" namespace OHOS { namespace DistributedHardware { class DeviceManagerImpl : public DeviceManager { -DECLARE_SINGLE_INSTANCE(DeviceManagerImpl); public: - virtual int32_t InitDeviceManager(std::string &pkgName, - std::shared_ptr dmInitCallback) override; - virtual int32_t UnInitDeviceManager(std::string &pkgName) override; - virtual int32_t GetTrustedDeviceList(std::string &pkgName, std::string &extra, - std::vector &deviceList) override; - virtual int32_t RegisterDevStateCallback(std::string &pkgName, std::string &extra, - std::shared_ptr callback) override; - virtual int32_t UnRegisterDevStateCallback(std::string &pkgName) override; - virtual int32_t StartDeviceDiscovery(std::string &pkgName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback) override; - virtual int32_t StopDeviceDiscovery(std::string &pkgName, uint16_t subscribeId) override; - virtual int32_t AuthenticateDevice(std::string &pkgName, const DmDeviceInfo &deviceInfo, - const DmAppImageInfo &imageInfo, std::string &extra, - std::shared_ptr callback) override; - virtual int32_t CheckAuthentication(std::string &pkgName, std::string &authPara, - std::shared_ptr callback) override; - virtual int32_t GetAuthenticationParam(std::string &pkgName, DmAuthParam &authParam) override; - virtual int32_t SetUserOperation(std::string &pkgName, int32_t action) override; - virtual int32_t RegisterDeviceManagerFaCallback(std::string &packageName, - std::shared_ptr callback) override; - virtual int32_t UnRegisterDeviceManagerFaCallback(std::string &pkgName) override; + static DeviceManagerImpl &GetInstance(); + +public: + virtual int32_t InitDeviceManager(const std::string &pkgName, + std::shared_ptr dmInitCallback) override; + virtual int32_t UnInitDeviceManager(const std::string &pkgName) override; + virtual int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList) override; + virtual int32_t GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &deviceInfo) override; + virtual int32_t RegisterDevStateCallback(const std::string &pkgName, const std::string &extra, + std::shared_ptr callback) override; + virtual int32_t UnRegisterDevStateCallback(const std::string &pkgName) override; + virtual int32_t StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra, + std::shared_ptr callback) override; + virtual int32_t StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId) override; + virtual int32_t AuthenticateDevice(const std::string &pkgName, int32_t authType, const DmDeviceInfo &deviceInfo, + const std::string &extra, + std::shared_ptr callback) override; + virtual int32_t UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId) override; + virtual int32_t VerifyAuthentication(const std::string &pkgName, const std::string &authPara, + std::shared_ptr callback) override; + virtual int32_t RegisterDeviceManagerFaCallback(const std::string &packageName, + std::shared_ptr callback) override; + virtual int32_t UnRegisterDeviceManagerFaCallback(const std::string &pkgName) override; + virtual int32_t GetFaParam(const std::string &pkgName, DmAuthParam &faParam) override; + virtual int32_t SetUserOperation(const std::string &pkgName, int32_t action) override; + virtual int32_t GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId, + std::string &udid) override; + virtual int32_t GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, + std::string &uuid) override; + +private: + DeviceManagerImpl() = default; + ~DeviceManagerImpl() = default; + DeviceManagerImpl(const DeviceManagerImpl &) = delete; + DeviceManagerImpl &operator=(const DeviceManagerImpl &) = delete; + DeviceManagerImpl(DeviceManagerImpl &&) = delete; + DeviceManagerImpl &operator=(DeviceManagerImpl &&) = delete; + +private: + bool isSystemAppCalling(void); + private: std::shared_ptr ipcClientProxy_ = std::make_shared(std::make_shared()); diff --git a/interfaces/inner_kits/native_cpp/include/dm_app_image_info.h b/interfaces/inner_kits/native_cpp/include/dm_app_image_info.h index 9fbccd7d6e79d7d79ff691a87a8bf58ed9b8eca3..91636af6ebfe813f82ac0d269f195f70eea7dec8 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_app_image_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_app_image_info.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_APP_IMAGE_INFO_H -#define OHOS_DEVICE_MANAGER_APP_IMAGE_INFO_H +#ifndef OHOS_DM_APP_IMAGE_INFO_H +#define OHOS_DM_APP_IMAGE_INFO_H #include @@ -48,7 +48,7 @@ public: return; } - appThumbnail = new (std::nothrow) uint8_t[appThumbnailLen_] {0}; + appThumbnail = new (std::nothrow) uint8_t[appThumbnailLen_]{0}; if (appThumbnail != nullptr) { appThumbnailLen = appThumbnailLen_; } @@ -56,7 +56,7 @@ public: int32_t SetThumbnailData(uint8_t *srcBuffer, int32_t srcBufferLen, int32_t copyIndex, int32_t copyLen) { - if (srcBuffer == nullptr || srcBufferLen <= 0 || copyLen > srcBufferLen || copyIndex < 0) { + if (srcBuffer == nullptr || srcBufferLen <= 0 || copyLen > srcBufferLen || copyIndex < 0) { return -1; } @@ -94,7 +94,7 @@ public: } } - DmAppImageInfo& operator=(const DmAppImageInfo &other) + DmAppImageInfo &operator=(const DmAppImageInfo &other) { if (this != &other) { SaveData(other.GetAppIcon(), other.GetAppIconLen(), other.GetAppThumbnail(), other.GetAppThumbnailLen()); @@ -102,8 +102,8 @@ public: return *this; } - DmAppImageInfo(DmAppImageInfo&&) = delete; - DmAppImageInfo& operator=(DmAppImageInfo&&) = delete; + DmAppImageInfo(DmAppImageInfo &&) = delete; + DmAppImageInfo &operator=(DmAppImageInfo &&) = delete; int32_t GetAppIconLen() const { @@ -124,6 +124,7 @@ public: { return appThumbnail; } + private: void SaveData(const uint8_t *appIcon_, int32_t appIconLen_, const uint8_t *appThumbnail_, int32_t appThumbnailLen_) { @@ -140,7 +141,7 @@ private: appIcon = nullptr; appIconLen = 0; } - appIcon = new (std::nothrow) uint8_t[appIconLen_] {0}; + appIcon = new (std::nothrow) uint8_t[appIconLen_]{0}; } if (appIcon != nullptr) { appIconLen = appIconLen_; @@ -160,7 +161,7 @@ private: appThumbnail = nullptr; appThumbnailLen = 0; } - appThumbnail = new (std::nothrow) uint8_t[appThumbnailLen_] {0}; + appThumbnail = new (std::nothrow) uint8_t[appThumbnailLen_]{0}; } if (appThumbnail != nullptr) { appThumbnailLen = appThumbnailLen_; @@ -170,14 +171,15 @@ private: } } } + private: - int32_t appIconLen {0}; - uint8_t *appIcon {nullptr}; - int32_t appThumbnailLen {0}; - uint8_t *appThumbnail {nullptr}; + int32_t appIconLen{0}; + uint8_t *appIcon{nullptr}; + int32_t appThumbnailLen{0}; + uint8_t *appThumbnail{nullptr}; const int32_t ICON_MAX_LEN = 32 * 1024; const int32_t THUMB_MAX_LEN = 153 * 1024; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_APP_IMAGE_INFO_H +#endif // OHOS_DM_APP_IMAGE_INFO_H diff --git a/interfaces/inner_kits/native_cpp/include/dm_device_info.h b/interfaces/inner_kits/native_cpp/include/dm_device_info.h index 2e084e7495475ca74f23dea6db044e8a831cded3..88be8a13444f39fad61bdfe2188824ecc5771c21 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_device_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_device_info.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_DEVICE_INFO_H -#define OHOS_DEVICE_MANAGER_DEVICE_INFO_H +#ifndef OHOS_DM_DEVICE_INFO_H +#define OHOS_DM_DEVICE_INFO_H #include @@ -25,31 +25,34 @@ namespace OHOS { namespace DistributedHardware { -typedef enum DMDeviceType { +typedef enum DmDeviceType { 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, -} DMDeviceType; +} DmDeviceType; typedef enum DmDeviceState { DEVICE_STATE_UNKNOWN = 0, DEVICE_STATE_ONLINE = 1, DEVICE_STATE_OFFLINE = 2, DEVICE_INFO_CHANGED = 3, + DEVICE_INFO_READY = 4, } DmDeviceState; typedef struct DmDeviceInfo { char deviceId[DM_MAX_DEVICE_ID_LEN]; char deviceName[DM_MAX_DEVICE_NAME_LEN]; - DMDeviceType deviceTypeId; + uint16_t deviceTypeId; } DmDeviceInfo; typedef struct DmAuthParam { + std::string authToken; std::string packageName; std::string appName; std::string appDescription; @@ -60,6 +63,7 @@ typedef struct DmAuthParam { int32_t pinToken; DmAppImageInfo imageinfo; } DmAuthParam; + } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_DEVICE_INFO_H +#endif // OHOS_DM_DEVICE_INFO_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 index 2101c59e5318192449c7ac89315f7e78ae2d8428..87561c4e8ab206e00abfa94c37ad2facfb606df7 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H -#define OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H +#ifndef OHOS_DM_SUBSCRIBE_INFO_H +#define OHOS_DM_SUBSCRIBE_INFO_H #include @@ -26,7 +26,7 @@ typedef enum DmDiscoverMode { /* Passive */ DM_DISCOVER_MODE_PASSIVE = 0x55, /* Proactive */ - DM_DISCOVER_MODE_ACTIVE = 0xAA + DM_DISCOVER_MODE_ACTIVE = 0xAA } DmDiscoverMode; typedef enum DmExchangeMedium { @@ -76,4 +76,4 @@ typedef struct DmSubscribeInfo { } DmSubscribeInfo; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H +#endif // OHOS_DM_SUBSCRIBE_INFO_H diff --git a/interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h index 818746ff706afecb07f5aa8e9252cb2c72d21351..85ee63e9cd70e589913e3dd40c8b80ff6e58c4ea 100644 --- a/interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h +++ b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,12 +13,12 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_H +#ifndef OHOS_DM_IPC_CLIENT_H +#define OHOS_DM_IPC_CLIENT_H #include -#include #include +#include #include "ipc_req.h" #include "ipc_rsp.h" @@ -26,12 +26,13 @@ namespace OHOS { namespace DistributedHardware { class IpcClient { -DECLARE_IPC_INTERFACE(IpcClient); + DECLARE_IPC_INTERFACE(IpcClient); + public: - virtual int32_t Init(std::string &pkgName) = 0; - virtual int32_t UnInit(std::string &pkgName) = 0; + virtual int32_t Init(const std::string &pkgName) = 0; + virtual int32_t UnInit(const std::string &pkgName) = 0; virtual int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) = 0; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_H \ No newline at end of file +#endif // OHOS_DM_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 index faa9e1a4b722295fb320e22574b84b00372308ed..7571f01886e3c0447e54cee3f107a83471dd554b 100644 --- a/interfaces/inner_kits/native_cpp/include/ipc/ipc_client_proxy.h +++ b/interfaces/inner_kits/native_cpp/include/ipc/ipc_client_proxy.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_PROXY_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_PROXY_H +#ifndef OHOS_DM_IPC_CLIENT_PROXY_H +#define OHOS_DM_IPC_CLIENT_PROXY_H #include #include @@ -26,16 +26,19 @@ namespace OHOS { namespace DistributedHardware { class IpcClientProxy : public IpcClient { -DECLARE_IPC_INTERFACE(IpcClientProxy); + DECLARE_IPC_INTERFACE(IpcClientProxy); + public: - IpcClientProxy(std::shared_ptr ipcClientManager) : ipcClientManager_(ipcClientManager) {}; + 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 Init(const std::string &pkgName); + virtual int32_t UnInit(const std::string &pkgName); virtual int32_t SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp); + private: - std::shared_ptr ipcClientManager_ {nullptr}; + std::shared_ptr ipcClientManager_{nullptr}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_PROXY_H \ No newline at end of file +#endif // OHOS_DM_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 index 997b5d39b8c9367682ae7c2583a83d544e74300b..2142ffad97527fee72b71e97271f401d8474b897 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,12 +13,12 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H +#ifndef OHOS_DM_IPC_CLIENT_MANAGER_H +#define OHOS_DM_IPC_CLIENT_MANAGER_H #include -#include #include +#include #include "ipc_client.h" #include "ipc_client_server_proxy.h" @@ -26,17 +26,20 @@ namespace OHOS { namespace DistributedHardware { class IpcClientManager : public IpcClient { -DECLARE_IPC_INTERFACE(IpcClientManager); + DECLARE_IPC_INTERFACE(IpcClientManager); + public: - virtual int32_t Init(std::string &pkgName) override; - virtual int32_t UnInit(std::string &pkgName) override; + virtual int32_t Init(const std::string &pkgName) override; + virtual int32_t UnInit(const 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); + bool IsInit(const 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 +#endif // OHOS_DM_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 index d7497c55c286c50527abfd7c47bb9d15174c6250..29cf5c71dc8bc4e4ae8b540aa4cda0673aab518c 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,33 +13,34 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H +#ifndef OHOS_DM_IPC_CLIENT_SERVER_PROXY_H +#define OHOS_DM_IPC_CLIENT_SERVER_PROXY_H #include #include #include +#include "ipc_req.h" +#include "ipc_rsp.h" #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}; + IClientProxy *serviceProxy_{nullptr}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H +#endif // OHOS_DM_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 index 672e4cb89448ed197a0fb7fac58e090c07f6ee17..caec91608a272898be93009a6ebff71f304e5569 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,31 +13,32 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H +#ifndef OHOS_DM_IPC_CLIENT_STUB_H +#define OHOS_DM_IPC_CLIENT_STUB_H -#include #include +#include #include "liteipc_adapter.h" - #include "single_instance.h" namespace OHOS { namespace DistributedHardware { class IpcClientStub { -DECLARE_SINGLE_INSTANCE(IpcClientStub); + DECLARE_SINGLE_INSTANCE(IpcClientStub); + public: int32_t Init(); SvcIdentity GetSvcIdentity() const { return clientIdentity_; } + private: std::mutex lock_; - bool bInit {false}; + bool bInit{false}; SvcIdentity clientIdentity_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H +#endif // OHOS_DM_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 index 422f297282afc35b65b94217e27c25acf0845426..058f74423c2db9fafe3eec44028ebf6c180f015a 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,20 +13,19 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H +#ifndef OHOS_DM_IPC_CLIENT_MANAGER_H +#define OHOS_DM_IPC_CLIENT_MANAGER_H #include -#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" +#include "iremote_object.h" namespace OHOS { namespace DistributedHardware { @@ -38,21 +37,24 @@ public: }; class IpcClientManager : public IpcClient { -friend class DmDeathRecipient; -DECLARE_IPC_INTERFACE(IpcClientManager); + 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 Init(const std::string &pkgName) override; + virtual int32_t UnInit(const 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); + bool IsInit(const std::string &pkgName); int32_t ClientInit(); + private: std::mutex lock_; std::map> dmListener_; - sptr dmInterface_ {nullptr}; - sptr dmRecipient_ {nullptr}; + sptr dmInterface_{nullptr}; + sptr dmRecipient_{nullptr}; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CLIENT_MANAGER_H \ No newline at end of file +#endif // OHOS_DM_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 index 3fd0586cd487e6a95ce9594aa1f5d371d7cf8358..dce3c3ddc0f265046e6bb83af50364f496b2cff1 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,27 +13,28 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_SERVER_PROXY_H +#ifndef OHOS_DM_IPC_CLIENT_SERVER_PROXY_H +#define OHOS_DM_IPC_CLIENT_SERVER_PROXY_H #include #include -#include "iremote_proxy.h" #include "ipc_remote_broker.h" #include "ipc_req.h" #include "ipc_rsp.h" +#include "iremote_proxy.h" namespace OHOS { namespace DistributedHardware { class IpcClientServerProxy : public IRemoteProxy { public: - explicit IpcClientServerProxy(const sptr &impl) : IRemoteProxy(impl) {}; - ~IpcClientServerProxy() {}; + 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 +#endif // OHOS_DM_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 index 61633f6e8db4bcaeba23b3d3e0e14b663f0ea595..ccb4e0b7a99dece2f5d60667220038b2c063ec0d 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,28 +13,27 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H -#define OHOS_DEVICE_MANAGER_IPC_CLIENT_STUB_H +#ifndef OHOS_DM_IPC_CLIENT_STUB_H +#define OHOS_DM_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" +#include "iremote_broker.h" +#include "iremote_stub.h" namespace OHOS { namespace DistributedHardware { class IpcClientStub : public IRemoteStub { public: - IpcClientStub() {}; - ~IpcClientStub() {}; + 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 +#endif // OHOS_DM_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 index b2b8618c7e2f32cfce0f7069e32f8dbdf3472ad1..ce5ded9cffee889bbe6952d028c13171247b3075 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,26 +13,28 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_REMOTE_BROKER_H -#define OHOS_DEVICE_MANAGER_IPC_REMOTE_BROKER_H +#ifndef OHOS_DM_IPC_REMOTE_BROKER_H +#define OHOS_DM_IPC_REMOTE_BROKER_H #include #include -#include "iremote_broker.h" - #include "ipc_req.h" #include "ipc_rsp.h" +#include "iremote_broker.h" namespace OHOS { namespace DistributedHardware { class IpcRemoteBroker : public OHOS::IRemoteBroker { public: - virtual ~IpcRemoteBroker() {} + 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 +#endif // OHOS_DM_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 index a654b55368accbcb12cd06eb30409c32d9f5d701..2f882bb120d358236e186089d68bf6a0426d950d 100644 --- a/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h +++ b/interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,63 +13,66 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_NOTIFY_H -#define OHOS_DEVICE_MANAGER_NOTIFY_H +#ifndef OHOS_DM_NOTIFY_H +#define OHOS_DM_NOTIFY_H -#include #include -#include -#include #include +#include +#include +#include +#include "device_manager_callback.h" #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); + 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); + void RegisterDeathRecipientCallback(const std::string &pkgName, std::shared_ptr dmInitCallback); + void UnRegisterDeathRecipientCallback(const std::string &pkgName); + void RegisterDeviceStateCallback(const std::string &pkgName, std::shared_ptr callback); + void UnRegisterDeviceStateCallback(const std::string &pkgName); + void RegisterDiscoveryCallback(const std::string &pkgName, uint16_t subscribeId, + std::shared_ptr callback); + void UnRegisterDiscoveryCallback(const std::string &pkgName, uint16_t subscribeId); + void RegisterAuthenticateCallback(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback); + void UnRegisterAuthenticateCallback(const std::string &pkgName, const std::string &deviceId); + void UnRegisterPackageCallback(const std::string &pkgName); + void RegisterVerifyAuthenticationCallback(const std::string &pkgName, const std::string &authPara, + std::shared_ptr callback); + void UnRegisterVerifyAuthenticationCallback(const std::string &pkgName); + void RegisterDeviceManagerFaCallback(const std::string &pkgName, std::shared_ptr callback); + void UnRegisterDeviceManagerFaCallback(const 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 OnDeviceOnline(const std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceOffline(const std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceChanged(const std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceReady(const std::string &pkgName, const DmDeviceInfo &deviceInfo); + void OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo); + void OnDiscoveryFailed(const std::string &pkgName, uint16_t subscribeId, int32_t failedReason); + void OnDiscoverySuccess(const std::string &pkgName, uint16_t subscribeId); + void OnAuthResult(const std::string &pkgName, const std::string &deviceId, const std::string &token, + uint32_t status, uint32_t reason); + void OnVerifyAuthResult(const std::string &pkgName, const 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>> deviceDiscoveryCallbacks_; std::map>> authenticateCallback_; - std::map> checkauthcallback_; + std::map> verifyAuthCallback_; std::map> dmInitCallback_; std::map> dmFaCallback_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_NOTIFY_H +#endif // OHOS_DM_NOTIFY_H diff --git a/interfaces/inner_kits/native_cpp/src/device_manager.cpp b/interfaces/inner_kits/native_cpp/src/device_manager.cpp index 4bedc0a57c5f4e940be45cea53e9c6db7b95a1f7..0e934d8d285278adf5029e144720e7c8ffe06be4 100644 --- a/interfaces/inner_kits/native_cpp/src/device_manager.cpp +++ b/interfaces/inner_kits/native_cpp/src/device_manager.cpp @@ -4,7 +4,7 @@ * 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 + * 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, diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp index 23f7ef2c60018e58df54eabd24d6d97da557daab..efb536dbbac8702c08c0abe4d7949cb374c64cd9 100644 --- a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp +++ b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,279 +15,521 @@ #include "device_manager_impl.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" -#include "device_manager_notify.h" -#include "constants.h" +#include "bundle_constants.h" +#include "bundle_info.h" +#include "bundle_mgr_client.h" +#include "bundle_mgr_interface.h" +#include "if_system_ability_manager.h" +#include "iservice_registry.h" +#include "system_ability_definition.h" +#include "device_manager_notify.h" +#include "dm_constants.h" +#include "dm_log.h" #include "ipc_authenticate_device_req.h" -#include "ipc_check_authenticate_req.h" +#include "ipc_get_dmfaparam_rsp.h" +#include "ipc_get_info_by_network_req.h" +#include "ipc_get_info_by_network_rsp.h" +#include "ipc_get_local_device_info_rsp.h" #include "ipc_get_trustdevice_req.h" #include "ipc_get_trustdevice_rsp.h" -#include "ipc_rsp.h" #include "ipc_req.h" +#include "ipc_rsp.h" +#include "ipc_set_useroperation_req.h" +#include "ipc_skeleton.h" #include "ipc_start_discovery_req.h" #include "ipc_stop_discovery_req.h" -#include "ipc_get_authenticationparam_rsp.h" -#include "ipc_set_useroperation_req.h" +#include "ipc_unauthenticate_device_req.h" +#include "ipc_verify_authenticate_req.h" + +using namespace OHOS::AppExecFwk; +using namespace OHOS::AppExecFwk::Constants; namespace OHOS { namespace DistributedHardware { -IMPLEMENT_SINGLE_INSTANCE(DeviceManagerImpl); +bool DeviceManagerImpl::isSystemAppCalling(void) +{ + int32_t uid = IPCSkeleton::GetCallingUid(); + if (uid < 0) { + LOGI("app caller uid is: %d,", uid); + return false; + } + + sptr systemAbilityManager = + SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + if (systemAbilityManager == nullptr) { + LOGE("failed to get system ability mgr."); + return false; + } + + sptr remoteObject = + systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID); + if (remoteObject == nullptr) { + LOGE("failed to get bundle manager proxy."); + return false; + } -int32_t DeviceManagerImpl::InitDeviceManager(std::string &pkgName, std::shared_ptr dmInitCallback) + LOGI("get bundle manager proxy success."); + sptr iBundleMgr = iface_cast(remoteObject); + return iBundleMgr->CheckIsSystemAppByUid(uid); +} + +DeviceManagerImpl &DeviceManagerImpl::GetInstance() { - DMLOG(DM_LOG_INFO, "DeviceManager::InitDeviceManager start, pkgName: %s", pkgName.c_str()); + static DeviceManagerImpl instance; + return instance; +} + +int32_t DeviceManagerImpl::InitDeviceManager(const std::string &pkgName, std::shared_ptr dmInitCallback) +{ + LOGI("DeviceManager::InitDeviceManager start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty() || dmInitCallback == nullptr) { - DMLOG(DM_LOG_ERROR, "InitDeviceManager error: Invalid parameter"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("InitDeviceManager error: Invalid parameter"); + return DM_INVALID_VALUE; } int32_t ret = ipcClientProxy_->Init(pkgName); - if (ret != DEVICEMANAGER_OK) { - return ret; + if (ret != DM_OK) { + LOGE("InitDeviceManager error: proxy init failed ret: %d", ret); + return DM_INIT_FAILED; } + DeviceManagerNotify::GetInstance().RegisterDeathRecipientCallback(pkgName, dmInitCallback); - DMLOG(DM_LOG_INFO, "success"); - return DEVICEMANAGER_OK; + LOGI("InitDeviceManager success"); + return DM_OK; } -int32_t DeviceManagerImpl::UnInitDeviceManager(std::string &pkgName) +int32_t DeviceManagerImpl::UnInitDeviceManager(const std::string &pkgName) { - DMLOG(DM_LOG_INFO, "DeviceManager::UnInitDeviceManager start, pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::UnInitDeviceManager start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "InitDeviceManager error: Invalid parameter"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("UnInitDeviceManager error: Invalid parameter"); + return DM_INVALID_VALUE; } int32_t ret = ipcClientProxy_->UnInit(pkgName); - if (ret != DEVICEMANAGER_OK) { - return ret; + if (ret != DM_OK) { + LOGE("UnInitDeviceManager error: proxy unInit failed ret: %d", ret); + return DM_UNINIT_FAILED; } + DeviceManagerNotify::GetInstance().UnRegisterPackageCallback(pkgName); - DMLOG(DM_LOG_INFO, "DeviceManager::UnInitDeviceManager completed with errcode %d", ret); - return DEVICEMANAGER_OK; + LOGI("UnInitDeviceManager success"); + return DM_OK; } -int32_t DeviceManagerImpl::GetTrustedDeviceList(std::string &pkgName, std::string &extra, - std::vector &deviceList) +int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList) { - DMLOG(DM_LOG_INFO, "DeviceManager::GetTrustedDeviceList start, pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::GetTrustedDeviceList start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("GetTrustedDeviceList error: Invalid para"); + return DM_INVALID_VALUE; } - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); req->SetPkgName(pkgName); req->SetExtra(extra); - if (ipcClientProxy_->SendRequest(GET_TRUST_DEVICE_LIST, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; + int32_t ret = ipcClientProxy_->SendRequest(GET_TRUST_DEVICE_LIST, req, rsp); + if (ret != DM_OK) { + LOGE("GetTrustedDeviceList error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; + } + + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGI("GetTrustedDeviceList error: failed ret: %d", ret); + return DM_IPC_RESPOND_ERROR; } - if (rsp->GetErrCode() == DEVICEMANAGER_OK) { - deviceList = rsp->GetDeviceVec(); + + deviceList = rsp->GetDeviceVec(); + LOGI("GetTrustedDeviceList completed, pkgName: %s", pkgName.c_str()); + return DM_OK; +} + +int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info) +{ + LOGI("DeviceManager::GetLocalDeviceInfo start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + int32_t ret = ipcClientProxy_->SendRequest(GET_LOCAL_DEVICE_INFO, req, rsp); + if (ret != DM_OK) { + LOGE("GetLocalDeviceInfo error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; } - DMLOG(DM_LOG_INFO, "DeviceManager::GetTrustedDeviceList completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGI("GetLocalDeviceInfo error: failed ret: %d", ret); + return DM_IPC_RESPOND_ERROR; + } + + info = rsp->GetLocalDeviceInfo(); + LOGI("GetLocalDeviceInfo completed,pkgname%s", req->GetPkgName().c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::RegisterDevStateCallback(std::string &pkgName, std::string &extra, - std::shared_ptr callback) +int32_t DeviceManagerImpl::RegisterDevStateCallback(const std::string &pkgName, const std::string &extra, + std::shared_ptr callback) { - DMLOG(DM_LOG_INFO, "DeviceManager::RegisterDevStateCallback start, pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::RegisterDevStateCallback start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty() || callback == nullptr) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("RegisterDevStateCallback error: Invalid para"); + return DM_INVALID_VALUE; } DeviceManagerNotify::GetInstance().RegisterDeviceStateCallback(pkgName, callback); - DMLOG(DM_LOG_INFO, "DeviceManager::RegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + LOGI("RegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::UnRegisterDevStateCallback(std::string &pkgName) +int32_t DeviceManagerImpl::UnRegisterDevStateCallback(const std::string &pkgName) { - DMLOG(DM_LOG_INFO, "DeviceManager::UnRegisterDevStateCallback start, pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::UnRegisterDevStateCallback start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("UnRegisterDevStateCallback error: Invalid para"); + return DM_INVALID_VALUE; } DeviceManagerNotify::GetInstance().UnRegisterDeviceStateCallback(pkgName); - DMLOG(DM_LOG_INFO, "DeviceManager::UnRegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + LOGI("UnRegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::StartDeviceDiscovery(std::string &pkgName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback) +int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra, std::shared_ptr callback) { - DMLOG(DM_LOG_INFO, "DeviceManager::StartDeviceDiscovery start, pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::StartDeviceDiscovery start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty() || callback == nullptr) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("StartDeviceDiscovery error: Invalid para"); + return DM_INVALID_VALUE; } - DMLOG(DM_LOG_INFO, "DeviceManager StartDeviceDiscovery in, pkgName %s", pkgName.c_str()); - DeviceManagerNotify::GetInstance().RegisterDiscoverCallback(pkgName, subscribeInfo.subscribeId, callback); + LOGI("DeviceManager StartDeviceDiscovery in, pkgName %s", pkgName.c_str()); + DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeInfo.subscribeId, callback); std::shared_ptr req = std::make_shared(); std::shared_ptr rsp = std::make_shared(); req->SetPkgName(pkgName); + req->SetExtra(extra); req->SetSubscribeInfo(subscribeInfo); - if (ipcClientProxy_->SendRequest(START_DEVICE_DISCOVER, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; + int32_t ret = ipcClientProxy_->SendRequest(START_DEVICE_DISCOVER, req, rsp); + if (ret != DM_OK) { + LOGE("StartDeviceDiscovery error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; } - int32_t ret = rsp->GetErrCode(); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "DeviceManager StartDeviceDiscovery Failed with ret %d", ret); - return ret; + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("StartDeviceDiscovery error: Failed with ret %d", ret); + return DM_IPC_RESPOND_ERROR; } - return DEVICEMANAGER_OK; + + LOGI("StartDeviceDiscovery completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::StopDeviceDiscovery(std::string &pkgName, uint16_t subscribeId) +int32_t DeviceManagerImpl::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId) { - DMLOG(DM_LOG_INFO, "DeviceManager::StopDeviceDiscovery start , pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::StopDeviceDiscovery start , pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("StopDeviceDiscovery error: Invalid para"); + return DM_INVALID_VALUE; } - DMLOG(DM_LOG_INFO, "StopDeviceDiscovery in, pkgName %s", pkgName.c_str()); + LOGI("StopDeviceDiscovery in, pkgName %s", pkgName.c_str()); std::shared_ptr req = std::make_shared(); std::shared_ptr rsp = std::make_shared(); req->SetPkgName(pkgName); req->SetSubscribeId(subscribeId); - if (ipcClientProxy_->SendRequest(STOP_DEVICE_DISCOVER, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; + int32_t ret = ipcClientProxy_->SendRequest(STOP_DEVICE_DISCOVER, req, rsp); + if (ret != DM_OK) { + LOGE("StopDeviceDiscovery error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; } - int32_t ret = rsp->GetErrCode(); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "StopDeviceDiscovery Failed with ret %d", ret); - return ret; + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("StopDeviceDiscovery error: Failed with ret %d", ret); + return DM_IPC_RESPOND_ERROR; } - DeviceManagerNotify::GetInstance().UnRegisterDiscoverCallback(pkgName, subscribeId); - DMLOG(DM_LOG_INFO, "DeviceManager::StopDeviceDiscovery completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + + DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId); + LOGI("StopDeviceDiscovery completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::AuthenticateDevice(std::string &pkgName, const DmDeviceInfo &deviceInfo, - const DmAppImageInfo &imageInfo, std::string &extra, std::shared_ptr callback) +int32_t DeviceManagerImpl::AuthenticateDevice(const std::string &pkgName, int32_t authType, + const DmDeviceInfo &deviceInfo, const std::string &extra, + std::shared_ptr callback) { - DMLOG(DM_LOG_INFO, "DeviceManager::AuthenticateDevice start , pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::AuthenticateDevice start , pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("AuthenticateDevice error: Invalid para"); + return DM_INVALID_VALUE; } - DMLOG(DM_LOG_INFO, "AuthenticateDevice in, pkgName %s", pkgName.c_str()); std::shared_ptr req = std::make_shared(); std::shared_ptr rsp = std::make_shared(); req->SetPkgName(pkgName); req->SetExtra(extra); + req->SetAuthType(authType); req->SetDeviceInfo(deviceInfo); - req->SetAppImageInfo(imageInfo); - if (ipcClientProxy_->SendRequest(AUTHENTICATE_DEVICE, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; + int32_t ret = ipcClientProxy_->SendRequest(AUTHENTICATE_DEVICE, req, rsp); + if (ret != DM_OK) { + LOGE("AuthenticateDevice error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; } - int32_t ret = rsp->GetErrCode(); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "AuthenticateDevice Failed with ret %d", ret); - return ret; + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("AuthenticateDevice error: Failed with ret %d", ret); + return DM_IPC_RESPOND_ERROR; } + std::string strDeviceId = deviceInfo.deviceId; DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, strDeviceId, callback); - DMLOG(DM_LOG_INFO, "DeviceManager::AuthenticateDevice completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + LOGI("DeviceManager::AuthenticateDevice completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::CheckAuthentication(std::string &pkgName, std::string &authPara, - std::shared_ptr callback) +int32_t DeviceManagerImpl::UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId) { - DMLOG(DM_LOG_INFO, "DeviceManager::CheckAuthentication start , pkgName: %s", pkgName.c_str()); + LOGI("DeviceManager::UnAuthenticateDevice start , pkgName: %s, deviceId: %s", pkgName.c_str(), deviceId.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } + + if (deviceId.empty()) { + LOGE("UnAuthenticateDevice error: Invalid para"); + return DM_INVALID_VALUE; + } + + DmDeviceInfo deviceInfo; + strcpy(deviceInfo.deviceId, deviceId.c_str()); + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetDeviceInfo(deviceInfo); + int32_t ret = ipcClientProxy_->SendRequest(UNAUTHENTICATE_DEVICE, req, rsp); + if (ret != DM_OK) { + LOGE("UnAuthenticateDevice error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; + } + + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("UnAuthenticateDevice error: Failed with ret %d", ret); + return DM_IPC_RESPOND_ERROR; + } + + DeviceManagerNotify::GetInstance().UnRegisterAuthenticateCallback(pkgName, deviceId); + LOGI("UnAuthenticateDevice completed, pkgName: %s", pkgName.c_str()); + return DM_OK; +} + +int32_t DeviceManagerImpl::RegisterDeviceManagerFaCallback(const std::string &pkgName, + std::shared_ptr callback) +{ + LOGI("DeviceManager::RegisterDeviceManagerFaCallback start, pkgName: %s", pkgName.c_str()); + if (pkgName.empty() || callback == nullptr) { + LOGE("RegisterDeviceManagerFaCallback error: Invalid para"); + return DM_INVALID_VALUE; + } + DeviceManagerNotify::GetInstance().RegisterDeviceManagerFaCallback(pkgName, callback); + LOGI("DeviceManager::RegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); + return DM_OK; +} + +int32_t DeviceManagerImpl::UnRegisterDeviceManagerFaCallback(const std::string &pkgName) +{ + LOGI("DeviceManager::UnRegisterDeviceManagerFaCallback start, pkgName: %s", pkgName.c_str()); + if (pkgName.empty()) { + LOGE("UnRegisterDeviceManagerFaCallback error: Invalid para"); + return DM_INVALID_VALUE; + } + DeviceManagerNotify::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName); + LOGI("DeviceManager::UnRegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); + return DM_OK; +} + +int32_t DeviceManagerImpl::VerifyAuthentication(const std::string &pkgName, const std::string &authPara, + std::shared_ptr callback) +{ + LOGI("DeviceManager::VerifyAuthentication start, pkgName: %s", pkgName.c_str()); + if (!isSystemAppCalling()) { + LOGI("the caller is not a system app"); + return DM_NOT_SYSTEM_APP; + } if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("VerifyAuthentication error: Invalid para"); + return DM_INVALID_VALUE; } - DMLOG(DM_LOG_INFO, "CheckAuthentication in, pkgName %s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); + + DeviceManagerNotify::GetInstance().RegisterVerifyAuthenticationCallback(pkgName, authPara, callback); + + std::shared_ptr req = std::make_shared(); std::shared_ptr rsp = std::make_shared(); req->SetPkgName(pkgName); req->SetAuthPara(authPara); - if (ipcClientProxy_->SendRequest(CHECK_AUTHENTICATION, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; - } - int32_t ret = rsp->GetErrCode(); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "CheckAuthentication Failed with ret %d", ret); + int32_t ret = ipcClientProxy_->SendRequest(VERIFY_AUTHENTICATION, req, rsp); + if (ret != DM_OK) { + LOGE("VerifyAuthentication error: Send Request failed ret: %d", ret); + return DM_IPC_SEND_REQUEST_FAILED; + } + ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("VerifyAuthentication error: Failed with ret %d", ret); return ret; } - DeviceManagerNotify::GetInstance().RegisterCheckAuthenticationCallback(pkgName, authPara, callback); - DMLOG(DM_LOG_INFO, "DeviceManager::CheckAuthentication completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + + LOGI("VerifyAuthentication completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::GetAuthenticationParam(std::string &pkgName, DmAuthParam &authParam) +int32_t DeviceManagerImpl::GetFaParam(const std::string &pkgName, DmAuthParam &dmFaParam) { - DMLOG(DM_LOG_INFO, "DeviceManager::GetAuthenticationParam start"); + LOGI("DeviceManager::GetFaParam start, pkgName: %s", pkgName.c_str()); + if (pkgName.empty()) { + LOGE("VerifyAuthentication failed, pkgName is empty"); + return DM_INVALID_VALUE; + } + std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); req->SetPkgName(pkgName); - if (ipcClientProxy_->SendRequest(SERVER_GET_AUTHENTCATION_INFO, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; + + if (ipcClientProxy_->SendRequest(SERVER_GET_DMFA_INFO, req, rsp) != DM_OK) { + LOGI("DeviceManagerImpl::GetFaParam start 2"); + return DM_IPC_SEND_REQUEST_FAILED; } - authParam = rsp->GetAuthParam(); - return DEVICEMANAGER_OK; + dmFaParam = rsp->GetDmAuthParam(); + LOGI("GetFaParam completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::SetUserOperation(std::string &pkgName, int32_t action) +int32_t DeviceManagerImpl::SetUserOperation(const std::string &pkgName, int32_t action) { - DMLOG(DM_LOG_INFO, "DeviceManager::SetUserOperation start"); + LOGI("DeviceManager::SetUserOperation start, pkgName: %s", pkgName.c_str()); + if (pkgName.empty()) { + LOGE("VerifyAuthentication failed, pkgName is empty"); + return DM_INVALID_VALUE; + } + std::shared_ptr req = std::make_shared(); std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); req->SetOperation(action); - if (ipcClientProxy_->SendRequest(SERVER_USER_AUTHORIZATION_OPERATION, req, rsp) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_IPC_FAILED; + if (ipcClientProxy_->SendRequest(SERVER_USER_AUTH_OPERATION, req, rsp) != DM_OK) { + return DM_IPC_SEND_REQUEST_FAILED; } int32_t ret = rsp->GetErrCode(); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "CheckAuthentication Failed with ret %d", ret); + if (ret != DM_OK) { + LOGE("CheckAuthentication Failed with ret %d", ret); return ret; } - return DEVICEMANAGER_OK; + LOGI("SetUserOperation completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t DeviceManagerImpl::RegisterDeviceManagerFaCallback(std::string &packageName, - std::shared_ptr callback) +int32_t DeviceManagerImpl::GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId, + std::string &udid) { - DMLOG(DM_LOG_INFO, "DeviceManager::RegisterDeviceManagerFaCallback start, pkgName: %s", packageName.c_str()); - if (packageName.empty() || callback == nullptr) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; - } - DeviceManagerNotify::GetInstance().RegisterDeviceManagerFaCallback(packageName, callback); - DMLOG(DM_LOG_INFO, "DeviceManager::RegisterDevStateCallback completed, pkgName: %s", packageName.c_str()); - return DEVICEMANAGER_OK; + if (pkgName.empty()) { + LOGE("VerifyAuthentication failed, pkgName is empty"); + return DM_INVALID_VALUE; + } + + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetNetWorkId(netWorkId); + + if (ipcClientProxy_->SendRequest(GET_UDID_BY_NETWORK, req, rsp) != DM_OK) { + return DM_IPC_SEND_REQUEST_FAILED; + } + int32_t ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("CheckAuthentication Failed with ret %d", ret); + return ret; + } + udid = rsp->GetUdid(); + return DM_OK; } -int32_t DeviceManagerImpl::UnRegisterDeviceManagerFaCallback(std::string &pkgName) +int32_t DeviceManagerImpl::GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, + std::string &uuid) { - DMLOG(DM_LOG_INFO, "DeviceManager::UnRegisterDeviceManagerFaCallback start, pkgName: %s", pkgName.c_str()); if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Invalid para"); - return DEVICEMANAGER_INVALID_VALUE; + LOGE("VerifyAuthentication failed, pkgName is empty"); + return DM_INVALID_VALUE; } - DeviceManagerNotify::GetInstance().UnRegisterDeviceManagerFaCallback(pkgName); - DMLOG(DM_LOG_INFO, "DeviceManager::UnRegisterDevStateCallback completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + + std::shared_ptr req = std::make_shared(); + std::shared_ptr rsp = std::make_shared(); + req->SetPkgName(pkgName); + req->SetNetWorkId(netWorkId); + + if (ipcClientProxy_->SendRequest(GET_UUID_BY_NETWORK, req, rsp) != DM_OK) { + return DM_IPC_SEND_REQUEST_FAILED; + } + int32_t ret = rsp->GetErrCode(); + if (ret != DM_OK) { + LOGE("CheckAuthentication Failed with ret %d", ret); + return ret; + } + uuid = rsp->GetUuid(); + return DM_OK; } } // 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 index 77cf6559d54dcd2f30ab43d65b550e41e66abb98..57fd0e97b0817cf133f94775bcf2f08e7d7af286 100644 --- a/interfaces/inner_kits/native_cpp/src/ipc/ipc_client_proxy.cpp +++ b/interfaces/inner_kits/native_cpp/src/ipc/ipc_client_proxy.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,23 +15,23 @@ #include "ipc_client_proxy.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" +#include "dm_constants.h" +#include "dm_log.h" namespace OHOS { namespace DistributedHardware { -int32_t IpcClientProxy::Init(std::string &pkgName) +int32_t IpcClientProxy::Init(const std::string &pkgName) { if (ipcClientManager_ == nullptr) { - return DEVICEMANAGER_NULLPTR; + return DM_POINT_NULL; } return ipcClientManager_->Init(pkgName); } -int32_t IpcClientProxy::UnInit(std::string &pkgName) +int32_t IpcClientProxy::UnInit(const std::string &pkgName) { if (ipcClientManager_ == nullptr) { - return DEVICEMANAGER_NULLPTR; + return DM_POINT_NULL; } return ipcClientManager_->UnInit(pkgName); } @@ -39,8 +39,8 @@ int32_t IpcClientProxy::UnInit(std::string &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; + LOGI("req,rsp or ipc client is null"); + return DM_POINT_NULL; } return ipcClientManager_->SendRequest(cmdCode, req, rsp); } 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 index 26551b4353d24859018d70a99a43e615451be7cb..0b1a27788378b6717481db14dd55b69529c0ff8a 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,27 +15,26 @@ #include "ipc_client_manager.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" - +#include "dm_constants.h" +#include "dm_log.h" #include "ipc_client_stub.h" #include "ipc_register_listener_req.h" namespace OHOS { namespace DistributedHardware { -int32_t IpcClientManager::Init(std::string &pkgName) +int32_t IpcClientManager::Init(const std::string &pkgName) { if (IsInit(pkgName)) { - DMLOG(DM_LOG_INFO, "already init"); - return DEVICEMANAGER_OK; + LOGI("already init"); + return DM_OK; } - if (serverProxy_.Init() != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "server proxy init failed."); - return DEVICEMANAGER_INIT_FAILED; + if (serverProxy_.Init() != DM_OK) { + LOGE("server proxy init failed."); + return DM_INIT_FAILED; } - if (IpcClientStub::GetInstance().Init() != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "ipcclientstub init failed."); - return DEVICEMANAGER_INIT_FAILED; + if (IpcClientStub::GetInstance().Init() != DM_OK) { + LOGE("ipcclientstub init failed."); + return DM_INIT_FAILED; } std::shared_ptr req = std::make_shared(); @@ -43,48 +42,48 @@ int32_t IpcClientManager::Init(std::string &pkgName) 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); + if (ret != DM_OK) { + LOGE("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); + if (ret != DM_OK) { + LOGE("DeviceManager::InitDeviceManager completed, pkgName: %s, ret=%d", pkgName.c_str(), ret); return ret; } packageInitSet_.emplace(pkgName); - return DEVICEMANAGER_OK; + return DM_OK; } -int32_t IpcClientManager::UnInit(std::string &pkgName) +int32_t IpcClientManager::UnInit(const std::string &pkgName) { - DMLOG(DM_LOG_INFO, "UnInitDeviceManager in, pkgName %s", pkgName.c_str()); + LOGI("UnInitDeviceManager in, pkgName %s", pkgName.c_str()); if (!IsInit(pkgName)) { - return DEVICEMANAGER_FAILED; + return DM_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); + if (ret != DM_OK) { + LOGE("UnRegisterDeviceManagerListener Failed with ret %d", ret); return ret; } packageInitSet_.erase(pkgName); - DMLOG(DM_LOG_INFO, "UnInitDeviceManager SUCCESS"); - return DEVICEMANAGER_OK; + LOGI("UnInitDeviceManager SUCCESS"); + return DM_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 DM_SERVICE_NOT_READY; } return serverProxy_.SendCmd(cmdCode, req, rsp); } -bool IpcClientManager::IsInit(std::string &pkgName) +bool IpcClientManager::IsInit(const std::string &pkgName) { return (packageInitSet_.count(pkgName) > 0); } 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 index bfac66bf3761e5188b7c4685c82d8a69079e166e..bf2f2b6704715c7f0f079a2fc2cc063f8e1b84db 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,17 +15,16 @@ #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 "dm_constants.h" +#include "dm_log.h" #include "ipc_cmd_register.h" +#include "ipc_def.h" namespace OHOS { namespace DistributedHardware { namespace { - const int32_t INVALID_CB_ID = 0xFF; +const int32_t INVALID_CB_ID = 0xFF; } static uint32_t g_deathCbId = INVALID_CB_ID; static SvcIdentity g_svcIdentity; @@ -43,23 +42,23 @@ int32_t DMDeathCallback(const IpcContext *ctx, void *ipcMsg, IpcIo *data, void * (void)ipcMsg; (void)data; (void)arg; - DMLOG(DM_LOG_INFO, "ATTENTION SERVICE (%s) DEAD !!!\n", DEVICE_MANAGER_SERVICE_NAME); + LOGI("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; + return DM_OK; } static int32_t SendCmdResultCb(IOwner owner, int32_t code, IpcIo *reply) { (void)code; int32_t cmdCode = *(int32_t *)owner; - DMLOG(DM_LOG_INFO, "SendCmdResultCb code:%d", cmdCode); + LOGI("SendCmdResultCb code:%d", cmdCode); (void)IpcCmdRegister::GetInstance().ReadResponse(cmdCode, *reply, pCurRsp); - return DEVICEMANAGER_OK; + return DM_OK; } IClientProxy *IpcClientServerProxy::GetServerProxy(void) @@ -67,14 +66,14 @@ IClientProxy *IpcClientServerProxy::GetServerProxy(void) IClientProxy *clientProxy = nullptr; IUnknown *iUnknown = nullptr; - DMLOG(DM_LOG_INFO, "start get client proxy"); + LOGI("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 || + if (iUnknown->QueryInterface(iUnknown, CLIENT_PROXY_VER, (void **)&clientProxy) != DM_OK || clientProxy == nullptr) { - DMLOG(DM_LOG_ERROR, "QueryInterface failed"); + LOGE("QueryInterface failed"); } return clientProxy; } @@ -84,52 +83,52 @@ 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; + LOGE("reg death callback failed"); + return DM_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } int32_t IpcClientServerProxy::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) { - DMLOG(DM_LOG_INFO, "SendCmd:%d", cmdCode); + LOGI("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; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, request, data, MAX_DM_IPC_LEN) != DM_OK) { + return DM_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; + LOGE("serviceProxy_ invoke failed."); + return DM_FAILED; } } - DMLOG(DM_LOG_INFO, "SendCmd:%d end", cmdCode); - return DEVICEMANAGER_OK; + LOGI("SendCmd:%d end", cmdCode); + return DM_OK; } int32_t IpcClientServerProxy::Init(void) { if (serviceProxy_ != nullptr) { - DMLOG(DM_LOG_INFO, "ServerProxy already Init"); - return DEVICEMANAGER_OK; + LOGI("ServerProxy already Init"); + return DM_OK; } HOS_SystemInit(); serviceProxy_ = GetServerProxy(); if (serviceProxy_ == nullptr) { - DMLOG(DM_LOG_ERROR, "get ipc client proxy failed"); - return DEVICEMANAGER_FAILED; + LOGE("get ipc client proxy failed"); + return DM_FAILED; } - if (RegisterServerDeathCb() != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "register server death cb failed"); - return DEVICEMANAGER_FAILED; + if (RegisterServerDeathCb() != DM_OK) { + LOGE("register server death cb failed"); + return DM_FAILED; } - DMLOG(DM_LOG_INFO, "ServerProxyInit ok"); - return DEVICEMANAGER_OK; + LOGI("ServerProxyInit ok"); + return DM_OK; } } // namespace DistributedHardware } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp index 2726d7ee3f35d7cde84e56036b1624b97ffef2e0..36132ab8bf51098abd6526f1d65c807c7615d543 100644 --- a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp +++ b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_stub.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,12 +15,11 @@ #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 "dm_constants.h" +#include "dm_log.h" #include "ipc_cmd_register.h" +#include "ipc_def.h" namespace OHOS { namespace DistributedHardware { @@ -30,16 +29,16 @@ static int32_t ClientIpcInterfaceMsgHandle(const IpcContext *ctx, void *ipcMsg, { (void)arg; if (ipcMsg == nullptr || io == nullptr) { - DMLOG(DM_LOG_ERROR, "invalid param"); - return DEVICEMANAGER_INVALID_PARAM; + LOGE("invalid param"); + return DM_INPUT_PARA_EMPTY; } uint32_t code = 0; GetCode(ipcMsg, &code); - int32_t errCode = DEVICEMANAGER_OK; + int32_t errCode = DM_OK; errCode = IpcCmdRegister::GetInstance().OnIpcCmd(code, *io); - DMLOG(DM_LOG_INFO, "receive ipc transact code:%u, retCode=%d", code, errCode); + LOGI("receive ipc transact code:%u, retCode=%d", code, errCode); FreeBuffer(ctx, ipcMsg); return errCode; } @@ -48,14 +47,14 @@ int32_t IpcClientStub::Init() { std::lock_guard autoLock(lock_); if (bInit) { - return DEVICEMANAGER_OK; + return DM_OK; } if (RegisterIpcCallback(ClientIpcInterfaceMsgHandle, 0, IPC_WAIT_FOREVER, &clientIdentity_, nullptr) != 0) { - DMLOG(DM_LOG_ERROR, "register ipc cb failed"); - return DEVICEMANAGER_FAILED; + LOGE("register ipc cb failed"); + return DM_FAILED; } bInit = true; - return DEVICEMANAGER_OK; + return DM_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 index bd67cd215b5b3f1849ed7d7ff4f6c11f99a055bd..e1a881b907105d52639c356acd1a7d089b6d44e4 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,32 +13,27 @@ * limitations under the License. */ -#include "ipc_cmd_register.h" -#include "ipc_def.h" - -#include "securec.h" -#include "constants.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" #include "device_manager_notify.h" - +#include "dm_constants.h" #include "dm_device_info.h" +#include "dm_log.h" #include "dm_subscribe_info.h" - +#include "ipc_authenticate_device_req.h" +#include "ipc_cmd_register.h" +#include "ipc_def.h" +#include "ipc_get_local_device_info_rsp.h" +#include "ipc_get_trustdevice_req.h" +#include "ipc_get_trustdevice_rsp.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" +#include "ipc_verify_authenticate_req.h" +#include "securec.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) +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(); @@ -47,47 +42,47 @@ ON_IPC_SET_REQUEST(REGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBa IpcIoInit(&request, buffer, buffLen, 1); IpcIoPushString(&request, pkgName.c_str()); IpcIoPushSvc(&request, &svcIdentity); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(REGISTER_DEVICE_MANAGER_LISTENER, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_SET_REQUEST(UNREGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) + uint8_t *buffer, size_t buffLen) { std::string pkgName = pBaseReq->GetPkgName(); IpcIoInit(&request, buffer, buffLen, 0); IpcIoPushString(&request, pkgName.c_str()); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(UNREGISTER_DEVICE_MANAGER_LISTENER, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(GET_TRUST_DEVICE_LIST, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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::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; + return DM_OK; } ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, IpcIo &reply, std::shared_ptr pBaseRsp) { - std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); int32_t deviceNum = IpcIoPopInt32(&reply); uint32_t deviceTotalSize = deviceNum * (int32_t)sizeof(DmDeviceInfo); @@ -95,9 +90,9 @@ ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, IpcIo &reply, std::shared_ptr 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; + LOGE("GetTrustedDeviceList read node info failed!"); + pRsp->SetErrCode(DM_IPC_TRANSACTION_FAILED); + return DM_IPC_TRANSACTION_FAILED; } for (int32_t i = 0; i < deviceNum; ++i) { pDmDeviceinfo = pDmDeviceinfo + i; @@ -106,30 +101,52 @@ ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, IpcIo &reply, std::shared_ptrSetDeviceVec(deviceInfoVec); } pRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; +} + +ON_IPC_SET_REQUEST(GET_LOCAL_DEVICE_INFO, std::shared_ptr pBaseReq, IpcIo &request, uint8_t *buffer, + size_t buffLen) +{ + IpcIoInit(&request, buffer, buffLen, 0); + return DM_OK; +} + +ON_IPC_READ_RESPONSE(GET_LOCAL_DEVICE_INFO, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + + uint32_t size = 0; + DmDeviceInfo *dmDeviceInfo = (DmDeviceInfo *)IpcIoPopFlatObj(&reply, &size); + if (dmDeviceInfo != nullptr) { + pRsp->SetLocalDeviceInfo(*dmDeviceInfo); + } + pRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DM_OK; } -ON_IPC_SET_REQUEST(START_DEVICE_DISCOVER, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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(); + std::string extra = pReq->GetExtra(); const DmSubscribeInfo dmSubscribeInfo = pReq->GetSubscribeInfo(); IpcIoInit(&request, buffer, buffLen, 0); IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushString(&request, extra.c_str()); IpcIoPushFlatObj(&request, &dmSubscribeInfo, sizeof(DmSubscribeInfo)); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVER, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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(); @@ -138,21 +155,21 @@ ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr pBaseReq, IpcIo IpcIoInit(&request, buffer, buffLen, 0); IpcIoPushString(&request, pkgName.c_str()); IpcIoPushUint16(&request, subscribeId); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(STOP_DEVICE_DISCOVER, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(AUTHENTICATE_DEVICE, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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(); + std::string extra = pReq->GetExtra(); DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); IpcIoInit(&request, buffer, buffLen, 0); @@ -160,30 +177,49 @@ ON_IPC_SET_REQUEST(AUTHENTICATE_DEVICE, std::shared_ptr pBaseReq, IpcIo IpcIoPushString(&request, extra.c_str()); IpcIoPushFlatObj(&request, &deviceInfo, sizeof(DmDeviceInfo)); // L1 暂时没有考虑appimage校验（8k限制） - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(AUTHENTICATE_DEVICE, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(CHECK_AUTHENTICATION, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +ON_IPC_SET_REQUEST(VERIFY_AUTHENTICATION, std::shared_ptr pBaseReq, IpcIo &request, uint8_t *buffer, + size_t buffLen) { - std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + 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; + return DM_OK; } -ON_IPC_READ_RESPONSE(CHECK_AUTHENTICATION, IpcIo &reply, std::shared_ptr pBaseRsp) +ON_IPC_READ_RESPONSE(VERIFY_AUTHENTICATION, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; +} + +ON_IPC_SET_REQUEST(SERVER_USER_AUTH_OPERATION, 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 action = pReq->GetOperation(); + + IpcIoInit(&request, buffer, buffLen, 0); + IpcIoPushString(&request, pkgName.c_str()); + IpcIoPushInt32(&request, action); + return DM_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_USER_AUTH_OPERATION, IpcIo &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); + return DM_OK; } ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, IpcIo &reply) @@ -192,9 +228,9 @@ ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, IpcIo &reply) 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); + const DmDeviceInfo *deviceInfo = (const DmDeviceInfo *)IpcIoPopFlatObj(&reply, &size); if (pkgName == "" || len == 0 || deviceInfo == NULL) { - DMLOG(DM_LOG_ERROR, "OnDeviceOnline, get para failed"); + LOGE("OnDeviceOnline, get para failed"); return; } switch (deviceState) { @@ -208,7 +244,7 @@ ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, IpcIo &reply) DeviceManagerNotify::GetInstance().OnDeviceChanged(pkgName, *deviceInfo); break; default: - DMLOG(DM_LOG_ERROR, "unknown device state:%d", deviceState); + LOGE("unknown device state:%d", deviceState); break; } } @@ -219,9 +255,9 @@ ON_IPC_CMD(SERVER_DEVICE_FOUND, IpcIo &reply) std::string pkgName = (const char *)IpcIoPopString(&reply, &len); uint16_t subscribeId = IpcIoPopUint16(&reply); uint32_t size; - const DmDeviceInfo *deviceInfo = (const DmDeviceInfo*)IpcIoPopFlatObj(&reply, &size); + const DmDeviceInfo *deviceInfo = (const DmDeviceInfo *)IpcIoPopFlatObj(&reply, &size); if (pkgName == "" || len == 0 || deviceInfo == NULL) { - DMLOG(DM_LOG_ERROR, "OnDeviceChanged, get para failed"); + LOGE("OnDeviceChanged, get para failed"); return; } DeviceManagerNotify::GetInstance().OnDeviceFound(pkgName, subscribeId, *deviceInfo); @@ -235,13 +271,13 @@ ON_IPC_CMD(SERVER_DISCOVER_FINISH, IpcIo &reply) int32_t failedReason = IpcIoPopInt32(&reply); if (pkgName == "" || len == 0) { - DMLOG(DM_LOG_ERROR, "OnDiscoverySuccess, get para failed"); + LOGE("OnDiscoverySuccess, get para failed"); return; } - if (failedReason == DEVICEMANAGER_OK) { + if (failedReason == DM_OK) { DeviceManagerNotify::GetInstance().OnDiscoverySuccess(pkgName, subscribeId); } else { - DeviceManagerNotify::GetInstance().OnDiscoverFailed(pkgName, subscribeId, failedReason); + DeviceManagerNotify::GetInstance().OnDiscoveryFailed(pkgName, subscribeId, failedReason); } } @@ -251,18 +287,17 @@ ON_IPC_CMD(SERVER_AUTH_RESULT, IpcIo &reply) 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"); + LOGE("OnAuthResult, get para failed"); return; } - DeviceManagerNotify::GetInstance().OnAuthResult(pkgName, deviceId, pinToken, status, reason); + DeviceManagerNotify::GetInstance().OnAuthResult(pkgName, deviceId, nullptr, status, reason); } -ON_IPC_CMD(SERVER_CHECK_AUTH_RESULT, IpcIo &reply) +ON_IPC_CMD(SERVER_VERIFY_AUTH_RESULT, IpcIo &reply) { size_t len = 0; std::string pkgName = (const char *)IpcIoPopString(&reply, &len); @@ -272,80 +307,13 @@ ON_IPC_CMD(SERVER_CHECK_AUTH_RESULT, IpcIo &reply) int32_t flag = IpcIoPopInt32(&reply); if (pkgName == "" || len == 0 || deviceId == "" || devIdLen == 0) { - DMLOG(DM_LOG_ERROR, "OnAuthResult, get para failed"); + LOGE("OnAuthResult, get para failed"); return; } - DeviceManagerNotify::GetInstance().OnCheckAuthResult(pkgName, deviceId, resultCode, flag); -} - -ON_IPC_SET_REQUEST(SERVER_GET_AUTHENTCATION_INFO, std::shared_ptr pBaseReq, IpcIo& request, - uint8_t *buffer, size_t buffLen) -{ - std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); - std::string packagename = pReq->GetPkgName(); - - IpcIoInit(&request, buffer, buffLen, 0); - IpcIoPushString(&request, packagename.c_str()); - return DEVICEMANAGER_OK; -} - -ON_IPC_READ_RESPONSE(SERVER_GET_AUTHENTCATION_INFO, IpcIo& reply, std::shared_ptr pBaseRsp) -{ - std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); - DmAuthParam authParam = {0}; - authParam.direction = IpcIoPopInt32(&reply); - authParam.authType = IpcIoPopInt32(&reply); - if (authParam.direction == AUTH_SESSION_SIDE_CLIENT) { - authParam.pinToken = IpcIoPopInt32(&reply); - pRsp->SetAuthParam(authParam); - return DEVICEMANAGER_OK; - } - size_t PackagerNamelen = 0; - authParam.packageName = strdup((const char *)IpcIoPopString(&reply, &PackagerNamelen)); - size_t appNameLen = 0; - authParam.appName = strdup((const char *)IpcIoPopString(&reply, &appNameLen)); - size_t appDesLen = 0; - authParam.appDescription = strdup((const char *)IpcIoPopString(&reply, &appDesLen)); - authParam.business = IpcIoPopInt32(&reply); - authParam.pincode = IpcIoPopInt32(&reply); - - uint32_t appIconLen = IpcIoPopInt32(&reply); - uint8_t *appIconBuffer = nullptr; - uint32_t appThumbnailLen = IpcIoPopInt32(&reply); - uint8_t *appThumbBuffer = nullptr; - - if (appIconLen > 0) { - appIconBuffer = (uint8_t *)IpcIoPopFlatObj(&reply, &appIconLen); - } - if (appThumbnailLen > 0) { - appThumbBuffer = (uint8_t *)IpcIoPopFlatObj(&reply, &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, IpcIo& request, - uint8_t *buffer, size_t buffLen) -{ - std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); - std::string pkgName= pReq->GetPkgName(); - int32_t action = pReq->GetOperation(); - - IpcIoInit(&request, buffer, buffLen, 0); - IpcIoPushString(&request, pkgName.c_str()); - IpcIoPushInt32(&request, action); - return DEVICEMANAGER_OK; -} - -ON_IPC_READ_RESPONSE(SERVER_USER_AUTHORIZATION_OPERATION, IpcIo& reply, std::shared_ptr pBaseRsp) -{ - pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + DeviceManagerNotify::GetInstance().OnVerifyAuthResult(pkgName, deviceId, resultCode, flag); } -ON_IPC_CMD(SERVER_DEVICEMANAGER_FA_NOTIFY, IpcIo &reply) +ON_IPC_CMD(SERVER_DEVICE_FA_NOTIFY, IpcIo &reply) { size_t len = 0; std::string packagename = (const char *)IpcIoPopString(&reply, &len); 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 index 26d9fb9278085021dc1ce49f396f86dd121350a2..b2b58f1f0b6e0bba4f3d23b4621ce5e7f7585a59 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,68 +15,67 @@ #include "ipc_client_manager.h" +#include "device_manager_notify.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "ipc_client_stub.h" +#include "ipc_register_listener_req.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"); + LOGW("DmDeathRecipient : OnRemoteDied"); DeviceManagerNotify::GetInstance().OnRemoteDied(); } int32_t IpcClientManager::ClientInit() { - DMLOG(DM_LOG_INFO, "InitDeviceManagerService start"); + LOGI("InitDeviceManagerService start"); if (dmInterface_ != nullptr) { - DMLOG(DM_LOG_INFO, "DeviceManagerService Already Init"); - return DEVICEMANAGER_OK; + LOGI("DeviceManagerService Already Init"); + return DM_OK; } auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); if (samgr == nullptr) { - DMLOG(DM_LOG_ERROR, "Get SystemAbilityManager Failed"); - return DEVICEMANAGER_SERVICE_NOT_READY; + LOGE("Get SystemAbilityManager Failed"); + return DM_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; + LOGE("Get DeviceManager SystemAbility Failed"); + return DM_SERVICE_NOT_READY; } if (dmRecipient_ == nullptr) { dmRecipient_ = sptr(new DmDeathRecipient()); } if (!object->AddDeathRecipient(dmRecipient_)) { - DMLOG(DM_LOG_ERROR, "InitDeviceManagerService: AddDeathRecipient Failed"); + LOGE("InitDeviceManagerService: AddDeathRecipient Failed"); } dmInterface_ = iface_cast(object); - DMLOG(DM_LOG_INFO, "DeviceManager::InitDeviceManagerService completed"); - return DEVICEMANAGER_OK; + LOGI("DeviceManager::InitDeviceManagerService completed"); + return DM_OK; } -int32_t IpcClientManager::Init(std::string &pkgName) +int32_t IpcClientManager::Init(const 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); + if (ret != DM_OK) { + LOGE("InitDeviceManager Failed with ret %d", ret); return ret; } if (dmListener_.count(pkgName) > 0) { - DMLOG(DM_LOG_INFO, "dmListener_ Already Init"); - return DEVICEMANAGER_OK; + LOGI("dmListener_ Already Init"); + return DM_OK; } sptr listener = sptr(new IpcClientStub()); @@ -85,25 +84,25 @@ int32_t IpcClientManager::Init(std::string &pkgName) 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); + if (ret != DM_OK) { + LOGE("InitDeviceManager: RegisterDeviceManagerListener Failed with ret %d", ret); return ret; } ret = rsp->GetErrCode(); - if (ret != DEVICEMANAGER_OK) { + if (ret != DM_OK) { return ret; } dmListener_[pkgName] = listener; - DMLOG(DM_LOG_INFO, "completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + LOGI("completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } -int32_t IpcClientManager::UnInit(std::string &pkgName) +int32_t IpcClientManager::UnInit(const std::string &pkgName) { - DMLOG(DM_LOG_INFO, "in, pkgName %s", pkgName.c_str()); + LOGI("in, pkgName %s", pkgName.c_str()); if (dmInterface_ == nullptr) { - DMLOG(DM_LOG_ERROR, "DeviceManager not Init"); - return DEVICEMANAGER_SERVICE_NOT_READY; + LOGE("DeviceManager not Init"); + return DM_SERVICE_NOT_READY; } std::lock_guard autoLock(lock_); @@ -112,8 +111,8 @@ int32_t IpcClientManager::UnInit(std::string &pkgName) 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); + if (ret != DM_OK) { + LOGE("UnRegisterDeviceManagerListener Failed with ret %d", ret); return ret; } dmListener_.erase(pkgName); @@ -122,28 +121,30 @@ int32_t IpcClientManager::UnInit(std::string &pkgName) dmInterface_ = nullptr; dmRecipient_ = nullptr; } - DMLOG(DM_LOG_INFO, "completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; + LOGI("completed, pkgName: %s", pkgName.c_str()); + return DM_OK; } int32_t IpcClientManager::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) { + LOGI("IpcClientManager::SendRequest in"); std::string pkgName = req->GetPkgName(); if (!IsInit(pkgName)) { - return DEVICEMANAGER_SERVICE_NOT_READY; + LOGE("IpcClientManager::SendRequest DM_SERVICE_NOT_READY"); + return DM_SERVICE_NOT_READY; } return dmInterface_->SendCmd(cmdCode, req, rsp); } -bool IpcClientManager::IsInit(std::string &pkgName) +bool IpcClientManager::IsInit(const std::string &pkgName) { if (dmInterface_ == nullptr) { - DMLOG(DM_LOG_ERROR, "DeviceManager not Init"); + LOGE("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()); + LOGE("dmListener_ not Init for %s", pkgName.c_str()); return false; } return true; 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 index 75d0d1923dfa1a5dc7d9f919d5103abc8381a0ce..0a8e9304041149f0c8abb62fc799d1abe69b9780 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,31 +15,30 @@ #include "ipc_client_server_proxy.h" +#include "dm_constants.h" +#include "dm_log.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; + LOGE("remote service null"); + return DM_POINT_NULL; } MessageParcel data; MessageParcel reply; MessageOption option; - if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_FAILED; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data) != DM_OK) { + return DM_IPC_SEND_REQUEST_FAILED; } - if (remote->SendRequest(cmdCode, data, reply, option) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "SendRequest fail, cmd:%d", cmdCode); - return DEVICEMANAGER_IPC_FAILED; + if (remote->SendRequest(cmdCode, data, reply, option) != DM_OK) { + LOGE("SendRequest fail, cmd:%d", cmdCode); + return DM_IPC_SEND_REQUEST_FAILED; } return IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); } 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 index cbe30dd5bebe91de00aa8174123085cf69f701c5..748da1c824852c5731e764bbe74e1cdd5d5993a9 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,31 +15,28 @@ #include "ipc_client_stub.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "ipc_cmd_register.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) +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; + LOGI("code = %d, flags= %d.", code, option.GetFlags()); + if (IpcCmdRegister::GetInstance().OnIpcCmd(code, data, reply) == DM_OK) { + return DM_OK; } - DMLOG(DM_LOG_WARN, "unsupport code: %d", code); + LOGW("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; + LOGE("error"); + return DM_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 index 45b3f02a9f164d369ebd9a34f07e51e4f913558b..be759e55e1057e56de3f5f2561f2fa21f8947279 100644 --- 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 @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,24 +13,28 @@ * 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 "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" +#include "ipc_authenticate_device_req.h" +#include "ipc_cmd_register.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_dmfaparam_rsp.h" +#include "ipc_get_info_by_network_req.h" +#include "ipc_get_info_by_network_rsp.h" +#include "ipc_get_local_device_info_rsp.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_register_listener_req.h" +#include "ipc_req.h" +#include "ipc_rsp.h" #include "ipc_set_useroperation_req.h" +#include "ipc_start_discovery_req.h" +#include "ipc_stop_discovery_req.h" +#include "ipc_unauthenticate_device_req.h" +#include "ipc_verify_authenticate_req.h" +#include "securec.h" namespace OHOS { namespace DistributedHardware { @@ -40,75 +44,141 @@ ON_IPC_SET_REQUEST(REGISTER_DEVICE_MANAGER_LISTENER, std::shared_ptr pBa std::string pkgName = pReq->GetPkgName(); sptr listener = pReq->GetListener(); if (!data.WriteString(pkgName)) { - DMLOG(DM_LOG_ERROR, "write pkgName failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write pkgName failed"); + return DM_IPC_TRANSACTION_FAILED; } if (!data.WriteRemoteObject(listener)) { - DMLOG(DM_LOG_ERROR, "write listener failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write listener failed"); + return DM_IPC_TRANSACTION_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_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; + LOGE("write papam failed"); + return DM_IPC_TRANSACTION_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_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::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; + LOGE("write pkg failed"); + return DM_IPC_TRANSACTION_FAILED; } if (!data.WriteString(extra)) { - DMLOG(DM_LOG_ERROR, "write extra failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write extra failed"); + return DM_IPC_TRANSACTION_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, MessageParcel &reply, std::shared_ptr pBaseRsp) { - std::shared_ptr pRsp = std::static_pointer_cast(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) { + if (deviceNum > 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; - } + DmDeviceInfo *pDmDeviceinfo = nullptr; for (int32_t i = 0; i < deviceNum; ++i) { - pDmDeviceinfo = pDmDeviceinfo + i; + pDmDeviceinfo = nullptr; + pDmDeviceinfo = (DmDeviceInfo *)reply.ReadRawData((int32_t)sizeof(DmDeviceInfo)); + if (pDmDeviceinfo == nullptr) { + LOGE("GetTrustedDeviceList read node info failed!"); + pRsp->SetErrCode(DM_IPC_TRANSACTION_FAILED); + return DM_IPC_TRANSACTION_FAILED; + } deviceInfoVec.emplace_back(*pDmDeviceinfo); } pRsp->SetDeviceVec(deviceInfoVec); } pRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; +} + +ON_IPC_SET_REQUEST(GET_LOCAL_DEVICE_INFO, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + if (!data.WriteString(pkgName)) { + return DM_FLATTEN_OBJECT; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(GET_LOCAL_DEVICE_INFO, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + DmDeviceInfo *localDeviceInfo = (DmDeviceInfo *)reply.ReadRawData(sizeof(DmDeviceInfo)); + if (localDeviceInfo == nullptr) { + LOGE("write subscribe info failed"); + } + pRsp->SetLocalDeviceInfo(*localDeviceInfo); + pRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} + +ON_IPC_SET_REQUEST(GET_UDID_BY_NETWORK, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string netWorkId = pReq->GetNetWorkId(); + if (!data.WriteString(pkgName)) { + return DM_FLATTEN_OBJECT; + } + if (!data.WriteString(netWorkId)) { + return DM_FLATTEN_OBJECT; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(GET_UDID_BY_NETWORK, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + pRsp->SetErrCode(reply.ReadInt32()); + pRsp->SetUdid(reply.ReadString()); + return DM_OK; +} + +ON_IPC_SET_REQUEST(GET_UUID_BY_NETWORK, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + std::string netWorkId = pReq->GetNetWorkId(); + if (!data.WriteString(pkgName)) { + return DM_FLATTEN_OBJECT; + } + if (!data.WriteString(netWorkId)) { + return DM_FLATTEN_OBJECT; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(GET_UUID_BY_NETWORK, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + std::shared_ptr pRsp = std::static_pointer_cast(pBaseRsp); + pRsp->SetErrCode(reply.ReadInt32()); + pRsp->SetUuid(reply.ReadString()); + return DM_OK; } ON_IPC_SET_REQUEST(START_DEVICE_DISCOVER, std::shared_ptr pBaseReq, MessageParcel &data) @@ -117,20 +187,20 @@ ON_IPC_SET_REQUEST(START_DEVICE_DISCOVER, std::shared_ptr pBaseReq, Mess 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; + LOGE("write pkgName failed"); + return DM_IPC_FLATTEN_OBJECT; } if (!data.WriteRawData(&dmSubscribeInfo, sizeof(DmSubscribeInfo))) { - DMLOG(DM_LOG_ERROR, "write subscribe info failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write subscribe info failed"); + return DM_IPC_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVER, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr pBaseReq, MessageParcel &data) @@ -139,83 +209,144 @@ ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr pBaseReq, Messa 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; + LOGE("write pkgName failed"); + return DM_IPC_FLATTEN_OBJECT; } if (!data.WriteInt16(subscribeId)) { - DMLOG(DM_LOG_ERROR, "write subscribeId failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write subscribeId failed"); + return DM_IPC_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(STOP_DEVICE_DISCOVER, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_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(); + std::string extra = pReq->GetExtra(); + int32_t authType = pReq->GetAuthType(); DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); - DmAppImageInfo imageInfo = pReq->GetAppImageInfo(); + std::string deviceId = deviceInfo.deviceId; if (!data.WriteString(pkgName)) { - DMLOG(DM_LOG_ERROR, "write pkgName failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write pkgName failed"); + return DM_IPC_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; + LOGE("write extra failed"); + return DM_IPC_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.WriteString(deviceId)) { + LOGE("write extra failed"); + return DM_IPC_FLATTEN_OBJECT; } - if (!data.WriteInt32(appThumbnailLen)) { - DMLOG(DM_LOG_ERROR, "write imageinfo appThumbnailLen failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + if (!data.WriteInt32(authType)) { + LOGE("write pkgName failed"); + return DM_IPC_FLATTEN_OBJECT; } - if (appIconLen > 0 && !data.WriteRawData(imageInfo.GetAppIcon(), appIconLen)) { - DMLOG(DM_LOG_ERROR, "write imageinfo appIcon failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + return DM_OK; +} + +ON_IPC_READ_RESPONSE(AUTHENTICATE_DEVICE, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} + +ON_IPC_SET_REQUEST(UNAUTHENTICATE_DEVICE, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string pkgName = pReq->GetPkgName(); + DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); + std::string deviceId = deviceInfo.deviceId; + if (!data.WriteString(pkgName)) { + LOGE("write pkgName failed"); + return DM_IPC_FLATTEN_OBJECT; } - if (appThumbnailLen > 0 && !data.WriteRawData(imageInfo.GetAppThumbnail(), appThumbnailLen)) { - DMLOG(DM_LOG_ERROR, "write imageinfo appThumbnail failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + if (!data.WriteString(deviceId)) { + LOGE("write extra failed"); + return DM_IPC_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_READ_RESPONSE(AUTHENTICATE_DEVICE, MessageParcel &reply, std::shared_ptr pBaseRsp) +ON_IPC_READ_RESPONSE(UNAUTHENTICATE_DEVICE, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(CHECK_AUTHENTICATION, std::shared_ptr pBaseReq, MessageParcel &data) +ON_IPC_SET_REQUEST(VERIFY_AUTHENTICATION, std::shared_ptr pBaseReq, MessageParcel &data) { - std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); std::string authPara = pReq->GetAuthPara(); if (!data.WriteString(authPara)) { - return DEVICEMANAGER_FLATTEN_OBJECT; + return DM_IPC_FLATTEN_OBJECT; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(VERIFY_AUTHENTICATION, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; +} + +ON_IPC_SET_REQUEST(SERVER_GET_DMFA_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)) { + LOGE("write pkgName failed"); + return DM_IPC_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_GET_DMFA_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(); + authParam.authToken = reply.ReadString(); + authParam.packageName = reply.ReadString(); + authParam.appName = reply.ReadString(); + authParam.appDescription = reply.ReadString(); + authParam.business = reply.ReadInt32(); + authParam.pincode = reply.ReadInt32(); + pRsp->SetDmAuthParam(authParam); + return DM_OK; } -ON_IPC_READ_RESPONSE(CHECK_AUTHENTICATION, MessageParcel &reply, std::shared_ptr pBaseRsp) +ON_IPC_SET_REQUEST(SERVER_USER_AUTH_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)) { + LOGE("write pkgName failed"); + return DM_IPC_TRANSACTION_FAILED; + } + if (!data.WriteInt32(action)) { + LOGE("write action failed"); + return DM_WRITE_FAILED; + } + + return DM_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_USER_AUTH_OPERATION, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &data, MessageParcel &reply) @@ -226,8 +357,8 @@ ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &data, MessageParcel &reply 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; + reply.WriteInt32(DM_IPC_COPY_FAILED); + return DM_OK; } switch (deviceState) { case DEVICE_STATE_ONLINE: @@ -239,12 +370,15 @@ ON_IPC_CMD(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &data, MessageParcel &reply case DEVICE_INFO_CHANGED: DeviceManagerNotify::GetInstance().OnDeviceChanged(pkgName, dmDeviceInfo); break; + case DEVICE_INFO_READY: + DeviceManagerNotify::GetInstance().OnDeviceReady(pkgName, dmDeviceInfo); + break; default: - DMLOG(DM_LOG_ERROR, "unknown device state:%d", deviceState); + LOGE("unknown device state:%d", deviceState); break; } - reply.WriteInt32(DEVICEMANAGER_OK); - return DEVICEMANAGER_OK; + reply.WriteInt32(DM_OK); + return DM_OK; } ON_IPC_CMD(SERVER_DEVICE_FOUND, MessageParcel &data, MessageParcel &reply) @@ -255,12 +389,12 @@ ON_IPC_CMD(SERVER_DEVICE_FOUND, MessageParcel &data, MessageParcel &reply) 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; + reply.WriteInt32(DM_IPC_COPY_FAILED); + return DM_IPC_COPY_FAILED; } DeviceManagerNotify::GetInstance().OnDeviceFound(pkgName, subscribeId, dmDeviceInfo); - reply.WriteInt32(DEVICEMANAGER_OK); - return DEVICEMANAGER_OK; + reply.WriteInt32(DM_OK); + return DM_OK; } ON_IPC_CMD(SERVER_DISCOVER_FINISH, MessageParcel &data, MessageParcel &reply) @@ -269,122 +403,48 @@ ON_IPC_CMD(SERVER_DISCOVER_FINISH, MessageParcel &data, MessageParcel &reply) uint16_t subscribeId = data.ReadInt16(); int32_t failedReason = data.ReadInt32(); - if (failedReason == DEVICEMANAGER_OK) { + if (failedReason == DM_OK) { DeviceManagerNotify::GetInstance().OnDiscoverySuccess(pkgName, subscribeId); } else { - DeviceManagerNotify::GetInstance().OnDiscoverFailed(pkgName, subscribeId, failedReason); + DeviceManagerNotify::GetInstance().OnDiscoveryFailed(pkgName, subscribeId, failedReason); } - reply.WriteInt32(DEVICEMANAGER_OK); - return DEVICEMANAGER_OK; + reply.WriteInt32(DM_OK); + return DM_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(); + std::string token = data.ReadString(); 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; + DeviceManagerNotify::GetInstance().OnAuthResult(pkgName, deviceId, token, status, reason); + reply.WriteInt32(DM_OK); + return DM_OK; } -ON_IPC_CMD(SERVER_CHECK_AUTH_RESULT, MessageParcel &data, MessageParcel &reply) +ON_IPC_CMD(SERVER_VERIFY_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; + DeviceManagerNotify::GetInstance().OnVerifyAuthResult(pkgName, deviceId, resultCode, flag); + reply.WriteInt32(DM_OK); + return DM_OK; } -ON_IPC_SET_REQUEST(SERVER_USER_AUTHORIZATION_OPERATION, std::shared_ptr pBaseReq, MessageParcel &data) +ON_IPC_CMD(SERVER_DEVICE_FA_NOTIFY, MessageParcel &data, MessageParcel &reply) { - 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; + if (!reply.WriteInt32(DM_OK)) { + LOGE("write return failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_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 index 94f03d156c6ebb0bf6af5ede84182ed7a19389fc..f1c36875eb76b23974e04affb9ebbe31f1e40b21 100644 --- a/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp +++ b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,65 +15,64 @@ #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" +#include "dm_constants.h" +#include "dm_log.h" +#include "nlohmann/json.hpp" namespace OHOS { namespace DistributedHardware { IMPLEMENT_SINGLE_INSTANCE(DeviceManagerNotify); -void DeviceManagerNotify::RegisterDeathRecipientCallback(std::string &pkgName, - std::shared_ptr dmInitCallback) +void DeviceManagerNotify::RegisterDeathRecipientCallback(const std::string &pkgName, + std::shared_ptr dmInitCallback) { std::lock_guard autoLock(lock_); dmInitCallback_[pkgName] = dmInitCallback; } -void DeviceManagerNotify::UnRegisterDeathRecipientCallback(std::string &pkgName) +void DeviceManagerNotify::UnRegisterDeathRecipientCallback(const std::string &pkgName) { std::lock_guard autoLock(lock_); dmInitCallback_.erase(pkgName); } -void DeviceManagerNotify::RegisterDeviceStateCallback(std::string &pkgName, - std::shared_ptr callback) +void DeviceManagerNotify::RegisterDeviceStateCallback(const std::string &pkgName, + std::shared_ptr callback) { std::lock_guard autoLock(lock_); deviceStateCallback_[pkgName] = callback; } -void DeviceManagerNotify::UnRegisterDeviceStateCallback(std::string &pkgName) +void DeviceManagerNotify::UnRegisterDeviceStateCallback(const std::string &pkgName) { std::lock_guard autoLock(lock_); deviceStateCallback_.erase(pkgName); } -void DeviceManagerNotify::RegisterDiscoverCallback(std::string &pkgName, uint16_t subscribeId, - std::shared_ptr callback) +void DeviceManagerNotify::RegisterDiscoveryCallback(const std::string &pkgName, uint16_t subscribeId, + std::shared_ptr callback) { std::lock_guard autoLock(lock_); - if (deviceDiscoverCallbacks_.count(pkgName) == 0) { - deviceDiscoverCallbacks_[pkgName] = std::map>(); + if (deviceDiscoveryCallbacks_.count(pkgName) == 0) { + deviceDiscoveryCallbacks_[pkgName] = std::map>(); } - deviceDiscoverCallbacks_[pkgName][subscribeId] = callback; + deviceDiscoveryCallbacks_[pkgName][subscribeId] = callback; } -void DeviceManagerNotify::UnRegisterDiscoverCallback(std::string &pkgName, uint16_t subscribeId) +void DeviceManagerNotify::UnRegisterDiscoveryCallback(const 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); + if (deviceDiscoveryCallbacks_.count(pkgName) > 0) { + deviceDiscoveryCallbacks_[pkgName].erase(subscribeId); + if (deviceDiscoveryCallbacks_[pkgName].empty()) { + deviceDiscoveryCallbacks_.erase(pkgName); } } } -void DeviceManagerNotify::RegisterAuthenticateCallback(std::string &pkgName, std::string &deviceId, - std::shared_ptr callback) +void DeviceManagerNotify::RegisterAuthenticateCallback(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback) { std::lock_guard autoLock(lock_); if (authenticateCallback_.count(pkgName) == 0) { @@ -82,7 +81,7 @@ void DeviceManagerNotify::RegisterAuthenticateCallback(std::string &pkgName, std authenticateCallback_[pkgName][deviceId] = callback; } -void DeviceManagerNotify::UnRegisterAuthenticateCallback(std::string &pkgName, std::string &deviceId) +void DeviceManagerNotify::UnRegisterAuthenticateCallback(const std::string &pkgName, const std::string &deviceId) { std::lock_guard autoLock(lock_); if (authenticateCallback_.count(pkgName) > 0) { @@ -93,185 +92,192 @@ void DeviceManagerNotify::UnRegisterAuthenticateCallback(std::string &pkgName, s } } -void DeviceManagerNotify::UnRegisterPackageCallback(std::string &pkgName) +void DeviceManagerNotify::UnRegisterPackageCallback(const std::string &pkgName) { std::lock_guard autoLock(lock_); deviceStateCallback_.erase(pkgName); - deviceDiscoverCallbacks_.erase(pkgName); + deviceDiscoveryCallbacks_.erase(pkgName); authenticateCallback_.erase(pkgName); dmInitCallback_.erase(pkgName); } -void DeviceManagerNotify::RegisterCheckAuthenticationCallback(std::string &pkgName, std::string &authPara, - std::shared_ptr callback) +void DeviceManagerNotify::RegisterVerifyAuthenticationCallback(const std::string &pkgName, const std::string &authPara, + std::shared_ptr callback) { std::lock_guard autoLock(lock_); - checkauthcallback_[pkgName] = callback; + verifyAuthCallback_[pkgName] = callback; } -void DeviceManagerNotify::UnRegisterCheckAuthenticationCallback(std::string &pkgName) +void DeviceManagerNotify::UnRegisterVerifyAuthenticationCallback(const std::string &pkgName) { std::lock_guard autoLock(lock_); - checkauthcallback_.erase(pkgName); + verifyAuthCallback_.erase(pkgName); } -void DeviceManagerNotify::RegisterDeviceManagerFaCallback(std::string &packageName, - std::shared_ptr callback) +void DeviceManagerNotify::RegisterDeviceManagerFaCallback(const std::string &pkgName, + std::shared_ptr callback) { std::lock_guard autoLock(lock_); - dmFaCallback_[packageName] = callback; + dmFaCallback_[pkgName] = callback; } -void DeviceManagerNotify::UnRegisterDeviceManagerFaCallback(std::string &pkgName) +void DeviceManagerNotify::UnRegisterDeviceManagerFaCallback(const std::string &pkgName) { std::lock_guard autoLock(lock_); + if (dmFaCallback_.count(pkgName) == 0) { + LOGE("DeviceManager UnRegisterDeviceManagerFaCallback not register"); + return; + } dmFaCallback_.erase(pkgName); } - void DeviceManagerNotify::OnRemoteDied() { - DMLOG(DM_LOG_WARN, "DeviceManager : OnRemoteDied"); + LOGW("DeviceManager : OnRemoteDied"); for (auto iter : dmInitCallback_) { iter.second->OnRemoteDied(); } } -void DeviceManagerNotify::OnDeviceOnline(std::string &pkgName, const DmDeviceInfo &deviceInfo) +void DeviceManagerNotify::OnDeviceOnline(const std::string &pkgName, const DmDeviceInfo &deviceInfo) { - DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceOnline pkgName:%s", pkgName.c_str()); + LOGI("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"); + LOGE("DeviceManager OnDeviceOnlinecallback not register"); return; } deviceStateCallback_[pkgName]->OnDeviceOnline(deviceInfo); } -void DeviceManagerNotify::OnDeviceOffline(std::string &pkgName, const DmDeviceInfo &deviceInfo) +void DeviceManagerNotify::OnDeviceOffline(const std::string &pkgName, const DmDeviceInfo &deviceInfo) { - DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceOffline pkgName:%s", pkgName.c_str()); + LOGI("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"); + LOGE("DeviceManager OnDeviceOfflinecallback not register"); return; } deviceStateCallback_[pkgName]->OnDeviceOffline(deviceInfo); } -void DeviceManagerNotify::OnDeviceChanged(std::string &pkgName, const DmDeviceInfo &deviceInfo) +void DeviceManagerNotify::OnDeviceChanged(const std::string &pkgName, const DmDeviceInfo &deviceInfo) { - DMLOG(DM_LOG_INFO, "DeviceManager OnDeviceChanged pkgName:%s", pkgName.c_str()); + LOGI("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"); + LOGE("DeviceManager OnDeviceChangedcallback not register"); return; } deviceStateCallback_[pkgName]->OnDeviceChanged(deviceInfo); } -void DeviceManagerNotify::OnDeviceFound(std::string &pkgName, uint16_t subscribeId, - const DmDeviceInfo &deviceInfo) +void DeviceManagerNotify::OnDeviceReady(const std::string &pkgName, const DmDeviceInfo &deviceInfo) +{ + LOGI("DeviceManager OnDeviceReady pkgName:%s", pkgName.c_str()); + std::lock_guard autoLock(lock_); + if (deviceStateCallback_.count(pkgName) == 0) { + LOGE("DeviceManager OnDeviceReadycallback not register"); + return; + } + deviceStateCallback_[pkgName]->OnDeviceReady(deviceInfo); +} + +void DeviceManagerNotify::OnDeviceFound(const 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); + LOGI("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"); + if (deviceDiscoveryCallbacks_.count(pkgName) == 0) { + LOGE("DeviceManager OnDeviceFound: no register DiscoveryCallback for this package"); return; } - std::map> &discoverCallMap = deviceDiscoverCallbacks_[pkgName]; + std::map> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName]; auto iter = discoverCallMap.find(subscribeId); if (iter == discoverCallMap.end()) { - DMLOG(DM_LOG_ERROR, "DeviceManager OnDeviceFound: no register discoverCallback for subscribeId %d", - subscribeId); + LOGE("DeviceManager OnDeviceFound: no register DiscoveryCallback for subscribeId %d", subscribeId); return; } iter->second->OnDeviceFound(subscribeId, deviceInfo); } -void DeviceManagerNotify::OnDiscoverFailed(std::string &pkgName, uint16_t subscribeId, int32_t failedReason) +void DeviceManagerNotify::OnDiscoveryFailed(const 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); + LOGI("DeviceManager OnDiscoveryFailed 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"); + if (deviceDiscoveryCallbacks_.count(pkgName) == 0) { + LOGE("DeviceManager OnDiscoveryFailed: no register DiscoveryCallback for this package"); return; } - std::map> &discoverCallMap = deviceDiscoverCallbacks_[pkgName]; + std::map> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName]; auto iter = discoverCallMap.find(subscribeId); if (iter == discoverCallMap.end()) { - DMLOG(DM_LOG_ERROR, "DeviceManager OnDiscoverFailed: no register discoverCallback for subscribeId %d", - subscribeId); + LOGE("DeviceManager OnDiscoveryFailed: no register DiscoveryCallback for subscribeId %d", subscribeId); return; } - iter->second->OnDiscoverFailed(subscribeId, failedReason); + iter->second->OnDiscoveryFailed(subscribeId, failedReason); } -void DeviceManagerNotify::OnDiscoverySuccess(std::string &pkgName, uint16_t subscribeId) +void DeviceManagerNotify::OnDiscoverySuccess(const std::string &pkgName, uint16_t subscribeId) { - DMLOG(DM_LOG_INFO, "DeviceManager OnDiscoverySuccess pkgName:%s, subscribeId:%d.", pkgName.c_str(), - subscribeId); + LOGI("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"); + if (deviceDiscoveryCallbacks_.count(pkgName) == 0) { + LOGE("DeviceManager OnDiscoverySuccess: no register DiscoveryCallback for this package"); return; } - std::map> &discoverCallMap = deviceDiscoverCallbacks_[pkgName]; + std::map> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName]; auto iter = discoverCallMap.find(subscribeId); if (iter == discoverCallMap.end()) { - DMLOG(DM_LOG_ERROR, "DeviceManager OnDiscoverySuccess: no register discoverCallback for subscribeId %d", - subscribeId); + LOGE("DeviceManager OnDiscoverySuccess: no register DiscoveryCallback 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) +void DeviceManagerNotify::OnAuthResult(const std::string &pkgName, const std::string &deviceId, + const std::string &token, uint32_t status, uint32_t reason) { - DMLOG(DM_LOG_INFO, "DeviceManagerNotify::OnAuthResult pkgName:%s, status:%d, reason:%d", - pkgName.c_str(), status, reason); + LOGI("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"); + LOGE("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 "); + LOGE("DeviceManager OnAuthResult: no register authCallback for deviceID "); return; } - iter->second->OnAuthResult(deviceId, pinToken, status, reason); + iter->second->OnAuthResult(deviceId, token, 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) +void DeviceManagerNotify::OnVerifyAuthResult(const std::string &pkgName, const 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); + LOGI("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"); + if (verifyAuthCallback_.count(pkgName) == 0) { + LOGE("DeviceManager OnCheckAuthResult: no register authCallback for this package"); return; } - - checkauthcallback_[pkgName]->OnCheckAuthResult(deviceId, resultCode, flag); - checkauthcallback_.erase(pkgName); + verifyAuthCallback_[pkgName]->OnVerifyAuthResult(deviceId, resultCode, flag); + verifyAuthCallback_.erase(pkgName); } void DeviceManagerNotify::OnFaCall(std::string &pkgName, std::string ¶mJson) { - DMLOG(DM_LOG_INFO, "DeviceManager OnFaCallback pkgName:%s", pkgName.c_str()); + LOGI("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"); + LOGE("DeviceManager DmFaCallback not register"); return; } dmFaCallback_[pkgName]->OnCall(paramJson); diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index 3ed612208fe22c1bdc4df266a43a544de9b24027..ca930a219ee6841dc2ad7e73b699741ef78e379e 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -16,17 +16,18 @@ import("//foundation/distributedhardware/devicemanager/devicemanager.gni") ohos_shared_library("devicemanager") { include_dirs = [ + "include", + "${common_path}/include", + "${common_path}/include/ipc", + "${utils_path}/include", + "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/ipc", + "${innerkits_path}/native_cpp/include/ipc/standard", "//third_party/node/src", "//third_party/json/include", - "${common_path}/include", "//foundation/ace/napi/native_engine", "//foundation/ace/napi/interfaces/kits", "//utils/native/base/include", - "include", - "${utils_path}/include/log", - "${common_path}/include/ipc", - "${innerkits_path}/native_cpp/include", - "${innerkits_path}/native_cpp/include/standard", ] sources = [ diff --git a/interfaces/kits/js/include/dm_native_event.h b/interfaces/kits/js/include/dm_native_event.h index 6a3858bddc98ed661bcb7aa1c08614c3323b75ac..3d619bf9912050f18330e1ebe7c4dcc1d7bd7c0b 100644 --- a/interfaces/kits/js/include/dm_native_event.h +++ b/interfaces/kits/js/include/dm_native_event.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,12 +13,13 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_NATIVE_EVENT_H -#define OHOS_DEVICE_MANAGER_NATIVE_EVENT_H +#ifndef OHOS_DM_NATIVE_EVENT_H +#define OHOS_DM_NATIVE_EVENT_H #include #include #include + #include "napi/native_api.h" struct DmEventListener { @@ -41,4 +42,4 @@ protected: std::map> eventMap_; }; -#endif /* OHOS_DEVICE_MANAGER_NATIVE_EVENT_H */ \ No newline at end of file +#endif /* OHOS_DM_NATIVE_EVENT_H */ \ No newline at end of file diff --git a/interfaces/kits/js/include/native_devicemanager_js.h b/interfaces/kits/js/include/native_devicemanager_js.h index c232985c018be57b51ad9f01fcd55485419fe86c..227d48e6cf50958320888e7e499914c06a3f294c 100644 --- a/interfaces/kits/js/include/native_devicemanager_js.h +++ b/interfaces/kits/js/include/native_devicemanager_js.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,20 +13,20 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H -#define OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H +#ifndef OHOS_DM_NATIVE_DEVICEMANAGER_JS_H +#define OHOS_DM_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_app_image_info.h" #include "dm_device_info.h" +#include "dm_native_event.h" #include "dm_subscribe_info.h" +#include "napi/native_api.h" +#include "napi/native_node_api.h" #include "nlohmann/json.hpp" -#include "dm_device_info.h" - #define DM_NAPI_BUF_LENGTH (256) struct AsyncCallbackInfo { @@ -40,6 +40,22 @@ struct AsyncCallbackInfo { int32_t status = -1; }; +struct DeviceInfoAsyncCallbackInfo { + napi_env env = nullptr; + napi_async_work asyncWork = nullptr; + + std::string bundleName; + size_t bundleNameLen = 0; + OHOS::DistributedHardware::DmDeviceInfo deviceInfo; + std::vector devList; + std::string extra; + // OHOS::DistributedHardware::DmFilterOptions filter; + napi_ref callback = nullptr; + napi_value thisVar = nullptr; + napi_deferred deferred = nullptr; + int32_t status = -1; + int32_t isList = 0; +}; struct AuthAsyncCallbackInfo { napi_env env = nullptr; @@ -50,17 +66,16 @@ struct AuthAsyncCallbackInfo { int32_t authType = -1; }; -enum DmNapiDevStateChangeAction { - ONLINE = 0, - READY = 1, - OFFLINE = 2, - CHANGE = 3 -}; +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() {} + explicit DmNapiInitCallback(std::string &bundleName) : bundleName_(bundleName) + { + } + virtual ~DmNapiInitCallback() + { + } void OnRemoteDied() override; private: @@ -69,8 +84,10 @@ private: class DmNapiDeviceStateCallback : public OHOS::DistributedHardware::DeviceStateCallback { public: - explicit DmNapiDeviceStateCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiDeviceStateCallback() {}; + 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; @@ -80,12 +97,14 @@ private: std::string bundleName_; }; -class DmNapiDiscoverCallback : public OHOS::DistributedHardware::DiscoverCallback { +class DmNapiDiscoveryCallback : public OHOS::DistributedHardware::DiscoveryCallback { public: - explicit DmNapiDiscoverCallback(std::string &bundleName) : refCount_(0), bundleName_(bundleName) {} - virtual ~DmNapiDiscoverCallback() {}; + explicit DmNapiDiscoveryCallback(std::string &bundleName) : refCount_(0), bundleName_(bundleName) + { + } + virtual ~DmNapiDiscoveryCallback(){}; void OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; - void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) override; + void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) override; void OnDiscoverySuccess(uint16_t subscribeId) override; void IncreaseRefCount(); void DecreaseRefCount(); @@ -96,31 +115,37 @@ private: std::string bundleName_; }; -class DmNapiAuthenticateCallback : public OHOS::DistributedHardware::AuthenticateCallback { +class DmNapiDeviceManagerFaCallback : public OHOS::DistributedHardware::DeviceManagerFaCallback { public: - explicit DmNapiAuthenticateCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiAuthenticateCallback() {}; - void OnAuthResult(std::string &deviceId, int32_t pinToken, int32_t status, int32_t reason) override; + explicit DmNapiDeviceManagerFaCallback(std::string &bundleName) : bundleName_(bundleName) + { + } + virtual ~DmNapiDeviceManagerFaCallback(){}; + void OnCall(const std::string ¶mJson) override; private: std::string bundleName_; }; -class DmNapiCheckAuthCallback : public OHOS::DistributedHardware::CheckAuthCallback { +class DmNapiAuthenticateCallback : public OHOS::DistributedHardware::AuthenticateCallback { public: - explicit DmNapiCheckAuthCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiCheckAuthCallback() {}; - void OnCheckAuthResult(std::string &deviceId, int32_t resultCode, int32_t flag) override; + explicit DmNapiAuthenticateCallback(std::string &bundleName) : bundleName_(bundleName) + { + } + virtual ~DmNapiAuthenticateCallback(){}; + void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, int32_t reason) override; private: std::string bundleName_; }; -class DmNapiDeviceManagerFaCallback : public OHOS::DistributedHardware::DeviceManagerFaCallback { +class DmNapiVerifyAuthCallback : public OHOS::DistributedHardware::VerifyAuthCallback { public: - explicit DmNapiDeviceManagerFaCallback(std::string &bundleName) : bundleName_(bundleName) {} - virtual ~DmNapiDeviceManagerFaCallback() {}; - void OnCall(std::string ¶mJson) override; + explicit DmNapiVerifyAuthCallback(std::string &bundleName) : bundleName_(bundleName) + { + } + virtual ~DmNapiVerifyAuthCallback(){}; + void OnVerifyAuthResult(const std::string &deviceId, int32_t resultCode, int32_t flag) override; private: std::string bundleName_; @@ -134,58 +159,78 @@ public: 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 SetUserOperationSync(napi_env env, napi_callback_info info); static napi_value GetTrustedDeviceListSync(napi_env env, napi_callback_info info); + static napi_value GetTrustedDeviceList(napi_env env, napi_callback_info info); + static napi_value GetLocalDeviceInfoSync(napi_env env, napi_callback_info info); + static napi_value GetLocalDeviceInfo(napi_env env, napi_callback_info info); + static napi_value UnAuthenticateDevice(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 AuthenticateDevice(napi_env env, napi_callback_info info); static napi_value VerifyAuthInfo(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 napi_value SetUserOperationSync(napi_env env, napi_callback_info info); static napi_value GetAuthenticationParamSync(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 int32_t idx, napi_value &arrayResult); - static void DmAuthParamToJsAuthParam(const napi_env &env, - const OHOS::DistributedHardware::DmAuthParam &authParam, napi_value ¶mResult); + const std::vector &vecDevInfo, + const int32_t idx, napi_value &arrayResult); + static void DmAuthParamToJsAuthParam(const napi_env &env, const OHOS::DistributedHardware::DmAuthParam &authParam, + napi_value ¶mResult); static void SetValueInt32(const napi_env &env, const std::string &fieldStr, const int32_t intValue, - napi_value &result); + 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, char *dest, const int32_t destLen); - static void JsObjectToBool(const napi_env &env, const napi_value &object, - const std::string &fieldStr, bool& fieldRef); + napi_value &result); + static void JsObjectToString(const napi_env &env, const napi_value &object, const std::string &fieldStr, char *dest, + const int32_t destLen); + 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); + int &fieldRef); static std::string JsObjectToString(const napi_env &env, const napi_value &object); static int32_t JsToDmSubscribeInfo(const napi_env &env, const napi_value &object, - OHOS::DistributedHardware::DmSubscribeInfo& info); + OHOS::DistributedHardware::DmSubscribeInfo &info); static void JsToDmDeviceInfo(const napi_env &env, const napi_value &object, - OHOS::DistributedHardware::DmDeviceInfo& info); - static void JsToDmAppImageInfoAndDmExtra(const napi_env &env, const napi_value &object, - OHOS::DistributedHardware::DmAppImageInfo& appImageInfo, std::string &extra, int32_t &authType); + OHOS::DistributedHardware::DmDeviceInfo &info); + static void JsToDmExtra(const napi_env &env, const napi_value &object, std::string &extra, int32_t &authType); static void JsToDmAuthInfo(const napi_env &env, const napi_value &object, std::string &extra); static void JsToDmBuffer(const napi_env &env, const napi_value &object, const std::string &fieldStr, - uint8_t **bufferPtr, int32_t &bufferLen); + uint8_t **bufferPtr, int32_t &bufferLen); static void JsToJsonObject(const napi_env &env, const napi_value &object, const std::string &fieldStr, - nlohmann::json &jsonObj); - static void JsToDmTokenInfo(const napi_env &env, const napi_value &object, - const std::string &fieldStr, nlohmann::json &jsonObj); + nlohmann::json &jsonObj); + static void JsToDmTokenInfo(const napi_env &env, const napi_value &object, const std::string &fieldStr, + nlohmann::json &jsonObj); static void JsToDmAuthExtra(const napi_env &env, const napi_value ¶m, nlohmann::json &jsonObj); + static void DmDeviceInfotoJsDeviceInfo(const napi_env &env, + const OHOS::DistributedHardware::DmDeviceInfo &vecDevInfo, + napi_value &result); void OnDeviceStateChange(DmNapiDevStateChangeAction action, - const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo); + 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 pinToken, int32_t status, int32_t reason); + void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason); + void OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, int32_t reason); void OnVerifyResult(const std::string &deviceId, int32_t resultCode, int32_t flag); void OnDmfaCall(const std::string ¶mJson); - static void DmAuthParamToJsAuthParamy(const napi_env &env, - const OHOS::DistributedHardware::DmAuthParam &authParam, napi_value ¶mResult); + +private: + static napi_value JsOffFrench(napi_env env, int32_t num, napi_value thisVar, napi_value argv[]); + static napi_value JsOnFrench(napi_env env, int32_t num, napi_value thisVar, napi_value argv[]); + static void CallAsyncWorkSync(napi_env env, DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); + static void CallAsyncWork(napi_env env, DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); + static void CallGetTrustedDeviceListStatusSync(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); + static void CallGetTrustedDeviceListStatus(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); + static napi_value CallDeviceList(napi_env env, napi_callback_info info, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); + static void CallGetLocalDeviceInfoSync(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); + static void CallGetLocalDeviceInfo(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo); private: napi_env env_; @@ -196,4 +241,4 @@ private: static AuthAsyncCallbackInfo verifyAsyncCallbackInfo_; }; -#endif // OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H +#endif // OHOS_DM_NATIVE_DEVICEMANAGER_JS_H diff --git a/interfaces/kits/js/src/dm_native_event.cpp b/interfaces/kits/js/src/dm_native_event.cpp index 70084134bc28dbb8824b02eb88786e539d71e445..205fcddc9022f59780fb73983a7621c8d2628f6a 100644 --- a/interfaces/kits/js/src/dm_native_event.cpp +++ b/interfaces/kits/js/src/dm_native_event.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,7 +15,7 @@ #include "dm_native_event.h" -#include "device_manager_log.h" +#include "dm_log.h" using namespace OHOS::DistributedHardware; @@ -38,7 +38,7 @@ DmNativeEvent::~DmNativeEvent() void DmNativeEvent::On(std::string &eventType, napi_value handler) { - DMLOG(DM_LOG_INFO, "DmNativeEvent On in for event: %s", eventType.c_str()); + LOGI("DmNativeEvent On in for event: %s", eventType.c_str()); auto listener = std::make_shared(); listener->eventType = eventType; napi_create_reference(env_, handler, 1, &listener->handlerRef); @@ -47,17 +47,17 @@ void DmNativeEvent::On(std::string &eventType, napi_value handler) void DmNativeEvent::Off(std::string &eventType) { - DMLOG(DM_LOG_INFO, "DmNativeEvent Off in for event: %s", eventType.c_str()); + LOGI("DmNativeEvent Off in for event: %s", eventType.c_str()); napi_handle_scope scope = nullptr; napi_open_handle_scope(env_, &scope); if (scope == nullptr) { - DMLOG(DM_LOG_ERROR, "scope is nullptr"); + LOGE("scope is nullptr"); return; } auto iter = eventMap_.find(eventType); if (iter == eventMap_.end()) { - DMLOG(DM_LOG_ERROR, "eventType %s not find", eventType.c_str()); + LOGE("eventType %s not find", eventType.c_str()); return; } auto listener = iter->second; @@ -68,38 +68,38 @@ void DmNativeEvent::Off(std::string &eventType) void DmNativeEvent::OnEvent(const std::string &eventType, size_t argc, const napi_value *argv) { - DMLOG(DM_LOG_INFO, "OnEvent for %s", eventType.c_str()); + LOGI("OnEvent for %s", eventType.c_str()); napi_handle_scope scope = nullptr; napi_open_handle_scope(env_, &scope); if (scope == nullptr) { - DMLOG(DM_LOG_ERROR, "scope is nullptr"); + LOGE("scope is nullptr"); return; } auto iter = eventMap_.find(eventType); if (iter == eventMap_.end()) { - DMLOG(DM_LOG_ERROR, "eventType %s not find", eventType.c_str()); + LOGE("eventType %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) { - DMLOG(DM_LOG_ERROR, "napi_get_reference_value thisVar for %s failed, status=%d", eventType.c_str(), status); + LOGE("napi_get_reference_value thisVar for %s failed, status=%d", eventType.c_str(), status); return; } napi_value handler = nullptr; status = napi_get_reference_value(env_, listener->handlerRef, &handler); if (status != napi_ok) { - DMLOG(DM_LOG_ERROR, "napi_get_reference_value handler for %s failed, status=%d", eventType.c_str(), status); + LOGE("napi_get_reference_value handler for %s failed, status=%d", eventType.c_str(), status); return; } napi_value callResult = nullptr; status = napi_call_function(env_, thisVar, handler, argc, argv, &callResult); if (status != napi_ok) { - DMLOG(DM_LOG_ERROR, "napi_call_function for %s failed, status=%d", eventType.c_str(), status); + LOGE("napi_call_function for %s failed, status=%d", eventType.c_str(), status); return; } napi_close_handle_scope(env_, scope); diff --git a/interfaces/kits/js/src/native_devicemanager_js.cpp b/interfaces/kits/js/src/native_devicemanager_js.cpp index bb38a37fde7c93839bd5998f327b0aeaea662cf0..96bd2c65032f4c0bd63034a2718a185cbf5a3409 100644 --- a/interfaces/kits/js/src/native_devicemanager_js.cpp +++ b/interfaces/kits/js/src/native_devicemanager_js.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -16,49 +16,45 @@ #include "native_devicemanager_js.h" #include -#include "nlohmann/json.hpp" #include "device_manager.h" -#include "device_manager_log.h" -#include "constants.h" +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" +#include "nlohmann/json.hpp" 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; \ +#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_DMFA_CALLBACK = "dmFaCallback"; +const std::string DM_NAPI_EVENT_DEVICE_DISCOVERY_FAIL = "discoveryFail"; const std::string DM_NAPI_EVENT_DEVICE_SERVICE_DIE = "serviceDie"; -const char *DM_CAPABILITY_OSD = "osdCapability"; const std::string DEVICE_MANAGER_NAPI_CLASS_NAME = "DeviceManager"; +const std::string DM_NAPI_EVENT_DMFA_CALLBACK = "dmFaCallback"; const int32_t DM_NAPI_ARGS_ONE = 1; const int32_t DM_NAPI_ARGS_TWO = 2; const int32_t DM_NAPI_ARGS_THREE = 3; const int32_t DM_NAPI_SUB_ID_MAX = 65535; -const int32_t DM_AUTH_TYPE_PINCODE = 1; const int32_t DM_AUTH_DIRECTION_CLIENT = 1; -const int32_t DM_NAPI_SUBSCRIBE_CAPABILITY_DDMP = 0; -const int32_t DM_NAPI_SUBSCRIBE_CAPABILITY_OSD = 1; - std::map g_deviceManagerMap; std::map> g_initCallbackMap; std::map> g_deviceStateCallbackMap; -std::map> g_discoverCallbackMap; +std::map> g_DiscoveryCallbackMap; std::map> g_authCallbackMap; -std::map> g_checkAuthCallbackMap; +std::map> g_verifyAuthCallbackMap; std::map> g_dmfaCallbackMap; -} +} // namespace napi_ref DeviceManagerNapi::sConstructor_ = nullptr; AuthAsyncCallbackInfo DeviceManagerNapi::authAsyncCallbackInfo_; @@ -68,7 +64,7 @@ void DmNapiInitCallback::OnRemoteDied() { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnRemoteDied, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnRemoteDied, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnEvent("serviceDie", 0, nullptr); @@ -78,7 +74,7 @@ void DmNapiDeviceStateCallback::OnDeviceOnline(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDeviceOnline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDeviceOnline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::ONLINE, deviceInfo); @@ -88,7 +84,7 @@ void DmNapiDeviceStateCallback::OnDeviceReady(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDeviceOnline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDeviceOnline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::READY, deviceInfo); @@ -98,7 +94,7 @@ void DmNapiDeviceStateCallback::OnDeviceOffline(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDeviceOffline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDeviceOffline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::OFFLINE, deviceInfo); @@ -108,90 +104,81 @@ void DmNapiDeviceStateCallback::OnDeviceChanged(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDeviceChanged, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDeviceChanged, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::CHANGE, deviceInfo); } -void DmNapiDiscoverCallback::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) +void DmNapiDiscoveryCallback::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDeviceFound, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDeviceFound, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - DMLOG(DM_LOG_INFO, "OnDeviceFound for %s, subscribeId %d", bundleName_.c_str(), (int32_t)subscribeId); + LOGI("OnDeviceFound for %s, subscribeId %d", bundleName_.c_str(), (int32_t)subscribeId); deviceManagerNapi->OnDeviceFound(subscribeId, deviceInfo); } -void DmNapiDiscoverCallback::OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) +void DmNapiDiscoveryCallback::OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDiscoverFailed, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDiscoveryFailed, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - deviceManagerNapi->OnDiscoverFailed(subscribeId, failedReason); + deviceManagerNapi->OnDiscoveryFailed(subscribeId, failedReason); } -void DmNapiDiscoverCallback::OnDiscoverySuccess(uint16_t subscribeId) +void DmNapiDiscoveryCallback::OnDiscoverySuccess(uint16_t subscribeId) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnDiscoverySuccess, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnDiscoverySuccess, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - DMLOG(DM_LOG_INFO, "DiscoverySuccess for %s, subscribeId %d", bundleName_.c_str(), (int32_t)subscribeId); + LOGI("DiscoverySuccess for %s, subscribeId %d", bundleName_.c_str(), (int32_t)subscribeId); } -void DmNapiDiscoverCallback::IncreaseRefCount() +void DmNapiDiscoveryCallback::IncreaseRefCount() { refCount_++; } -void DmNapiDiscoverCallback::DecreaseRefCount() +void DmNapiDiscoveryCallback::DecreaseRefCount() { refCount_--; } -int32_t DmNapiDiscoverCallback::GetRefCount() +int32_t DmNapiDiscoveryCallback::GetRefCount() { return refCount_; } -void DmNapiAuthenticateCallback::OnAuthResult(std::string &deviceId, int32_t pinToken, int32_t status, int32_t reason) +void DmNapiAuthenticateCallback::OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, + int32_t reason) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnAuthResult, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnAuthResult, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - deviceManagerNapi->OnAuthResult(deviceId, pinToken, status, reason); + deviceManagerNapi->OnAuthResult(deviceId, token, status, reason); } -void DmNapiCheckAuthCallback::OnCheckAuthResult(std::string &deviceId, int32_t resultCode, int32_t flag) +void DmNapiVerifyAuthCallback::OnVerifyAuthResult(const std::string &deviceId, int32_t resultCode, int32_t flag) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnCheckAuthResult, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + LOGE("OnCheckAuthResult, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnVerifyResult(deviceId, resultCode, flag); } -void DmNapiDeviceManagerFaCallback::OnCall(std::string ¶mJson) -{ - DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); - if (deviceManagerNapi == nullptr) { - DMLOG(DM_LOG_ERROR, "OnCall, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); - return; - } - deviceManagerNapi->OnDmfaCall(paramJson); -} - DeviceManagerNapi::DeviceManagerNapi(napi_env env, napi_value thisVar) : DmNativeEvent(env, thisVar) { env_ = env; @@ -214,7 +201,8 @@ DeviceManagerNapi *DeviceManagerNapi::GetDeviceManagerNapi(std::string &buldleNa return iter->second; } -void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, const DmDeviceInfo &deviceInfo) +void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, + const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) { napi_value result = nullptr; napi_create_object(env_, &result); @@ -232,7 +220,7 @@ void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, c void DeviceManagerNapi::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) { - DMLOG(DM_LOG_INFO, "OnDeviceFound for subscribeId %d", (int32_t)subscribeId); + LOGI("OnDeviceFound for subscribeId %d", (int32_t)subscribeId); napi_value result = nullptr; napi_create_object(env_, &result); SetValueInt32(env_, "subscribeId", (int)subscribeId, result); @@ -247,9 +235,9 @@ void DeviceManagerNapi::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo & OnEvent("deviceFound", DM_NAPI_ARGS_ONE, &result); } -void DeviceManagerNapi::OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) +void DeviceManagerNapi::OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) { - DMLOG(DM_LOG_INFO, "OnDiscoverFailed for subscribeId %d", (int32_t)subscribeId); + LOGI("OnDiscoveryFailed for subscribeId %d", (int32_t)subscribeId); napi_value result = nullptr; napi_create_object(env_, &result); SetValueInt32(env_, "subscribeId", (int)subscribeId, result); @@ -257,32 +245,21 @@ void DeviceManagerNapi::OnDiscoverFailed(uint16_t subscribeId, int32_t failedRea OnEvent("discoverFail", DM_NAPI_ARGS_ONE, &result); } -void DeviceManagerNapi::OnDmfaCall(const std::string ¶mJson) -{ - DMLOG(DM_LOG_INFO, "OnCall for paramJson"); - napi_value result = nullptr; - napi_create_object(env_, &result); - SetValueUtf8String(env_, "param", paramJson, result); - OnEvent("dmFaCallback", DM_NAPI_ARGS_ONE, &result); -} - -void DeviceManagerNapi::OnAuthResult(const std::string &deviceId, int32_t pinToken, int32_t status, int32_t reason) +void DeviceManagerNapi::OnAuthResult(const std::string &deviceId, const std::string &token, int32_t status, + int32_t reason) { - DMLOG(DM_LOG_INFO, "OnAuthResult for status: %d, reason: %d", status, reason); + LOGI("OnAuthResult for status: %d, reason: %d", status, reason); napi_value thisVar = nullptr; napi_get_reference_value(env_, thisVarRef_, &thisVar); - napi_value result[DM_NAPI_ARGS_TWO] = { 0 }; + napi_value result[DM_NAPI_ARGS_TWO] = {0}; if (status == 0) { - DMLOG(DM_LOG_INFO, "OnAuthResult success"); + LOGI("OnAuthResult success"); napi_get_undefined(env_, &result[0]); napi_create_object(env_, &result[1]); SetValueUtf8String(env_, "deviceId", deviceId, result[1]); - if (authAsyncCallbackInfo_.authType == DM_AUTH_TYPE_PINCODE) { - SetValueInt32(env_, "pinTone", pinToken, result[1]); - } } else { - DMLOG(DM_LOG_INFO, "OnAuthResult failed"); + LOGI("OnAuthResult failed"); napi_create_object(env_, &result[0]); SetValueInt32(env_, "code", status, result[0]); SetValueInt32(env_, "reason", reason, result[0]); @@ -296,17 +273,17 @@ void DeviceManagerNapi::OnAuthResult(const std::string &deviceId, int32_t pinTok napi_call_function(env_, nullptr, handler, DM_NAPI_ARGS_TWO, &result[0], &callResult); napi_delete_reference(env_, verifyAsyncCallbackInfo_.callback); } else { - DMLOG(DM_LOG_ERROR, "handler is nullptr"); + LOGE("handler is nullptr"); } g_authCallbackMap.erase(bundleName_); } void DeviceManagerNapi::OnVerifyResult(const std::string &deviceId, int32_t resultCode, int32_t flag) { - DMLOG(DM_LOG_INFO, "OnVerifyResult for resultCode: %d, flag: %d", resultCode, flag); + LOGI("OnVerifyResult for resultCode: %d, flag: %d", resultCode, flag); napi_value thisVar = nullptr; napi_get_reference_value(env_, thisVarRef_, &thisVar); - napi_value result[DM_NAPI_ARGS_TWO] = { 0 }; + napi_value result[DM_NAPI_ARGS_TWO] = {0}; if (resultCode == 0) { napi_get_undefined(env_, &result[0]); napi_create_object(env_, &result[1]); @@ -325,13 +302,13 @@ void DeviceManagerNapi::OnVerifyResult(const std::string &deviceId, int32_t resu napi_call_function(env_, nullptr, handler, DM_NAPI_ARGS_TWO, &result[0], &callResult); napi_delete_reference(env_, verifyAsyncCallbackInfo_.callback); } else { - DMLOG(DM_LOG_ERROR, "handler is nullptr"); + LOGE("handler is nullptr"); } - g_checkAuthCallbackMap.erase(bundleName_); + g_verifyAuthCallbackMap.erase(bundleName_); } void DeviceManagerNapi::SetValueUtf8String(const napi_env &env, const std::string &fieldStr, const std::string &str, - napi_value &result) + napi_value &result) { napi_value value = nullptr; napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value); @@ -339,16 +316,15 @@ void DeviceManagerNapi::SetValueUtf8String(const napi_env &env, const std::strin } void DeviceManagerNapi::SetValueInt32(const napi_env &env, const std::string &fieldStr, const int32_t intValue, - napi_value &result) + napi_value &result) { napi_value value = nullptr; 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 int32_t idx, napi_value &arrayResult) +void DeviceManagerNapi::DeviceInfoToJsArray(const napi_env &env, const std::vector &vecDevInfo, + const int32_t idx, napi_value &arrayResult) { napi_value result = nullptr; napi_create_object(env, &result); @@ -359,20 +335,19 @@ void DeviceManagerNapi::DeviceInfoToJsArray(const napi_env &env, napi_status status = napi_set_element(env, arrayResult, idx, result); if (status != napi_ok) { - DMLOG(DM_LOG_ERROR, "DmDeviceInfo To JsArray set element error: %d", status); + LOGE("DmDeviceInfo To JsArray set element error: %d", status); } } -void DeviceManagerNapi::DmAuthParamToJsAuthParamy(const napi_env &env, - const DmAuthParam &authParam, napi_value ¶mResult) +void DeviceManagerNapi::DmAuthParamToJsAuthParam(const napi_env &env, const DmAuthParam &authParam, + napi_value ¶mResult) { - DMLOG(DM_LOG_INFO, "DmAuthParamToJsAuthParamy in"); - SetValueInt32(env, "authType", authParam.authType, paramResult); - napi_value extraInfo = nullptr; napi_create_object(env, &extraInfo); SetValueInt32(env, "direction", authParam.direction, extraInfo); - SetValueInt32(env, "pinToken", authParam.pinToken, extraInfo); + SetValueInt32(env, "authType", authParam.authType, paramResult); + SetValueInt32(env, "pinToken", stoi(authParam.authToken), extraInfo); + if (authParam.direction == DM_AUTH_DIRECTION_CLIENT) { napi_set_named_property(env, paramResult, "extraInfo", extraInfo); return; @@ -391,8 +366,8 @@ void DeviceManagerNapi::DmAuthParamToJsAuthParamy(const napi_env &env, napi_value appIconBuffer = nullptr; napi_create_arraybuffer(env, appIconLen, &appIcon, &appIconBuffer); if (appIcon != nullptr && - memcpy_s(appIcon, appIconLen, reinterpret_cast(authParam.imageinfo.GetAppIcon()), - appIconLen) == 0) { + memcpy_s(appIcon, appIconLen, reinterpret_cast(authParam.imageinfo.GetAppIcon()), + appIconLen) == 0) { napi_value appIconArray = nullptr; napi_create_typedarray(env, napi_uint8_array, appIconLen, appIconBuffer, 0, &appIconArray); napi_set_named_property(env, paramResult, "appIcon", appIconArray); @@ -406,7 +381,7 @@ void DeviceManagerNapi::DmAuthParamToJsAuthParamy(const napi_env &env, napi_create_arraybuffer(env, appThumbnailLen, &appThumbnail, &appThumbnailBuffer); if (appThumbnail != nullptr && memcpy_s(appThumbnail, appThumbnailLen, - reinterpret_cast(authParam.imageinfo.GetAppThumbnail()), appThumbnailLen) == 0) { + reinterpret_cast(authParam.imageinfo.GetAppThumbnail()), appThumbnailLen) == 0) { napi_value appThumbnailArray = nullptr; napi_create_typedarray(env, napi_uint8_array, appThumbnailLen, appThumbnailBuffer, 0, &appThumbnailArray); napi_set_named_property(env, paramResult, "appThumbnail", appThumbnailArray); @@ -414,8 +389,8 @@ void DeviceManagerNapi::DmAuthParamToJsAuthParamy(const napi_env &env, } } -void DeviceManagerNapi::JsObjectToString(const napi_env &env, const napi_value &object, - const std::string &fieldStr, char *dest, const int32_t destLen) +void DeviceManagerNapi::JsObjectToString(const napi_env &env, const napi_value &object, const std::string &fieldStr, + char *dest, const int32_t destLen) { bool hasProperty = false; NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); @@ -429,13 +404,13 @@ void DeviceManagerNapi::JsObjectToString(const napi_env &env, const napi_value & size_t result = 0; NAPI_CALL_RETURN_VOID(env, napi_get_value_string_utf8(env, field, dest, destLen, &result)); } else { - DMLOG(DM_LOG_ERROR, "devicemanager napi js to str no property: %s", fieldStr.c_str()); + LOGE("devicemanager napi js to str no property: %s", fieldStr.c_str()); } } std::string DeviceManagerNapi::JsObjectToString(const napi_env &env, const napi_value ¶m) { - DMLOG(DM_LOG_INFO, "JsObjectToString in."); + LOGI("JsObjectToString in."); size_t size = 0; if (napi_get_value_string_utf8(env, param, nullptr, 0, &size) != napi_ok) { return ""; @@ -461,8 +436,8 @@ std::string DeviceManagerNapi::JsObjectToString(const napi_env &env, const napi_ return value; } -void DeviceManagerNapi::JsObjectToInt(const napi_env &env, const napi_value &object, - const std::string &fieldStr, int32_t &fieldRef) +void DeviceManagerNapi::JsObjectToInt(const napi_env &env, const napi_value &object, const std::string &fieldStr, + int32_t &fieldRef) { bool hasProperty = false; NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); @@ -475,12 +450,12 @@ void DeviceManagerNapi::JsObjectToInt(const napi_env &env, const napi_value &obj NAPI_ASSERT_RETURN_VOID(env, valueType == napi_number, "Wrong argument type. Number expected."); napi_get_value_int32(env, field, &fieldRef); } else { - DMLOG(DM_LOG_ERROR, "devicemanager napi js to int no property: %s", fieldStr.c_str()); + LOGE("devicemanager napi js to int no property: %s", fieldStr.c_str()); } } -void DeviceManagerNapi::JsObjectToBool(const napi_env &env, const napi_value &object, - const std::string &fieldStr, bool &fieldRef) +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)); @@ -493,17 +468,16 @@ void DeviceManagerNapi::JsObjectToBool(const napi_env &env, const napi_value &ob NAPI_ASSERT_RETURN_VOID(env, valueType == napi_boolean, "Wrong argument type. Bool expected."); napi_get_value_bool(env, field, &fieldRef); } else { - DMLOG(DM_LOG_ERROR, "devicemanager napi js to bool no property: %s", fieldStr.c_str()); + LOGE("devicemanager napi js to bool no property: %s", fieldStr.c_str()); } } -int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env &env, const napi_value &object, - DmSubscribeInfo &info) +int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env &env, const napi_value &object, DmSubscribeInfo &info) { int32_t subscribeId = -1; JsObjectToInt(env, object, "subscribeId", subscribeId); if (subscribeId < 0 || subscribeId > DM_NAPI_SUB_ID_MAX) { - DMLOG(DM_LOG_ERROR, "DeviceManagerNapi::JsToDmSubscribeInfo, subscribeId error, subscribeId: %d ", subscribeId); + LOGE("DeviceManagerNapi::JsToDmSubscribeInfo, subscribeId error, subscribeId: %d ", subscribeId); return -1; } @@ -532,20 +506,19 @@ int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env &env, const napi_v return 0; } -void DeviceManagerNapi::JsToDmDeviceInfo(const napi_env &env, const napi_value &object, - DmDeviceInfo &info) +void DeviceManagerNapi::JsToDmDeviceInfo(const napi_env &env, const napi_value &object, DmDeviceInfo &info) { JsObjectToString(env, object, "deviceId", info.deviceId, sizeof(info.deviceId)); JsObjectToString(env, object, "deviceName", info.deviceName, sizeof(info.deviceName)); int32_t deviceType = -1; JsObjectToInt(env, object, "deviceType", deviceType); - info.deviceTypeId = (DMDeviceType)deviceType; + info.deviceTypeId = (DmDeviceType)deviceType; } -void DeviceManagerNapi::JsToDmAppImageInfoAndDmExtra(const napi_env &env, const napi_value &object, - DmAppImageInfo& appImageInfo, std::string &extra, int32_t &authType) +void DeviceManagerNapi::JsToDmExtra(const napi_env &env, const napi_value &object, std::string &extra, + int32_t &authType) { - DMLOG(DM_LOG_INFO, "JsToDmAppImageInfoAndDmExtra in."); + LOGI("JsToDmExtra in."); int32_t authTypeTemp = -1; JsObjectToInt(env, object, "authType", authTypeTemp); authType = authTypeTemp; @@ -557,8 +530,6 @@ void DeviceManagerNapi::JsToDmAppImageInfoAndDmExtra(const napi_env &env, const uint8_t *appThumbnailBufferPtr = nullptr; int32_t appThumbnailBufferLen = 0; JsToDmBuffer(env, object, "appThumbnail", &appThumbnailBufferPtr, appThumbnailBufferLen); - - appImageInfo.Reset(appIconBufferPtr, appIconBufferLen, appThumbnailBufferPtr, appThumbnailBufferLen); if (appIconBufferPtr != nullptr) { free(appIconBufferPtr); appIconBufferPtr = nullptr; @@ -574,17 +545,17 @@ void DeviceManagerNapi::JsToDmAppImageInfoAndDmExtra(const napi_env &env, const JsToJsonObject(env, object, "extraInfo", jsonObj); extra = jsonObj.dump(); - DMLOG(DM_LOG_INFO, "appIconLen %d, appThumbnailLen %d", appIconBufferLen, appThumbnailBufferLen); + LOGI("appIconLen %d, appThumbnailLen %d", appIconBufferLen, appThumbnailBufferLen); } -void DeviceManagerNapi::JsToDmBuffer(const napi_env &env, const napi_value &object, - const std::string &fieldStr, uint8_t **bufferPtr, int32_t &bufferLen) +void DeviceManagerNapi::JsToDmBuffer(const napi_env &env, const napi_value &object, const std::string &fieldStr, + uint8_t **bufferPtr, int32_t &bufferLen) { - DMLOG(DM_LOG_INFO, "JsToDmBuffer in."); + LOGI("JsToDmBuffer in."); bool hasProperty = false; NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); if (!hasProperty) { - DMLOG(DM_LOG_ERROR, "devicemanager napi js to str no property: %s", fieldStr.c_str()); + LOGE("devicemanager napi js to str no property: %s", fieldStr.c_str()); return; } @@ -595,19 +566,18 @@ void DeviceManagerNapi::JsToDmBuffer(const napi_env &env, const napi_value &obje napi_value buffer = nullptr; size_t offset = 0; uint8_t *data = nullptr; - napi_get_typedarray_info(env, field, &type, - &length, reinterpret_cast(&data), &buffer, &offset); + napi_get_typedarray_info(env, field, &type, &length, reinterpret_cast(&data), &buffer, &offset); if (type != napi_uint8_array || length == 0 || data == nullptr) { - DMLOG(DM_LOG_ERROR, "Invaild AppIconInfo"); + LOGE("Invaild AppIconInfo"); return; } - *bufferPtr = (uint8_t*)calloc(sizeof(uint8_t), length); + *bufferPtr = (uint8_t *)calloc(sizeof(uint8_t), length); if (*bufferPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "low memory, calloc return nullptr, length is %d, filed %s", length, fieldStr.c_str()); + LOGE("low memory, calloc return nullptr, length is %d, filed %s", length, fieldStr.c_str()); return; } if (memcpy_s(*bufferPtr, length, data, length) != 0) { - DMLOG(DM_LOG_ERROR, "memcpy_s failed, filed %s", fieldStr.c_str()); + LOGE("memcpy_s failed, filed %s", fieldStr.c_str()); free(*bufferPtr); *bufferPtr = nullptr; return; @@ -615,14 +585,14 @@ void DeviceManagerNapi::JsToDmBuffer(const napi_env &env, const napi_value &obje bufferLen = length; } -void DeviceManagerNapi::JsToJsonObject(const napi_env &env, const napi_value &object, - const std::string &fieldStr, nlohmann::json &jsonObj) +void DeviceManagerNapi::JsToJsonObject(const napi_env &env, const napi_value &object, const std::string &fieldStr, + nlohmann::json &jsonObj) { - DMLOG(DM_LOG_INFO, "JsToJsonObject in."); + LOGI("JsToJsonObject in."); bool hasProperty = false; NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); if (!hasProperty) { - DMLOG(DM_LOG_ERROR, "devicemanager napi js to str no property: %s", fieldStr.c_str()); + LOGE("devicemanager napi js to str no property: %s", fieldStr.c_str()); return; } @@ -633,7 +603,7 @@ void DeviceManagerNapi::JsToJsonObject(const napi_env &env, const napi_value &ob uint32_t jsProCount = 0; napi_get_property_names(env, jsonField, &jsProNameList); napi_get_array_length(env, jsProNameList, &jsProCount); - DMLOG(DM_LOG_INFO, "Property size=%d.", jsProCount); + LOGI("Property size=%d.", jsProCount); napi_value jsProName = nullptr; napi_value jsProValue = nullptr; @@ -645,29 +615,29 @@ void DeviceManagerNapi::JsToJsonObject(const napi_env &env, const napi_value &ob switch (jsValueType) { case napi_string: { std::string natValue = JsObjectToString(env, jsProValue); - DMLOG(DM_LOG_INFO, "Property name=%s, string, value=%s", strProName.c_str(), natValue.c_str()); + LOGI("Property name=%s, string, value=%s", strProName.c_str(), natValue.c_str()); jsonObj[strProName] = natValue; break; } case napi_boolean: { bool elementValue = false; napi_get_value_bool(env, jsProValue, &elementValue); - DMLOG(DM_LOG_INFO, "Property name=%s, boolean, value=%d.", strProName.c_str(), elementValue); + LOGI("Property name=%s, boolean, value=%d.", strProName.c_str(), elementValue); jsonObj[strProName] = elementValue; break; } case napi_number: { int32_t elementValue = 0; if (napi_get_value_int32(env, jsProValue, &elementValue) != napi_ok) { - DMLOG(DM_LOG_ERROR, "Property name=%s, Property int32_t parse error", strProName.c_str()); + LOGE("Property name=%s, Property int32_t parse error", strProName.c_str()); } else { jsonObj[strProName] = elementValue; - DMLOG(DM_LOG_INFO, "Property name=%s, number, value=%d.", strProName.c_str(), elementValue); + LOGI("Property name=%s, number, value=%d.", strProName.c_str(), elementValue); } break; } default: { - DMLOG(DM_LOG_ERROR, "Property name=%s, value type not support.", strProName.c_str()); + LOGE("Property name=%s, value type not support.", strProName.c_str()); break; } } @@ -676,27 +646,32 @@ void DeviceManagerNapi::JsToJsonObject(const napi_env &env, const napi_value &ob void DeviceManagerNapi::JsToDmAuthInfo(const napi_env &env, const napi_value &object, std::string &extra) { - DMLOG(DM_LOG_INFO, "%s called.", __func__); + LOGI("%s called.", __func__); int32_t authType = -1; int32_t token = -1; JsObjectToInt(env, object, "authType", authType); JsObjectToInt(env, object, "token", token); - nlohmann::json jsonObj; jsonObj[AUTH_TYPE] = authType; - if (authType == DM_AUTH_TYPE_PINCODE) { - jsonObj[PIN_TOKEN] = token; - } else { - jsonObj[TOKEN] = token; - } + jsonObj[PIN_TOKEN] = token; JsToJsonObject(env, object, "extraInfo", jsonObj); extra = jsonObj.dump(); } +void DeviceManagerNapi::DmDeviceInfotoJsDeviceInfo(const napi_env &env, const DmDeviceInfo &vecDevInfo, + napi_value &result) +{ + napi_create_object(env, &result); + + SetValueUtf8String(env, "deviceId", vecDevInfo.deviceId, result); + SetValueUtf8String(env, "deviceName", vecDevInfo.deviceName, result); + SetValueInt32(env, "deviceType", (int)vecDevInfo.deviceTypeId, result); +} + void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &eventType) { - DMLOG(DM_LOG_ERROR, "CreateDmCallback for bunderName %s eventType %s", bundleName.c_str(), eventType.c_str()); + LOGE("CreateDmCallback for bundleName %s eventType %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()) { @@ -704,7 +679,7 @@ void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &e std::string extra = ""; int32_t ret = DeviceManager::GetInstance().RegisterDevStateCallback(bundleName, extra, callback); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); + LOGE("RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); return; } g_deviceStateCallbackMap[bundleName] = callback; @@ -712,18 +687,18 @@ void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &e 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; + if (eventType == DM_NAPI_EVENT_DEVICE_FOUND || eventType == DM_NAPI_EVENT_DEVICE_DISCOVERY_FAIL) { + std::shared_ptr DiscoveryCallback = nullptr; + auto iter = g_DiscoveryCallbackMap.find(bundleName); + if (iter == g_DiscoveryCallbackMap.end()) { + auto callback = std::make_shared(bundleName); + g_DiscoveryCallbackMap[bundleName] = callback; + DiscoveryCallback = callback; } else { - discoverCallback = iter->second; + DiscoveryCallback = iter->second; } - discoverCallback->IncreaseRefCount(); + DiscoveryCallback->IncreaseRefCount(); return; } @@ -733,7 +708,7 @@ void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &e auto callback = std::make_shared(bundleName); int32_t ret = DeviceManager::GetInstance().RegisterDeviceManagerFaCallback(bundleName, callback); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "RegisterDeviceManagerFaCallback failed for bunderName %s", bundleName.c_str()); + LOGE("RegisterDeviceManagerFaCallback failed for bunderName %s", bundleName.c_str()); return; } g_dmfaCallbackMap[bundleName] = callback; @@ -747,29 +722,29 @@ void DeviceManagerNapi::ReleaseDmCallback(std::string &bundleName, std::string & if (eventType == DM_NAPI_EVENT_DEVICE_STATE_CHANGE) { auto iter = g_deviceStateCallbackMap.find(bundleName); if (iter == g_deviceStateCallbackMap.end()) { - DMLOG(DM_LOG_ERROR, "ReleaseDmCallback: cannot find stateCallback for bunderName %s", bundleName.c_str()); + LOGE("ReleaseDmCallback: cannot find stateCallback for bunderName %s", bundleName.c_str()); return; } int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(bundleName); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); + LOGE("RegisterDevStateCallback failed for bunderName %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()) { + if (eventType == DM_NAPI_EVENT_DEVICE_FOUND || eventType == DM_NAPI_EVENT_DEVICE_DISCOVERY_FAIL) { + std::shared_ptr DiscoveryCallback = nullptr; + auto iter = g_DiscoveryCallbackMap.find(bundleName); + if (iter == g_DiscoveryCallbackMap.end()) { return; } - discoverCallback = iter->second; - discoverCallback->DecreaseRefCount(); - if (discoverCallback->GetRefCount() == 0) { - g_discoverCallbackMap.erase(bundleName); + DiscoveryCallback = iter->second; + DiscoveryCallback->DecreaseRefCount(); + if (DiscoveryCallback->GetRefCount() == 0) { + g_DiscoveryCallbackMap.erase(bundleName); } return; } @@ -777,12 +752,12 @@ void DeviceManagerNapi::ReleaseDmCallback(std::string &bundleName, std::string & if (eventType == DM_NAPI_EVENT_DMFA_CALLBACK) { auto iter = g_dmfaCallbackMap.find(bundleName); if (iter == g_dmfaCallbackMap.end()) { - DMLOG(DM_LOG_ERROR, "cannot find dmFaCallback for bunderName %s", bundleName.c_str()); + LOGE("cannot find dmFaCallback for bunderName %s", bundleName.c_str()); return; } int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(bundleName); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); + LOGE("RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); return; } g_dmfaCallbackMap.erase(bundleName); @@ -790,11 +765,34 @@ void DeviceManagerNapi::ReleaseDmCallback(std::string &bundleName, std::string & } } +napi_value DeviceManagerNapi::GetAuthenticationParamSync(napi_env env, napi_callback_info info) +{ + LOGI("GetAuthenticationParamSync in"); + size_t argc = 0; + napi_value thisVar = nullptr; + napi_value resultParam = 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)); + DmAuthParam authParam; + int32_t ret = DeviceManager::GetInstance().GetFaParam(deviceManagerWrapper->bundleName_, authParam); + if (ret != 0) { + LOGE("GetAuthenticationParam for %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); + napi_get_undefined(env, &resultParam); + return resultParam; + } + napi_create_object(env, &resultParam); + DmAuthParamToJsAuthParam(env, authParam, resultParam); + return resultParam; +} + napi_value DeviceManagerNapi::SetUserOperationSync(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "SetUserOperationSync in"); + LOGI("SetUserOperationSync in"); GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); - napi_valuetype valueType = napi_undefined; + napi_valuetype valueType; napi_typeof(env, argv[0], &valueType); NAPI_ASSERT(env, valueType == napi_number, "Wrong argument type. Object expected."); @@ -804,83 +802,437 @@ napi_value DeviceManagerNapi::SetUserOperationSync(napi_env env, napi_callback_i napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); int32_t ret = DeviceManager::GetInstance().SetUserOperation(deviceManagerWrapper->bundleName_, action); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "SetUserOperation for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); + LOGE("SetUserOperation for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); } napi_value result = nullptr; napi_get_undefined(env, &result); return result; } -napi_value DeviceManagerNapi::GetAuthenticationParamSync(napi_env env, napi_callback_info info) +void DeviceManagerNapi::CallGetTrustedDeviceListStatusSync(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) { - DMLOG(DM_LOG_INFO, "GetAuthenticationParamSync in"); - size_t argc = 0; - napi_value thisVar = nullptr; - napi_value resultParam = nullptr; + for (unsigned int i = 0; i < deviceInfoAsyncCallbackInfo->devList.size(); i++) { + LOGI("DeviceManager::GetTrustedDeviceList deviceId:%s deviceName:%s deviceTypeId:%d ", + deviceInfoAsyncCallbackInfo->devList[i].deviceId, deviceInfoAsyncCallbackInfo->devList[i].deviceName, + deviceInfoAsyncCallbackInfo->devList[i].deviceTypeId); + } - NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); - NAPI_ASSERT(env, argc == 0, "Wrong number of arguments"); + napi_value array[DM_NAPI_ARGS_TWO] = {0}; + if (deviceInfoAsyncCallbackInfo->status == 0) { + if (deviceInfoAsyncCallbackInfo->devList.size() > 0) { + bool isArray = false; + napi_create_array(env, &array[1]); + napi_is_array(env, array[1], &isArray); + if (isArray == false) { + LOGE("napi_create_array fail"); + } + for (unsigned int i = 0; i != deviceInfoAsyncCallbackInfo->devList.size(); ++i) { + DeviceInfoToJsArray(env, deviceInfoAsyncCallbackInfo->devList, i, array[1]); + } + napi_resolve_deferred(env, deviceInfoAsyncCallbackInfo->deferred, array[1]); + LOGE("devList is OK"); + } else { + LOGE("devList is null"); + } + } else { + napi_create_object(env, &array[0]); + SetValueInt32(env, "code", status, array[0]); + napi_reject_deferred(env, deviceInfoAsyncCallbackInfo->deferred, array[0]); + } +} - DeviceManagerNapi *deviceManagerWrapper = nullptr; - napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); +void DmNapiDeviceManagerFaCallback::OnCall(const std::string ¶mJson) +{ + DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); + if (deviceManagerNapi == nullptr) { + LOGE("OnCall, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); + return; + } + deviceManagerNapi->OnDmfaCall(paramJson); +} - DmAuthParam authParam; - int32_t ret = DeviceManager::GetInstance().GetAuthenticationParam(deviceManagerWrapper->bundleName_, authParam); - if (ret != 0) { - DMLOG(DM_LOG_ERROR, "GetAuthenticationParam for %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); - napi_get_undefined(env, &resultParam); - return resultParam; +void DeviceManagerNapi::OnDmfaCall(const std::string ¶mJson) +{ + LOGI("OnCall for paramJson"); + napi_value result; + napi_create_object(env_, &result); + SetValueUtf8String(env_, "param", paramJson, result); + OnEvent("dmFaCallback", DM_NAPI_ARGS_ONE, &result); +} + +void DeviceManagerNapi::CallGetTrustedDeviceListStatus(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) +{ + for (unsigned int i = 0; i < deviceInfoAsyncCallbackInfo->devList.size(); i++) { + LOGI("DeviceManager::GetTrustedDeviceList deviceId:%s deviceName:%s deviceTypeId:%d ", + deviceInfoAsyncCallbackInfo->devList[i].deviceId, deviceInfoAsyncCallbackInfo->devList[i].deviceName, + deviceInfoAsyncCallbackInfo->devList[i].deviceTypeId); } + napi_value callResult = nullptr; + napi_value handler = nullptr; + napi_value array[DM_NAPI_ARGS_TWO] = {0}; + + if (deviceInfoAsyncCallbackInfo->status == 0) { + if (deviceInfoAsyncCallbackInfo->devList.size() > 0) { + bool isArray = false; + napi_create_array(env, &array[1]); + napi_is_array(env, array[1], &isArray); + if (isArray == false) { + LOGE("napi_create_array fail"); + } - napi_create_object(env, &resultParam); - DmAuthParamToJsAuthParamy(env, authParam, resultParam); - return resultParam; + for (size_t i = 0; i != deviceInfoAsyncCallbackInfo->devList.size(); ++i) { + DeviceInfoToJsArray(env, deviceInfoAsyncCallbackInfo->devList, i, array[1]); + } + LOGE("devList is OK"); + } else { + LOGE("devList is null"); + } + } else { + napi_create_object(env, &array[0]); + SetValueInt32(env, "code", status, array[0]); + } + + napi_get_reference_value(env, deviceInfoAsyncCallbackInfo->callback, &handler); + if (handler != nullptr) { + napi_call_function(env, nullptr, handler, DM_NAPI_ARGS_TWO, &array[0], &callResult); + napi_delete_reference(env, deviceInfoAsyncCallbackInfo->callback); + } else { + LOGE("handler is nullptr"); + } +} + +void DeviceManagerNapi::CallGetLocalDeviceInfoSync(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) +{ + napi_value result[DM_NAPI_ARGS_TWO] = {0}; + + LOGI("DeviceManager::GetTrustedDeviceList deviceId:%s deviceName:%s deviceTypeId:%d ", + deviceInfoAsyncCallbackInfo->deviceInfo.deviceId, deviceInfoAsyncCallbackInfo->deviceInfo.deviceName, + deviceInfoAsyncCallbackInfo->deviceInfo.deviceTypeId); + + if (deviceInfoAsyncCallbackInfo->status == 0) { + DmDeviceInfotoJsDeviceInfo(env, deviceInfoAsyncCallbackInfo->deviceInfo, result[1]); + } else { + napi_create_object(env, &result[0]); + SetValueInt32(env, "code", status, result[0]); + napi_reject_deferred(env, deviceInfoAsyncCallbackInfo->deferred, result[0]); + } +} + +void DeviceManagerNapi::CallGetLocalDeviceInfo(napi_env env, napi_status &status, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) +{ + napi_value result[DM_NAPI_ARGS_TWO] = {0}; + LOGI("DeviceManager::GetTrustedDeviceList deviceId:%s deviceName:%s deviceTypeId:%d ", + deviceInfoAsyncCallbackInfo->deviceInfo.deviceId, deviceInfoAsyncCallbackInfo->deviceInfo.deviceName, + deviceInfoAsyncCallbackInfo->deviceInfo.deviceTypeId); + napi_value callResult = nullptr; + napi_value handler = nullptr; + + if (deviceInfoAsyncCallbackInfo->status == 0) { + DmDeviceInfotoJsDeviceInfo(env, deviceInfoAsyncCallbackInfo->deviceInfo, result[1]); + } else { + napi_create_object(env, &result[0]); + SetValueInt32(env, "code", status, result[0]); + } + + napi_get_reference_value(env, deviceInfoAsyncCallbackInfo->callback, &handler); + if (handler != nullptr) { + napi_call_function(env, nullptr, handler, DM_NAPI_ARGS_TWO, &result[0], &callResult); + napi_delete_reference(env, deviceInfoAsyncCallbackInfo->callback); + } else { + LOGE("handler is nullptr"); + } +} + +void DeviceManagerNapi::CallAsyncWorkSync(napi_env env, DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) +{ + napi_value resourceName; + napi_create_string_latin1(env, "GetLocalDeviceInfo", NAPI_AUTO_LENGTH, &resourceName); + napi_create_async_work( + env, nullptr, resourceName, + [](napi_env env, void *data) { + (void)env; + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo = (DeviceInfoAsyncCallbackInfo *)data; + int32_t ret = 0; + if (deviceInfoAsyncCallbackInfo->isList == 1) { + ret = DeviceManager::GetInstance().GetTrustedDeviceList(deviceInfoAsyncCallbackInfo->bundleName, + deviceInfoAsyncCallbackInfo->extra, + deviceInfoAsyncCallbackInfo->devList); + } else { + ret = DeviceManager::GetInstance().GetLocalDeviceInfo(deviceInfoAsyncCallbackInfo->bundleName, + deviceInfoAsyncCallbackInfo->deviceInfo); + } + if (ret != 0) { + LOGE("GetTrustedDeviceList for bunderName %s failed, ret %d", + deviceInfoAsyncCallbackInfo->bundleName.c_str(), ret); + deviceInfoAsyncCallbackInfo->status = -1; + return; + } + deviceInfoAsyncCallbackInfo->status = 0; + LOGE("GetTrustedDeviceList status %d", deviceInfoAsyncCallbackInfo->status); + }, + [](napi_env env, napi_status status, void *data) { + (void)status; + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo = (DeviceInfoAsyncCallbackInfo *)data; + if (deviceInfoAsyncCallbackInfo->isList == 1) { + CallGetTrustedDeviceListStatusSync(env, status, deviceInfoAsyncCallbackInfo); + } else { + CallGetLocalDeviceInfoSync(env, status, deviceInfoAsyncCallbackInfo); + } + napi_delete_async_work(env, deviceInfoAsyncCallbackInfo->asyncWork); + delete deviceInfoAsyncCallbackInfo; + }, + (void *)deviceInfoAsyncCallbackInfo, &deviceInfoAsyncCallbackInfo->asyncWork); + napi_queue_async_work(env, deviceInfoAsyncCallbackInfo->asyncWork); +} + +void DeviceManagerNapi::CallAsyncWork(napi_env env, DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) +{ + napi_value resourceName; + napi_create_string_latin1(env, "GetLocalDeviceInfo", NAPI_AUTO_LENGTH, &resourceName); + napi_create_async_work( + env, nullptr, resourceName, + [](napi_env env, void *data) { + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo = (DeviceInfoAsyncCallbackInfo *)data; + int32_t ret = 0; + if (deviceInfoAsyncCallbackInfo->isList == 1) { + ret = DeviceManager::GetInstance().GetTrustedDeviceList(deviceInfoAsyncCallbackInfo->bundleName, + deviceInfoAsyncCallbackInfo->extra, + deviceInfoAsyncCallbackInfo->devList); + } else { + ret = DeviceManager::GetInstance().GetLocalDeviceInfo(deviceInfoAsyncCallbackInfo->bundleName, + deviceInfoAsyncCallbackInfo->deviceInfo); + } + if (ret != 0) { + LOGE("CallAsyncWork for bunderName %s failed, ret %d", deviceInfoAsyncCallbackInfo->bundleName.c_str(), + ret); + deviceInfoAsyncCallbackInfo->status = -1; + return; + } + deviceInfoAsyncCallbackInfo->status = 0; + LOGE("CallAsyncWork status %d", deviceInfoAsyncCallbackInfo->status); + }, + [](napi_env env, napi_status status, void *data) { + (void)status; + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo = (DeviceInfoAsyncCallbackInfo *)data; + if (deviceInfoAsyncCallbackInfo->isList == 1) { + CallGetTrustedDeviceListStatus(env, status, deviceInfoAsyncCallbackInfo); + } else { + CallGetLocalDeviceInfo(env, status, deviceInfoAsyncCallbackInfo); + } + napi_delete_async_work(env, deviceInfoAsyncCallbackInfo->asyncWork); + delete deviceInfoAsyncCallbackInfo; + }, + (void *)deviceInfoAsyncCallbackInfo, &deviceInfoAsyncCallbackInfo->asyncWork); + napi_queue_async_work(env, deviceInfoAsyncCallbackInfo->asyncWork); +} + +napi_value DeviceManagerNapi::CallDeviceList(napi_env env, napi_callback_info info, + DeviceInfoAsyncCallbackInfo *deviceInfoAsyncCallbackInfo) +{ + napi_value result = nullptr; + std::string extra = ""; + deviceInfoAsyncCallbackInfo->extra = extra; + GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); + napi_valuetype eventHandleType = napi_undefined; + napi_typeof(env, argv[0], &eventHandleType); + if (eventHandleType == napi_function) { + LOGE("CallDeviceList for argc %d Type = %d", argc, (int)eventHandleType); + napi_create_reference(env, argv[0], 1, &deviceInfoAsyncCallbackInfo->callback); + CallAsyncWork(env, deviceInfoAsyncCallbackInfo); + napi_get_undefined(env, &result); + return result; + } else { + LOGE("CallDeviceList for argc %d Type = %d", argc, (int)eventHandleType); + napi_deferred deferred; + napi_value promise = 0; + napi_create_promise(env, &deferred, &promise); + deviceInfoAsyncCallbackInfo->deferred = deferred; + char extraString[20]; + JsObjectToString(env, argv[0], "extra", extraString, sizeof(extraString)); + deviceInfoAsyncCallbackInfo->extra = extraString; + CallAsyncWorkSync(env, deviceInfoAsyncCallbackInfo); + return promise; + } } napi_value DeviceManagerNapi::GetTrustedDeviceListSync(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "GetTrustedDeviceList in"); - size_t argc = 0; + LOGI("GetTrustedDeviceListSync in"); + napi_value result = nullptr; napi_value thisVar = nullptr; - napi_value array = nullptr; + DmDeviceInfo deviceInfo; + LOGI("DeviceManager::GetTrustedDeviceListSync deviceId:%s deviceName:%s deviceTypeId:%d ", deviceInfo.deviceId, + deviceInfo.deviceName, deviceInfo.deviceTypeId); + size_t argc = 0; + bool isArray = false; + napi_create_array(env, &result); + napi_is_array(env, result, &isArray); + if (isArray == false) { + LOGE("napi_create_array fail"); + } NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); - NAPI_ASSERT(env, argc == 0, "Wrong number of arguments"); - + NAPI_ASSERT(env, argc == 1, "Wrong number of arguments"); DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); std::string extra = ""; - std::vector devList; + std::vector devList; int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(deviceManagerWrapper->bundleName_, extra, devList); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "GetTrustedDeviceList for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); - return array; + LOGE("GetTrustedDeviceList for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); + return result; } - + LOGI("DeviceManager::GetTrustedDeviceListSync"); if (devList.size() > 0) { - bool isArray = false; - napi_create_array(env, &array); - napi_is_array(env, array, &isArray); - if (isArray == false) { - DMLOG(DM_LOG_ERROR, "napi_create_array fail"); - } - for (size_t i = 0; i != devList.size(); ++i) { - DeviceInfoToJsArray(env, devList, i, array); + DeviceInfoToJsArray(env, devList, i, result); } - } else { - DMLOG(DM_LOG_ERROR, "devList is null"); } + return result; +} + +napi_value DeviceManagerNapi::GetTrustedDeviceList(napi_env env, napi_callback_info info) +{ + LOGI("GetTrustedDeviceList in"); + napi_value result = nullptr; + napi_value thisVar = nullptr; + size_t argc = 0; + std::vector devList; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); - return array; + DeviceManagerNapi *deviceManagerWrapper = nullptr; + napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); + auto *deviceInfoAsyncCallbackInfo = new DeviceInfoAsyncCallbackInfo(); + deviceInfoAsyncCallbackInfo->env = env; + deviceInfoAsyncCallbackInfo->devList = devList; + deviceInfoAsyncCallbackInfo->isList = 1; + deviceInfoAsyncCallbackInfo->bundleName = deviceManagerWrapper->bundleName_; + LOGE("GetTrustedDeviceList for argc %d", argc); + if (argc == 0) { + std::string extra = ""; + deviceInfoAsyncCallbackInfo->extra = extra; + napi_deferred deferred; + napi_value promise = 0; + napi_create_promise(env, &deferred, &promise); + deviceInfoAsyncCallbackInfo->deferred = deferred; + CallAsyncWorkSync(env, deviceInfoAsyncCallbackInfo); + return promise; + } else if (argc == 1) { + return CallDeviceList(env, info, deviceInfoAsyncCallbackInfo); + } else if (argc == DM_NAPI_ARGS_TWO) { + GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); + napi_valuetype valueType; + napi_typeof(env, argv[0], &valueType); + LOGE("GetTrustedDeviceList for argc %d Type = %d", argc, (int)valueType); + NAPI_ASSERT(env, valueType == napi_string, "Wrong argument type, string expected."); + + napi_valuetype eventHandleType = napi_undefined; + napi_typeof(env, argv[1], &eventHandleType); + LOGE("GetTrustedDeviceList for argc %d Type = %d", argc, (int)eventHandleType); + NAPI_ASSERT(env, eventHandleType == napi_function, "Wrong argument type. Object expected."); + char extra[20]; + JsObjectToString(env, argv[0], "extra", extra, sizeof(extra)); + deviceInfoAsyncCallbackInfo->extra = extra; + napi_create_reference(env, argv[1], 1, &deviceInfoAsyncCallbackInfo->callback); + CallAsyncWork(env, deviceInfoAsyncCallbackInfo); + napi_get_undefined(env, &result); + return result; + } + napi_get_undefined(env, &result); + return result; +} +napi_value DeviceManagerNapi::GetLocalDeviceInfoSync(napi_env env, napi_callback_info info) +{ + LOGI("GetLocalDeviceInfoSync in"); + napi_value result = nullptr; + napi_value thisVar = nullptr; + DmDeviceInfo deviceInfo; + LOGI("DeviceManager::GetLocalDeviceInfoSync deviceId:%s deviceName:%s deviceTypeId:%d ", deviceInfo.deviceId, + deviceInfo.deviceName, deviceInfo.deviceTypeId); + size_t argc = 0; + + 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)); + int32_t ret = DeviceManager::GetInstance().GetLocalDeviceInfo(deviceManagerWrapper->bundleName_, deviceInfo); + if (ret != 0) { + LOGE("GetLocalDeviceInfoSync for failed, ret %d", ret); + return result; + } + LOGI("DeviceManager::GetLocalDeviceInfoSync deviceId:%s deviceName:%s deviceTypeId:%d ", deviceInfo.deviceId, + deviceInfo.deviceName, deviceInfo.deviceTypeId); + DmDeviceInfotoJsDeviceInfo(env, deviceInfo, result); + return result; +} + +napi_value DeviceManagerNapi::GetLocalDeviceInfo(napi_env env, napi_callback_info info) +{ + LOGI("GetLocalDeviceInfo in"); + napi_value result = nullptr; + napi_value thisVar = nullptr; + size_t argc = 0; + DmDeviceInfo deviceInfo; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); + + DeviceManagerNapi *deviceManagerWrapper = nullptr; + napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); + auto *deviceInfoAsyncCallbackInfo = new DeviceInfoAsyncCallbackInfo(); + deviceInfoAsyncCallbackInfo->env = env; + deviceInfoAsyncCallbackInfo->deviceInfo = deviceInfo; + deviceInfoAsyncCallbackInfo->isList = 0; + deviceInfoAsyncCallbackInfo->bundleName = deviceManagerWrapper->bundleName_; + LOGE("GetLocalDeviceInfo for argc %d", argc); + if (argc == 0) { + std::string extra = ""; + deviceInfoAsyncCallbackInfo->extra = extra; + napi_deferred deferred; + napi_value promise = 0; + napi_create_promise(env, &deferred, &promise); + deviceInfoAsyncCallbackInfo->deferred = deferred; + CallAsyncWorkSync(env, deviceInfoAsyncCallbackInfo); + return promise; + } else if (argc == 1) { + std::string extra = ""; + deviceInfoAsyncCallbackInfo->extra = extra; + GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); + napi_create_reference(env, argv[0], 1, &deviceInfoAsyncCallbackInfo->callback); + CallAsyncWork(env, deviceInfoAsyncCallbackInfo); + napi_get_undefined(env, &result); + return result; + } + napi_get_undefined(env, &result); + return result; +} + +napi_value DeviceManagerNapi::UnAuthenticateDevice(napi_env env, napi_callback_info info) +{ + LOGI("UnAuthenticateDevice"); + napi_value result = nullptr; + napi_valuetype deviceInfoType; + GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); + napi_typeof(env, argv[0], &deviceInfoType); + NAPI_ASSERT(env, deviceInfoType == napi_string, "Wrong argument type. String expected."); + std::string deviceId = JsObjectToString(env, argv[0]); + LOGI("UnAuthenticateDevice deviceId=%s", deviceId.c_str()); + DeviceManagerNapi *deviceManagerWrapper = nullptr; + napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); + int32_t ret = DeviceManager::GetInstance().UnAuthenticateDevice(deviceManagerWrapper->bundleName_, deviceId); + if (ret != 0) { + LOGE("UnAuthenticateDevice for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); + } + + napi_create_int32(env, ret, &result); + return result; } napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "StartDeviceDiscoverSync in"); + LOGI("StartDeviceDiscoverSync in"); GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); napi_value result = nullptr; napi_valuetype valueType = napi_undefined; @@ -890,23 +1242,24 @@ napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callbac 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; + std::shared_ptr DiscoveryCallback = nullptr; + auto iter = g_DiscoveryCallbackMap.find(deviceManagerWrapper->bundleName_); + if (iter == g_DiscoveryCallbackMap.end()) { + DiscoveryCallback = std::make_shared(deviceManagerWrapper->bundleName_); + g_DiscoveryCallbackMap[deviceManagerWrapper->bundleName_] = DiscoveryCallback; } else { - discoverCallback = iter->second; + DiscoveryCallback = 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); + std::string extra = ""; + int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(deviceManagerWrapper->bundleName_, subInfo, extra, + DiscoveryCallback); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "StartDeviceDiscovery for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); + LOGE("StartDeviceDiscovery for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); + DiscoveryCallback->OnDiscoveryFailed(subInfo.subscribeId, ret); return result; } @@ -916,24 +1269,21 @@ napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callbac napi_value DeviceManagerNapi::StopDeviceDiscoverSync(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "StopDeviceDiscoverSync in"); + LOGI("StopDeviceDiscoverSync in"); GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); napi_value result = nullptr; napi_valuetype valueType = napi_undefined; 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); + int32_t ret = + DeviceManager::GetInstance().StopDeviceDiscovery(deviceManagerWrapper->bundleName_, (int16_t)subscribeId); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "StopDeviceDiscovery for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); + LOGE("StopDeviceDiscovery for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); return result; } @@ -945,7 +1295,7 @@ napi_value DeviceManagerNapi::AuthenticateDevice(napi_env env, napi_callback_inf { const int32_t PARAM_INDEX_ONE = 1; const int32_t PARAM_INDEX_TWO = 2; - DMLOG(DM_LOG_INFO, "AuthenticateDevice in"); + LOGI("AuthenticateDevice in"); GET_PARAMS(env, info, DM_NAPI_ARGS_THREE); napi_value result = nullptr; napi_valuetype deviceInfoType = napi_undefined; @@ -976,25 +1326,20 @@ napi_value DeviceManagerNapi::AuthenticateDevice(napi_env env, napi_callback_inf } DmDeviceInfo deviceInfo; JsToDmDeviceInfo(env, argv[0], deviceInfo); - - DmAppImageInfo appImageInfo(nullptr, 0, nullptr, 0); - std::string extra; - JsToDmAppImageInfoAndDmExtra(env, argv[PARAM_INDEX_ONE], appImageInfo, extra, authAsyncCallbackInfo_.authType); - - int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(deviceManagerWrapper->bundleName_, deviceInfo, - appImageInfo, extra, authCallback); + std::string extraString; + JsToDmExtra(env, argv[PARAM_INDEX_ONE], extraString, authAsyncCallbackInfo_.authType); + int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(deviceManagerWrapper->bundleName_, 1, deviceInfo, + extraString, authCallback); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "AuthenticateDevice for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); + LOGE("AuthenticateDevice for bundleName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); } - napi_get_undefined(env, &result); return result; } napi_value DeviceManagerNapi::VerifyAuthInfo(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "VerifyAuthInfo in"); + LOGI("VerifyAuthInfo in"); GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); napi_value result = nullptr; napi_valuetype valueType = napi_undefined; @@ -1011,42 +1356,29 @@ napi_value DeviceManagerNapi::VerifyAuthInfo(napi_env env, napi_callback_info in DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - std::shared_ptr verifyCallback = nullptr; - auto iter = g_checkAuthCallbackMap.find(deviceManagerWrapper->bundleName_); - if (iter == g_checkAuthCallbackMap.end()) { - verifyCallback = std::make_shared(deviceManagerWrapper->bundleName_); - g_checkAuthCallbackMap[deviceManagerWrapper->bundleName_] = verifyCallback; + std::shared_ptr verifyCallback = nullptr; + auto iter = g_verifyAuthCallbackMap.find(deviceManagerWrapper->bundleName_); + if (iter == g_verifyAuthCallbackMap.end()) { + verifyCallback = std::make_shared(deviceManagerWrapper->bundleName_); + g_verifyAuthCallbackMap[deviceManagerWrapper->bundleName_] = verifyCallback; } else { verifyCallback = iter->second; } std::string authParam; JsToDmAuthInfo(env, argv[0], authParam); - int32_t ret = DeviceManager::GetInstance().CheckAuthentication(deviceManagerWrapper->bundleName_, - authParam, verifyCallback); + int32_t ret = + DeviceManager::GetInstance().VerifyAuthentication(deviceManagerWrapper->bundleName_, authParam, verifyCallback); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "VerifyAuthInfo for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); + LOGE("VerifyAuthInfo for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); } napi_get_undefined(env, &result); return result; } -napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) +napi_value DeviceManagerNapi::JsOnFrench(napi_env env, int32_t num, napi_value thisVar, napi_value argv[]) { - DMLOG(DM_LOG_INFO, "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); @@ -1059,9 +1391,9 @@ napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - DMLOG(DM_LOG_INFO, "JsOn for bunderName %s, eventType %s ", deviceManagerWrapper->bundleName_.c_str(), - eventType.c_str()); - deviceManagerWrapper->On(eventType, argv[1]); + LOGI("JsOn for bunderName %s, eventType %s ", deviceManagerWrapper->bundleName_.c_str(), eventType.c_str()); + deviceManagerWrapper->On(eventType, argv[num + 1]); + CreateDmCallback(deviceManagerWrapper->bundleName_, eventType); napi_value result = nullptr; @@ -1069,26 +1401,50 @@ napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) return result; } -napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) +napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "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"); + size_t argc = 0; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); + if (argc == DM_NAPI_ARGS_THREE) { + LOGI("JsOff in argc == 3"); + GET_PARAMS(env, info, DM_NAPI_ARGS_THREE); + NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_THREE, "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 eventValueType = napi_undefined; - napi_typeof(env, argv[0], &eventValueType); - NAPI_ASSERT(env, eventValueType == napi_string, "type mismatch for parameter 1"); + napi_valuetype valueType; + napi_typeof(env, argv[1], &valueType); + NAPI_ASSERT(env, valueType == napi_object, "type mismatch for parameter 2"); + + napi_valuetype eventHandleType = napi_undefined; + napi_typeof(env, argv[DM_NAPI_ARGS_TWO], &eventHandleType); + NAPI_ASSERT(env, eventHandleType == napi_function, "type mismatch for parameter 3"); + + return JsOnFrench(env, 1, thisVar, argv); + } else { + LOGI("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"); - 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"); + NAPI_ASSERT(env, eventHandleType == napi_function, "type mismatch for parameter 2"); + + return JsOnFrench(env, 0, thisVar, argv); } +} +napi_value DeviceManagerNapi::JsOffFrench(napi_env env, int32_t num, napi_value thisVar, napi_value argv[]) +{ size_t typeLen = 0; napi_get_value_string_utf8(env, argv[0], nullptr, 0, &typeLen); - NAPI_ASSERT(env, typeLen > 0, "typeLen == 0"); NAPI_ASSERT(env, typeLen < DM_NAPI_BUF_LENGTH, "typeLen >= MAXLEN"); char type[DM_NAPI_BUF_LENGTH] = {0}; @@ -1098,8 +1454,7 @@ napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - DMLOG(DM_LOG_INFO, "JsOff for bunderName %s, eventType %s ", deviceManagerWrapper->bundleName_.c_str(), - eventType.c_str()); + LOGI("JsOff for bunderName %s, eventType %s ", deviceManagerWrapper->bundleName_.c_str(), eventType.c_str()); deviceManagerWrapper->Off(eventType); ReleaseDmCallback(deviceManagerWrapper->bundleName_, eventType); @@ -1108,9 +1463,52 @@ napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) return result; } +napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) +{ + size_t argc = 0; + napi_value thisVar = nullptr; + NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, &thisVar, nullptr)); + if (argc == DM_NAPI_ARGS_THREE) { + LOGI("JsOff in argc == 3"); + GET_PARAMS(env, info, DM_NAPI_ARGS_THREE); + 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"); + + napi_valuetype valueType; + napi_typeof(env, argv[1], &valueType); + NAPI_ASSERT(env, valueType == napi_object, "type mismatch for parameter 2"); + + if (argc > requireArgc) { + napi_valuetype eventHandleType = napi_undefined; + napi_typeof(env, argv[DM_NAPI_ARGS_TWO], &eventHandleType); + NAPI_ASSERT(env, eventValueType == napi_function, "type mismatch for parameter 2"); + } + return JsOffFrench(env, 1, thisVar, argv); + } else { + LOGI("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"); + } + return JsOffFrench(env, 0, thisVar, argv); + } +} napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "ReleaseDeviceManager in"); + LOGI("ReleaseDeviceManager in"); size_t argc = 0; napi_value thisVar = nullptr; napi_value result = nullptr; @@ -1120,11 +1518,10 @@ napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_i DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - DMLOG(DM_LOG_INFO, "ReleaseDeviceManager for bunderName %s", deviceManagerWrapper->bundleName_.c_str()); + LOGI("ReleaseDeviceManager for bunderName %s", deviceManagerWrapper->bundleName_.c_str()); int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(deviceManagerWrapper->bundleName_); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "ReleaseDeviceManager for bunderName %s failed, ret %d", - deviceManagerWrapper->bundleName_.c_str(), ret); + LOGE("ReleaseDeviceManager for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); napi_create_uint32(env, ret, &result); return result; } @@ -1132,9 +1529,9 @@ napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_i g_deviceManagerMap.erase(deviceManagerWrapper->bundleName_); g_initCallbackMap.erase(deviceManagerWrapper->bundleName_); g_deviceStateCallbackMap.erase(deviceManagerWrapper->bundleName_); - g_discoverCallbackMap.erase(deviceManagerWrapper->bundleName_); + g_DiscoveryCallbackMap.erase(deviceManagerWrapper->bundleName_); g_authCallbackMap.erase(deviceManagerWrapper->bundleName_); - g_checkAuthCallbackMap.erase(deviceManagerWrapper->bundleName_); + g_verifyAuthCallbackMap.erase(deviceManagerWrapper->bundleName_); napi_get_undefined(env, &result); return result; } @@ -1151,7 +1548,7 @@ void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbac std::string bundleName = std::string(asCallbackInfo->bundleName); std::shared_ptr initCallback = std::make_shared(bundleName); if (DeviceManager::GetInstance().InitDeviceManager(bundleName, initCallback) != 0) { - DMLOG(DM_LOG_ERROR, "InitDeviceManager for bunderName %s failed", bundleName.c_str()); + LOGE("InitDeviceManager for bunderName %s failed", bundleName.c_str()); return; } g_initCallbackMap[bundleName] = initCallback; @@ -1160,18 +1557,18 @@ void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbac [](napi_env env, napi_status status, void *data) { (void)status; AsyncCallbackInfo *asCallbackInfo = (AsyncCallbackInfo *)data; - napi_value result[DM_NAPI_ARGS_TWO] = { 0 }; + napi_value result[DM_NAPI_ARGS_TWO] = {0}; napi_value ctor = nullptr; napi_value argv = nullptr; 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) { - DMLOG(DM_LOG_ERROR, "Create DeviceManagerNapi for bunderName %s failed", asCallbackInfo->bundleName); + LOGE("Create DeviceManagerNapi for bunderName %s failed", asCallbackInfo->bundleName); asCallbackInfo->status = -1; } if (asCallbackInfo->status == 0) { - DMLOG(DM_LOG_INFO, "InitDeviceManager for bunderName %s success", asCallbackInfo->bundleName); + LOGI("InitDeviceManager for bunderName %s success", asCallbackInfo->bundleName); napi_get_undefined(env, &result[0]); napi_value callback = nullptr; napi_value callResult = nullptr; @@ -1179,7 +1576,7 @@ void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbac napi_call_function(env, nullptr, callback, DM_NAPI_ARGS_TWO, &result[0], &callResult); napi_delete_reference(env, asCallbackInfo->callback); } else { - DMLOG(DM_LOG_INFO, "InitDeviceManager for bunderName %s failed", asCallbackInfo->bundleName); + LOGI("InitDeviceManager for bunderName %s failed", asCallbackInfo->bundleName); napi_value message = nullptr; napi_create_object(env, &result[0]); napi_create_int32(env, asCallbackInfo->status, &message); @@ -1188,13 +1585,14 @@ void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbac } napi_delete_async_work(env, asCallbackInfo->asyncWork); delete asCallbackInfo; - }, (void *)asCallbackInfo, &asCallbackInfo->asyncWork); + }, + (void *)asCallbackInfo, &asCallbackInfo->asyncWork); napi_queue_async_work(env, asCallbackInfo->asyncWork); } napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "CreateDeviceManager in"); + LOGI("CreateDeviceManager in"); GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_TWO, "Wrong number of arguments, required 2"); @@ -1209,7 +1607,7 @@ napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_in auto *asCallbackInfo = new AsyncCallbackInfo(); asCallbackInfo->env = env; napi_get_value_string_utf8(env, argv[0], asCallbackInfo->bundleName, DM_NAPI_BUF_LENGTH - 1, - &asCallbackInfo->bundleNameLen); + &asCallbackInfo->bundleNameLen); napi_create_reference(env, argv[1], 1, &asCallbackInfo->callback); HandleCreateDmCallBack(env, asCallbackInfo); @@ -1221,7 +1619,7 @@ napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_in napi_value DeviceManagerNapi::Constructor(napi_env env, napi_callback_info info) { - DMLOG(DM_LOG_INFO, "DeviceManagerNapi Constructor in"); + LOGI("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"); @@ -1229,15 +1627,16 @@ napi_value DeviceManagerNapi::Constructor(napi_env env, napi_callback_info info) napi_typeof(env, argv[0], &valueType); NAPI_ASSERT(env, valueType == napi_string, "type mismatch for parameter 1"); - char bundleName[DM_NAPI_BUF_LENGTH] = { 0 }; + char bundleName[DM_NAPI_BUF_LENGTH] = {0}; size_t typeLen = 0; napi_get_value_string_utf8(env, argv[0], bundleName, sizeof(bundleName), &typeLen); - DMLOG(DM_LOG_INFO, "create DeviceManagerNapi for packageName:%s", bundleName); + LOGI("create DeviceManagerNapi for packageName:%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_wrap( + env, thisVar, reinterpret_cast(obj), [](napi_env env, void *data, void *hint) { (void)env; (void)hint; @@ -1254,28 +1653,31 @@ napi_value DeviceManagerNapi::Init(napi_env env, napi_value exports) napi_property_descriptor dmProperties[] = { DECLARE_NAPI_FUNCTION("release", ReleaseDeviceManager), DECLARE_NAPI_FUNCTION("getTrustedDeviceListSync", GetTrustedDeviceListSync), + DECLARE_NAPI_FUNCTION("getTrustedDeviceList", GetTrustedDeviceList), DECLARE_NAPI_FUNCTION("startDeviceDiscovery", StartDeviceDiscoverSync), DECLARE_NAPI_FUNCTION("stopDeviceDiscovery", StopDeviceDiscoverSync), + DECLARE_NAPI_FUNCTION("getLocalDeviceInfoSync", GetLocalDeviceInfoSync), + DECLARE_NAPI_FUNCTION("getLocalDeviceInfo", GetLocalDeviceInfo), + DECLARE_NAPI_FUNCTION("unAuthenticateDevice", UnAuthenticateDevice), DECLARE_NAPI_FUNCTION("authenticateDevice", AuthenticateDevice), DECLARE_NAPI_FUNCTION("verifyAuthInfo", VerifyAuthInfo), DECLARE_NAPI_FUNCTION("setUserOperation", SetUserOperationSync), + DECLARE_NAPI_FUNCTION("getFaParam", GetAuthenticationParamSync), DECLARE_NAPI_FUNCTION("getAuthenticationParam", GetAuthenticationParamSync), DECLARE_NAPI_FUNCTION("on", JsOn), - DECLARE_NAPI_FUNCTION("off", JsOff) - }; + DECLARE_NAPI_FUNCTION("off", JsOff)}; napi_property_descriptor static_prop[] = { DECLARE_NAPI_STATIC_FUNCTION("createDeviceManager", CreateDeviceManager), }; - DMLOG(DM_LOG_DEBUG, "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)); + LOGD("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)); - DMLOG(DM_LOG_INFO, "All props and functions are configured.."); + LOGI("All props and functions are configured.."); return exports; } @@ -1284,7 +1686,7 @@ napi_value DeviceManagerNapi::Init(napi_env env, napi_value exports) */ static napi_value Export(napi_env env, napi_value exports) { - DMLOG(DM_LOG_INFO, "Export() is called!"); + LOGI("Export() is called!"); DeviceManagerNapi::Init(env, exports); return exports; } @@ -1292,21 +1694,19 @@ static napi_value Export(napi_env env, napi_value 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} - }; +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) { - DMLOG(DM_LOG_INFO, "RegisterModule() is called!"); + LOGI("RegisterModule() is called!"); napi_module_register(&g_dmModule); } diff --git a/ohos.build b/ohos.build index f544c0dcc5235233f3748d3b24b5313debe618b8..59995c055a28f389812fe9a7e3abb7f1499404b7 100644 --- a/ohos.build +++ b/ohos.build @@ -12,8 +12,7 @@ "device_manager.h", "device_manager_callback.h", "dm_device_info.h", - "dm_subscribe_info.h", - "dm_app_image_info.h" + "dm_subscribe_info.h" ] } } @@ -23,7 +22,9 @@ "//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" + "//foundation/distributedhardware/devicemanager/sa_profile:dm_sa_profile", + "//foundation/distributedhardware/devicemanager/ext/pin_auth:devicemanagerext_pin_auth", + "//foundation/distributedhardware/devicemanager/ext/profile:devicemanagerext_profile" ], "test_list": [ "//foundation/distributedhardware/devicemanager/test:test" diff --git a/sa_profile/4802.xml b/sa_profile/4802.xml index 398977926affe714d592b75c701543622c556616..d2e77008ed95ef339e8b26fb1085b66e11c3344f 100644 --- a/sa_profile/4802.xml +++ b/sa_profile/4802.xml @@ -15,12 +15,12 @@ --> foundation - + 4802 libdevicemanagerservice.z.so - - - true + + + true false 1 diff --git a/services/devicemanagerservice/BUILD.gn b/services/devicemanagerservice/BUILD.gn index 85b8e5774a63282d8096f510101e515cb5dfc4a2..3b6f201b31e3cfa9dc1936a638bc6c7436790ab6 100644 --- a/services/devicemanagerservice/BUILD.gn +++ b/services/devicemanagerservice/BUILD.gn @@ -21,138 +21,67 @@ import("//foundation/distributedhardware/devicemanager/devicemanager.gni") if (defined(ohos_lite)) { executable("devicemanagerservice") { - include_dirs = [ - "include", - "include/ability", - "include/softbus", - "include/requestauth", - "include/auth", - "include/ipc", - "include/timer", - "include/message", - "include/ipc/lite", - "${utils_path}/include/cipher", - "${utils_path}/include/log", - "${utils_path}/include/ipc/lite", - "${utils_path}/include", - "${common_path}/include/ipc", - "${common_path}/include/ipc/model", - "${common_path}/include", - "${innerkits_path}/native_cpp/include", - "${innerkits_path}/native_cpp/include/ipc/lite", - ] - - include_dirs += [ - "//base/security/deviceauth/interfaces/innerkits", - "//base/startup/syspara_lite/interfaces/innerkits/native/syspara/include", - "//utils/native/lite/include", - "//utils/system/safwk/native/include", - "//third_party/json/include", - "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits/hilog", - "//third_party/bounds_checking_function/include", - "//foundation/communication/ipc_lite/interfaces/kits", - "//foundation/communication/dsoftbus/interfaces/kits/bus_center", - "//foundation/communication/dsoftbus/interfaces/kits/common", - "//foundation/communication/dsoftbus/interfaces/kits/discovery", - "//foundation/communication/dsoftbus/interfaces/kits/transport", - "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", - "//foundation/distributedschedule/samgr_lite/interfaces/kits/samgr", - ] - - sources = [ - "src/ability/lite/dm_ability_manager.cpp", - "src/auth/hichain_connector.cpp", - "src/ipc/ipc_server_adapter.cpp", - "src/ipc/ipc_server_listener_adapter.cpp", - "src/ipc/lite/ipc_cmd_parser.cpp", - "src/ipc/lite/ipc_server_listener.cpp", - "src/ipc/lite/ipc_server_listenermgr.cpp", - "src/ipc/lite/ipc_server_main.cpp", - "src/ipc/lite/ipc_server_stub.cpp", - "src/message/msg_codec.cpp", - "src/message/msg_head.cpp", - "src/message/msg_request_auth.cpp", - "src/message/msg_response_auth.cpp", - "src/message/msg_sync_group.cpp", - "src/requestauth/auth_manager.cpp", - "src/requestauth/request_session.cpp", - "src/requestauth/response_session.cpp", - "src/softbus/softbus_adapter.cpp", - "src/softbus/softbus_session.cpp", - "src/timer/dm_timer.cpp", - ] - - defines = [ - "LITE_DEVICE", - "HI_LOG_ENABLE", - "DH_LOG_TAG=\"devicemanagerservice\"", - "LOG_DOMAIN=0xD004100", - ] - - ldflags = dm_ldflags - - deps = [ - "${innerkits_path}/native_cpp:devicemanagersdk", - "${utils_path}:devicemanagerutils", - "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", - "//base/security/deviceauth/services:deviceauth_sdk", - "//base/startup/syspara_lite/frameworks/parameter/src:sysparam", - "//foundation/communication/dsoftbus/sdk:softbus_client", - "//foundation/communication/ipc_lite:liteipc_adapter", - "//foundation/distributedschedule/samgr_lite/samgr:samgr", - "//third_party/bounds_checking_function:libsec_shared", - "//third_party/mbedtls:mbedtls_shared", - "//utils/native/lite:utils", - ] + sources = [ "src/ipc/lite/ipc_server_main.cpp" ] } } else { ohos_shared_library("devicemanagerservice") { include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", "include", + "include/config", + "include/adapter", + "include/authentication", "include/ability", - "include/softbus", - "include/requestauth", - "include/auth", + "include/deviceinfo", + "include/devicestate", + "include/discovery", + "include/dependency/commonevent", + "include/dependency/hichain", + "include/dependency/softbus", + "include/dependency/timer", "include/ipc", - "include/message", - "include/timer", "include/ipc/standard", - "${utils_path}/include/cipher", - "${utils_path}/include/log", - "${utils_path}/include", - "${utils_path}/include/ipc/standard", + "include/eventbus", "${common_path}/include", "${common_path}/include/ipc", "${common_path}/include/ipc/model", + "${utils_path}/include", + "${utils_path}/include/ipc/standard", "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/ipc", "${innerkits_path}/native_cpp/include/ipc/standard", + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "//base/notification/ces_standard/frameworks/core/include", + "//base/notification/ces_standard/interfaces/innerkits/native/include", "//base/security/deviceauth/interfaces/innerkits", + "//base/startup/syspara_lite/interfaces/kits", "//base/startup/syspara_lite/adapter/native/syspara/include", "//third_party/json/include", ] sources = [ "src/ability/standard/dm_ability_manager.cpp", - "src/auth/hichain_connector.cpp", - "src/ipc/ipc_server_adapter.cpp", - "src/ipc/ipc_server_listener_adapter.cpp", + "src/adapter/standard/dm_adapter_manager.cpp", + "src/authentication/auth_message_processor.cpp", + "src/authentication/auth_request_state.cpp", + "src/authentication/auth_response_state.cpp", + "src/authentication/auth_ui.cpp", + "src/authentication/dm_auth_manager.cpp", + "src/config/config_manager.cpp", + "src/dependency/commonevent/event_manager_adapt.cpp", + "src/dependency/hichain/hichain_connector.cpp", + "src/dependency/softbus/softbus_connector.cpp", + "src/dependency/softbus/softbus_session.cpp", + "src/dependency/timer/dm_timer.cpp", + "src/device_manager_service.cpp", + "src/device_manager_service_listener.cpp", + "src/deviceinfo/dm_device_info_manager.cpp", + "src/devicestate/dm_device_state_manager.cpp", + "src/discovery/dm_discovery_manager.cpp", "src/ipc/standard/ipc_cmd_parser.cpp", "src/ipc/standard/ipc_server_client_proxy.cpp", "src/ipc/standard/ipc_server_listener.cpp", "src/ipc/standard/ipc_server_stub.cpp", - "src/message/msg_codec.cpp", - "src/message/msg_head.cpp", - "src/message/msg_request_auth.cpp", - "src/message/msg_response_auth.cpp", - "src/message/msg_sync_group.cpp", - "src/requestauth/auth_manager.cpp", - "src/requestauth/request_session.cpp", - "src/requestauth/response_session.cpp", - "src/softbus/softbus_adapter.cpp", - "src/softbus/softbus_session.cpp", - "src/timer/dm_timer.cpp", ] deps = [ @@ -175,12 +104,15 @@ if (defined(ohos_lite)) { "appexecfwk_standard:appexecfwk_base", "appexecfwk_standard:appexecfwk_core", "appexecfwk_standard:libeventhandler", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", "dsoftbus_standard:softbus_client", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", "safwk:system_ability_fwk", "samgr_standard:samgr_proxy", "startup_l2:syspara", + "startup_l2:syspara_watchagent", ] subsystem_name = "distributedhardware" diff --git a/services/devicemanagerservice/include/ability/dm_ability_manager.h b/services/devicemanagerservice/include/ability/dm_ability_manager.h index 17a9337d598f8052ef850417d37f471250955197..64c27a5e5bffaf97a5f0db3099c61e611c2404bd 100644 --- a/services/devicemanagerservice/include/ability/dm_ability_manager.h +++ b/services/devicemanagerservice/include/ability/dm_ability_manager.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -16,37 +16,29 @@ #ifndef OHOS_DM_ABILITY_MANAGER_H #define OHOS_DM_ABILITY_MANAGER_H +#include + +#include #include #include -#include -#include #include "single_instance.h" namespace OHOS { namespace DistributedHardware { -enum AbilityRole : int32_t { - ABILITY_ROLE_PASSIVE = 0, - ABILITY_ROLE_INITIATIVE = 1, - ABILITY_ROLE_UNKNOWN = 2 -}; +enum AbilityRole { ABILITY_ROLE_PASSIVE = 0, ABILITY_ROLE_INITIATIVE = 1, ABILITY_ROLE_UNKNOWN = 2 }; -enum AbilityStatus : int32_t { - ABILITY_STATUS_FAILED = 0, - ABILITY_STATUS_SUCCESS = 1, - ABILITY_STATUS_START = 2 -}; +enum AbilityStatus { ABILITY_STATUS_FAILED = 0, ABILITY_STATUS_SUCCESS = 1, ABILITY_STATUS_START = 2 }; -typedef enum FaAction { +enum FaAction { USER_OPERATION_TYPE_ALLOW_AUTH = 0, USER_OPERATION_TYPE_CANCEL_AUTH = 1, USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT = 2, USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY = 3, USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT = 4 -} FaAction; +}; class DmAbilityManager { -DECLARE_SINGLE_INSTANCE(DmAbilityManager); public: AbilityRole GetAbilityRole(); AbilityStatus StartAbility(AbilityRole role); diff --git a/services/devicemanagerservice/include/adapter/crypto_adapter.h b/services/devicemanagerservice/include/adapter/crypto_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..1ae62730e20a634958a02f16c5803ac6b56d3387 --- /dev/null +++ b/services/devicemanagerservice/include/adapter/crypto_adapter.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_DM_CRYPTO_ADAPTER_H +#define OHOS_DM_CRYPTO_ADAPTER_H +namespace OHOS { +namespace DistributedHardware { +class ICryptoAdapter { +public: + virtual ~ICryptoAdapter() = default; + virtual std::string GetName() = 0; + virtual std::string GetVersion() = 0; + virtual int32_t MbedTlsEncrypt(const uint8_t *plainText, int32_t plainTextLen, uint8_t *cipherText, + int32_t cipherTextLen, int32_t *outLen) = 0; + virtual int32_t MbedTlsDecrypt(const uint8_t *cipherText, int32_t cipherTextLen, uint8_t *plainText, + int32_t plainTextLen, int32_t *outLen) = 0; +}; + +using CreateICryptoAdapterFuncPtr = ICryptoAdapter *(*)(void); + +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_CRYPTO_ADAPTER_H diff --git a/services/devicemanagerservice/include/adapter/decision_adapter.h b/services/devicemanagerservice/include/adapter/decision_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..7e96a823de44442b5596999146c149b1def257c3 --- /dev/null +++ b/services/devicemanagerservice/include/adapter/decision_adapter.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_DM_DECISION_ADAPTER_H +#define OHOS_DM_DECISION_ADAPTER_H + +#include +#include + +#include "dm_device_info.h" + +namespace OHOS { +namespace DistributedHardware { +class IDecisionAdapter { +public: + virtual ~IDecisionAdapter() = default; + virtual std::string GetName() = 0; + virtual std::string GetVersion() = 0; + virtual int32_t FilterDeviceList(std::vector &infoList, const std::string &filterOptions) = 0; + virtual int32_t SortDeviceList(std::vector &infoList, const std::string &sortOptions) = 0; +}; + +using CreateIDecisionAdapterFuncPtr = IDecisionAdapter *(*)(void); + +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_DECISION_ADAPTER_H diff --git a/services/devicemanagerservice/include/adapter/dm_adapter_manager.h b/services/devicemanagerservice/include/adapter/dm_adapter_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..b290e83675c77685bf62e26b56d5b6a78cf7376f --- /dev/null +++ b/services/devicemanagerservice/include/adapter/dm_adapter_manager.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_DM_ADAPTER_MANAGER_H +#define OHOS_DM_ADAPTER_MANAGER_H + +#include + +#include "crypto_adapter.h" +#include "decision_adapter.h" +#include "profile_adapter.h" +#include "single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +class IProfileAdapter; +class DmAdapterManager { + DECLARE_SINGLE_INSTANCE(DmAdapterManager); + +public: + std::shared_ptr GetDecisionAdapter(const std::string &soName); + std::shared_ptr GetProfileAdapter(const std::string &soName); + std::shared_ptr GetCryptoAdapter(const std::string &soName); +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_ADAPTER_MANAGER_H diff --git a/services/devicemanagerservice/include/adapter/profile_adapter.h b/services/devicemanagerservice/include/adapter/profile_adapter.h new file mode 100644 index 0000000000000000000000000000000000000000..d7100f37cf5000e7d4040246e5a9f6b052db6f73 --- /dev/null +++ b/services/devicemanagerservice/include/adapter/profile_adapter.h @@ -0,0 +1,37 @@ +/* + * 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_PROFILE_ADAPTER_H +#define OHOS_DM_PROFILE_ADAPTER_H + +#include + +namespace OHOS { +namespace DistributedHardware { +class DmDeviceStateManager; +class IProfileAdapter { +public: + virtual ~IProfileAdapter() = default; + virtual int32_t RegisterProfileListener(const std::string &pkgName, const std::string &deviceId, + std::shared_ptr callback) = 0; + virtual int32_t UnRegisterProfileListener(const std::string &pkgName) = 0; +}; + +using CreateIProfileAdapterFuncPtr = IProfileAdapter *(*)(void); + +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_PROFILE_ADAPTER_H diff --git a/services/devicemanagerservice/include/authentication/auth_message_processor.h b/services/devicemanagerservice/include/authentication/auth_message_processor.h new file mode 100644 index 0000000000000000000000000000000000000000..73226f7a82c9ddf8eba05c512456b633c02e8996 --- /dev/null +++ b/services/devicemanagerservice/include/authentication/auth_message_processor.h @@ -0,0 +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_DM_AUTH_MESSAGE_PROCESSOR_H +#define OHOS_DM_AUTH_MESSAGE_PROCESSOR_H + +#include +#include + +#include "crypto_adapter.h" +#include "dm_auth_manager.h" +#include "nlohmann/json.hpp" + +namespace OHOS { +namespace DistributedHardware { +class DmAuthManager; +struct DmAuthRequestContext; +struct DmAuthResponseContext; +class ICryptoAdapter; +class AuthMessageProcessor { +public: + AuthMessageProcessor(std::shared_ptr authMgr); + ~AuthMessageProcessor(); + std::vector CreateAuthRequestMessage(); + std::string CreateSimpleMessage(int32_t msgType); + int32_t ParseMessage(const std::string &message); + void SetRequestContext(std::shared_ptr authRequestContext); + void SetResponseContext(std::shared_ptr authResponseContext); + std::shared_ptr GetResponseContext(); + std::shared_ptr GetRequestContext(); + +private: + std::string CreateRequestAuthMessage(nlohmann::json &json); + void CreateNegotiateMessage(nlohmann::json &json); + void CreateSyncGroupMessage(nlohmann::json &json); + void CreateResponseAuthMessage(nlohmann::json &json); + void ParseAuthResponseMessage(nlohmann::json &json); + void ParseAuthRequestMessage(); + void ParseNegotiateMessage(const nlohmann::json &json); + void CreateResponseFinishMessage(nlohmann::json &json); + void ParseResponseFinishMessage(nlohmann::json &json); + +private: + std::weak_ptr authMgr_; + std::shared_ptr cryptoAdapter_; + std::shared_ptr authRequestContext_; + std::shared_ptr authResponseContext_; + std::vector authSplitJsonList_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_AUTH_MESSAGE_PROCESSOR_H diff --git a/services/devicemanagerservice/include/authentication/auth_request_state.h b/services/devicemanagerservice/include/authentication/auth_request_state.h new file mode 100644 index 0000000000000000000000000000000000000000..a1a3343e89db38400bd63ed2c1444814a1ca7066 --- /dev/null +++ b/services/devicemanagerservice/include/authentication/auth_request_state.h @@ -0,0 +1,95 @@ +/* + * 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_AUTH_REQUEST_STATE_H +#define OHOS_DM_AUTH_REQUEST_STATE_H +#include +#include +#include + +#include "dm_log.h" +namespace OHOS { +namespace DistributedHardware { +class DmAuthManager; +struct DmAuthRequestContext; +class AuthRequestState : public std::enable_shared_from_this { +public: + virtual ~AuthRequestState() + { + authManager_.reset(); + LOGE("~AuthRequestState"); + }; + virtual int32_t GetStateType() = 0; + virtual void Enter() = 0; + void Leave(); + void TransitionTo(std::shared_ptr state); + void SetAuthManager(std::shared_ptr authManager); + void SetAuthContext(std::shared_ptr context); + std::shared_ptr GetAuthContext(); + +protected: + std::weak_ptr authManager_; + std::shared_ptr context_; +}; + +class AuthRequestInitState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthRequestNegotiateState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; +class AuthRequestNegotiateDoneState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthRequestReplyState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthRequestInputState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthRequestJoinState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthRequestNetworkState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthRequestFinishState : public AuthRequestState { +public: + int32_t GetStateType() override; + void Enter() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_AUTH_REQUEST_STATE_H diff --git a/services/devicemanagerservice/include/authentication/auth_response_state.h b/services/devicemanagerservice/include/authentication/auth_response_state.h new file mode 100644 index 0000000000000000000000000000000000000000..f84e54ba9dc675cfa58046e467cd34e5bbc44c41 --- /dev/null +++ b/services/devicemanagerservice/include/authentication/auth_response_state.h @@ -0,0 +1,82 @@ +/* + * 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_AUTH_RESPONSE_STATE_H +#define OHOS_DM_AUTH_RESPONSE_STATE_H + +#include + +namespace OHOS { +namespace DistributedHardware { + +class DmAuthManager; +struct DmAuthResponseContext; +class AuthResponseState : public std::enable_shared_from_this { +public: + virtual ~AuthResponseState() + { + authManager_.reset(); + }; + virtual int32_t GetStateType() = 0; + virtual void Enter() = 0; + void Leave(); + void TransitionTo(std::shared_ptr state); + void SetAuthManager(std::shared_ptr authManager); + void SetAuthContext(std::shared_ptr context); + std::shared_ptr GetAuthContext(); + +protected: + std::weak_ptr authManager_; + std::shared_ptr context_; +}; + +class AuthResponseInitState : public AuthResponseState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthResponseNegotiateState : public AuthResponseState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthResponseConfirmState : public AuthResponseState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthResponseGroupState : public AuthResponseState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthResponseShowState : public AuthResponseState { +public: + int32_t GetStateType() override; + void Enter() override; +}; + +class AuthResponseFinishState : public AuthResponseState { +public: + int32_t GetStateType() override; + void Enter() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_AUTH_RESPONSE_STATE_H diff --git a/services/devicemanagerservice/include/authentication/auth_ui.h b/services/devicemanagerservice/include/authentication/auth_ui.h new file mode 100644 index 0000000000000000000000000000000000000000..4ba96cb50c9680afaa424212760915ad8bf64968 --- /dev/null +++ b/services/devicemanagerservice/include/authentication/auth_ui.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_DM_AUTH_UI_H +#define OHOS_DM_AUTH_UI_H + +#include + +#include "dm_ability_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class AuthUi { +public: + AuthUi(); + int32_t ShowConfirmDialog(std::shared_ptr dmAbilityManager); + +private: + int32_t StartFaService(); + +private: + std::shared_ptr dmAbilityMgr_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_AUTH_UI_H \ No newline at end of file diff --git a/services/devicemanagerservice/include/authentication/authentication.h b/services/devicemanagerservice/include/authentication/authentication.h new file mode 100644 index 0000000000000000000000000000000000000000..5783f11125a23e813979ae3249a9cfd3d3d97603 --- /dev/null +++ b/services/devicemanagerservice/include/authentication/authentication.h @@ -0,0 +1,34 @@ +/* + * 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_AUTHENTICATION_H +#define OHOS_DM_AUTHENTICATION_H + +#include "dm_ability_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class IAuthentication { +public: + virtual ~IAuthentication() = default; + virtual int32_t ShowAuthInfo() = 0; + virtual int32_t StartAuth(std::shared_ptr dmAbilityManager) = 0; + virtual int32_t VerifyAuthentication(std::string pinToken, int32_t code, const std::string &authParam) = 0; +}; + +using CreateIAuthAdapterFuncPtr = IAuthentication *(*)(void); +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_AUTHENTICATION_H diff --git a/services/devicemanagerservice/include/authentication/dm_auth_manager.h b/services/devicemanagerservice/include/authentication/dm_auth_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..5bf2d4a0421b863fa1f7afa14da5972726d79f89 --- /dev/null +++ b/services/devicemanagerservice/include/authentication/dm_auth_manager.h @@ -0,0 +1,182 @@ +/* + * 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_AUTH_MANAGER_H +#define OHOS_DM_AUTH_MANAGER_H + +#include +#include + +#include "auth_message_processor.h" +#include "auth_request_state.h" +#include "auth_response_state.h" +#include "auth_ui.h" +#include "authentication.h" +#include "device_manager_service_listener.h" +#include "dm_ability_manager.h" +#include "dm_adapter_manager.h" +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_timer.h" +#include "hichain_connector.h" +#include "softbus_connector.h" +#include "softbus_session.h" + +namespace OHOS { +namespace DistributedHardware { + +typedef enum AuthState { + AUTH_REQUEST_INIT = 1, + AUTH_REQUEST_NEGOTIATE, + AUTH_REQUEST_NEGOTIATE_DONE, + AUTH_REQUEST_REPLY, + AUTH_REQUEST_INPUT, + AUTH_REQUEST_JOIN, + AUTH_REQUEST_NETWORK, + AUTH_REQUEST_FINISH, + AUTH_RESPONSE_INIT = 20, + AUTH_RESPONSE_NEGOTIATE, + AUTH_RESPONSE_CONFIRM, + AUTH_RESPONSE_GROUP, + AUTH_RESPONSE_SHOW, + AUTH_RESPONSE_FINISH, +} AuthState; + +enum DmMsgType : int32_t { + MSG_TYPE_UNKNOWN = 0, + MSG_TYPE_NEGOTIATE = 80, + MSG_TYPE_RESP_NEGOTIATE = 90, + MSG_TYPE_REQ_AUTH = 100, + MSG_TYPE_INVITE_AUTH_INFO = 102, + MSG_TYPE_REQ_AUTH_TERMINATE = 104, + MSG_TYPE_RESP_AUTH = 200, + MSG_TYPE_JOIN_AUTH_INFO = 201, + MSG_TYPE_RESP_AUTH_TERMINATE = 205, + MSG_TYPE_CHANNEL_CLOSED = 300, + MSG_TYPE_SYNC_GROUP = 400, + MSG_TYPE_AUTH_BY_PIN = 500, +}; + +typedef struct DmAuthRequestContext { + int32_t authType; + std::string localDeviceId; + std::string deviceId; + std::string deviceName; + std::string deviceTypeId; + int32_t sessionId; + int32_t groupVisibility; + bool cryptoSupport; + std::string cryptoName; + std::string cryptoVer; + std::string hostPkgName; + std::string targetPkgName; + std::string appName; + std::string appDesc; + std::string appIcon; + std::string appThumbnail; + std::string token; + int32_t reason; + std::vector syncGroupList; +} DmAuthRequestContext; + +typedef struct DmAuthResponseContext { + int32_t authType; + std::string deviceId; + std::string localDeviceId; + int32_t msgType; + int32_t sessionId; + bool cryptoSupport; + std::string cryptoName; + std::string cryptoVer; + int32_t reply; + std::string networkId; + std::string groupId; + std::string groupName; + std::string hostPkgName; + std::string targetPkgName; + std::string appName; + std::string appDesc; + std::string appIcon; + std::string appThumbnail; + std::string token; + int64_t requestId; + int32_t code; + std::vector syncGroupList; +} DmAuthResponseContext; + +class AuthMessageProcessor; + +class DmAuthManager final : public ISoftbusSessionCallback, + public IHiChainConnectorCallback, + public std::enable_shared_from_this { +public: + DmAuthManager(std::shared_ptr softbusConnector, + std::shared_ptr listener); + ~DmAuthManager(); + int32_t AuthenticateDevice(const std::string &pkgName, int32_t authType, const std::string &deviceId, + const std::string &extra); + int32_t UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId); + int32_t VerifyAuthentication(const std::string &authParam); + void OnSessionOpened(const std::string &pkgName, int32_t sessionId, int32_t sessionSide, int32_t result); + void OnSessionClosed(const std::string &pkgName, int32_t sessionId); + void OnDataReceived(const std::string &pkgName, int32_t sessionId, std::string message); + void OnGroupCreated(int64_t requestId, const std::string &groupId); + void OnMemberJoin(int64_t requestId, int32_t status); + + // auth state machine + void EstablishAuthChannel(const std::string &deviceId); + void StartNegotiate(const int32_t &sessionId); + void RespNegotiate(const int32_t &sessionId); + void SendAuthRequest(const int32_t &sessionId); + void StartAuthProcess(const int32_t &authType); + void StartRespAuthProcess(); + void CreateGroup(); + void AddMember(const std::string &deviceId); + std::string GetConnectAddr(std::string deviceId); + void JoinNetwork(); + void AuthenticateFinish(); + void GetIsCryptoSupport(bool &isCryptoSupport); + void SetAuthRequestState(std::shared_ptr authRequestState); + void SetAuthResponseState(std::shared_ptr authResponseState); + int32_t GetPinCode(); + std::string GenerateGroupName(); + void HandleAuthenticateTimeout(); + void CancelDisplay(); + int32_t GeneratePincode(); + void ShowConfigDialog(); + void ShowAuthInfoDialog(); + void ShowStartAuthDialog(); + int32_t GetAuthenticationParam(DmAuthParam &authParam); + int32_t RegisterSessionCallback(); + int32_t OnUserOperation(int32_t action); + +private: + std::shared_ptr softbusConnector_; + std::shared_ptr hiChainConnector_; + std::shared_ptr listener_; + std::shared_ptr adapterMgr_; + std::map> authenticationMap_; + std::shared_ptr authRequestState_ = nullptr; + std::shared_ptr authResponseState_ = nullptr; + std::shared_ptr authRequestContext_; + std::shared_ptr authResponseContext_; + std::shared_ptr authMessageProcessor_; + std::map> timerMap_; + std::shared_ptr dmAbilityMgr_; + bool isCryptoSupport_ = false; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_AUTH_MANAGER_H diff --git a/services/devicemanagerservice/include/requestauth/response_session.h b/services/devicemanagerservice/include/config/config_manager.h similarity index 30% rename from services/devicemanagerservice/include/requestauth/response_session.h rename to services/devicemanagerservice/include/config/config_manager.h index ee80835b22514654ab7a691349e20d9d9037ea93..4a410a1e7616838f97b01a2380f923a0e92366aa 100644 --- a/services/devicemanagerservice/include/requestauth/response_session.h +++ b/services/devicemanagerservice/include/config/config_manager.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -12,70 +12,70 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef OHOS_RESPONSE_SESSION_H -#define OHOS_RESPONSE_SESSION_H +#ifndef OHOS_OHOS_DM_CONFIG_MANAGER_H +#define OHOS_OHOS_DM_CONFIG_MANAGER_H + +#include +#include +#include +#include +#include #include #include -#include -#include +#include "authentication.h" +#include "crypto_adapter.h" +#include "decision_adapter.h" +#include "profile_adapter.h" #include "single_instance.h" -#include "dm_device_info.h" -#include "msg_response_auth.h" -#include "msg_request_auth.h" -#include "hichain_connector.h" -#include "dm_timer.h" namespace OHOS { namespace DistributedHardware { -enum ResponseSessionStatus : int32_t { - SESSION_INIT = 0, - SESSION_WAITTING_USER_CONFIRM = 1, - SESSION_WAITTING_GROUP_CREATED = 2, - SESSION_WAITTING_PIN_CODE = 3 -}; +typedef struct { + std::string name; + std::string type; + std::string version; + std::string funcName; + std::string soName; + std::string soPath; +} AdapterSoLoadInfo; + +typedef struct { + int32_t authType; + std::string name; + std::string type; + std::string version; + std::string funcName; + std::string soName; + std::string soPath; +} AuthSoLoadInfo; + +class DmConfigManager final { + DECLARE_SINGLE_INSTANCE_BASE(DmConfigManager); -class ResponseSession : public HichainConnectorCallback, public std::enable_shared_from_this { public: - ResponseSession(); - virtual ~ResponseSession() {}; - int32_t SendResponseMessage(int32_t reply); - void OnUserOperate(int32_t action); - void OnGroupCreated(int64_t requestId, const std::string &groupId) override; - void OnMemberJoin(int64_t requestId, int32_t status) override; - void BuildAuthenticationInfo(DmAuthParam &authParam); - void OnReceiveMsg(long long channelId, std::string &message); - int64_t GetRequestId(); - int32_t GetPinCodeByReqId(int64_t requestId); - bool IsMyChannelId(long long channelId); - void Release(); - void CancelDisplay(); - int32_t GetStatus(); + ~DmConfigManager(); + void GetAllAuthType(std::vector &allAuthType); + std::shared_ptr GetDecisionAdapter(const std::string &soName); + std::shared_ptr GetProfileAdapter(const std::string &soName); + std::shared_ptr GetCryptoAdapter(const std::string &soName); + void GetAuthAdapter(std::map> &authAdapter); private: - int32_t DecodeReqMsg(std::string &message); - int32_t StartFaService(); - std::string GenerateGroupName(); - void OnUserConfirm(); - void OnUserReject(int32_t errorCode); - int32_t GeneratePincode(); + DmConfigManager(); private: - int64_t mRequestId_; - std::string mGroupId_; - std::string mGroupName_; - std::string mReqDeviceId_; - sem_t mSem_; - std::shared_ptr mMsgRequestAuthPtr_; - int64_t mChannelId_; - int32_t mPincode_; - int32_t mSessionStatus_; - std::shared_ptr mReceiveTimerPtr_; - std::shared_ptr mMemberJoinTimerPtr_; + std::mutex authAdapterMutex_; + std::mutex cryptoAdapterMutex_; + std::mutex decisionAdapterMutex_; + std::mutex profileAdapterMutex_; + std::map soAuthLoadInfo_; + std::map soAdapterLoadInfo_; + std::map> decisionAdapterPtr_; + std::map> profileAdapterPtr_; + std::map> cryptoAdapterPtr_; }; } // namespace DistributedHardware } // namespace OHOS - - -#endif +#endif // OHOS_OHOS_DM_CONFIG_MANAGER_H \ No newline at end of file diff --git a/services/devicemanagerservice/include/config/json_config.h b/services/devicemanagerservice/include/config/json_config.h new file mode 100644 index 0000000000000000000000000000000000000000..a1c495cc0cf4d0215e66f50f16dff67664cdeb39 --- /dev/null +++ b/services/devicemanagerservice/include/config/json_config.h @@ -0,0 +1,79 @@ +/* + * 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_OHOS_DM_JSON_CONFIG_H +#define OHOS_OHOS_DM_JSON_CONFIG_H + +#include + +namespace OHOS { +namespace DistributedHardware { +const std::string adapterJsonConfigString = + R"({ + "devicemanager_adapter_components": [ + { + "name": "crypto_adapter", + "type": "CPYPTO", + "version": "1.0", + "funcName": "CreateCryptoAdapterObject", + "soName": "libdevicemanager_crypto_adapter.z.so", + "soPath": "/system/lib/" + }, + { + "name": "device_profile", + "type": "PROFILE", + "version": "1.0", + "funcName": "CreateDeviceProfileObject", + "soName": "libdevicemanagerext_profile.z.so", + "soPath": "/system/lib/" + } + ] +})"; + +const std::string authJsonConfigString = + R"({ + "devicemanager_auth_components": [ + { + "name": "pin_auth", + "type": "AUTHENTICATE", + "version": "1.0", + "authType": 1, + "funcName": "CreatePinAuthObject", + "soName": "libdevicemanagerext_pin_auth.z.so", + "soPath": "/system/lib/" + }, + { + "name": "QRcode_auth", + "type": "AUTHENTICATE", + "version": "1.0", + "authType": 2, + "funcName": "CreateQRcodeAuthObject", + "soName": "libdevicemanager_qrcodeauth.z.so", + "soPath": "/system/lib/" + }, + { + "name": "nfc_auth", + "type": "AUTHENTICATE", + "version": "1.0", + "authType": 3, + "funcName": "CreateNfcAuthObject", + "soName": "libdevicemanager_nfcauth.z.so", + "soPath": "/system/lib/" + } + ] +})"; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_OHOS_DM_JSON_CONFIG_H \ No newline at end of file diff --git a/services/devicemanagerservice/include/dependency/commonevent/event_manager_adapt.h b/services/devicemanagerservice/include/dependency/commonevent/event_manager_adapt.h new file mode 100644 index 0000000000000000000000000000000000000000..be733f983ed246c3fcfcfc7c98a8d5e2dcfaccce --- /dev/null +++ b/services/devicemanagerservice/include/dependency/commonevent/event_manager_adapt.h @@ -0,0 +1,81 @@ +/* + * 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_EVENT_MANAGER_ADAPT_H +#define OHOS_EVENT_MANAGER_ADAPT_H + +#include +#include + +#include "common_event.h" +#include "common_event_data.h" +#include "common_event_manager.h" +#include "common_event_subscribe_info.h" +#include "common_event_subscriber.h" +#include "dm_log.h" +#include "matching_skills.h" + +namespace OHOS { +namespace DistributedHardware { + +using CommomEventCallback = void (*)(void); + +class DmCommonEventManager { +public: + static DmCommonEventManager &GetInstance(); + +public: + bool SubscribeServiceEvent(const std::string &event, CommomEventCallback callback); + bool UnsubscribeServiceEvent(const std::string &event); + + class EventSubscriber : public EventFwk::CommonEventSubscriber { + public: + explicit EventSubscriber(const EventFwk::CommonEventSubscribeInfo &subscribeInfo) + : EventFwk::CommonEventSubscriber(subscribeInfo) + { + } + + void OnReceiveEvent(const EventFwk::CommonEventData &data); + void addEventCallback(const std::string &event, CommomEventCallback callback); + void deleteEventCallback(const std::string &event); + + private: + std::mutex callbackLock_; + std::map dmEventCallback_; + }; + +private: + DmCommonEventManager() = default; + virtual ~DmCommonEventManager(); + DmCommonEventManager(const DmCommonEventManager &) = delete; + DmCommonEventManager &operator=(const DmCommonEventManager &) = delete; + DmCommonEventManager(DmCommonEventManager &&) = delete; + DmCommonEventManager &operator=(DmCommonEventManager &&) = delete; + +private: + static void DealCallback(void); + static void InitCallbackThread(void); + +private: + static std::once_flag onceFlag_; + static std::list callbackQueue_; + static std::mutex callbackQueueMutex_; + static std::condition_variable notEmpty_; + std::map> dmEventSubscriber_; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_EVENT_MANAGER_ADAPT_H \ No newline at end of file diff --git a/services/devicemanagerservice/include/auth/hichain_connector.h b/services/devicemanagerservice/include/dependency/hichain/hichain_connector.h similarity index 51% rename from services/devicemanagerservice/include/auth/hichain_connector.h rename to services/devicemanagerservice/include/dependency/hichain/hichain_connector.h index e49700c97a279be2b31d7376b24074e5986561f3..20013a203cdab6ced20d08a07654ba83e2843a77 100644 --- a/services/devicemanagerservice/include/auth/hichain_connector.h +++ b/services/devicemanagerservice/include/dependency/hichain/hichain_connector.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -16,26 +16,19 @@ #ifndef OHOS_HICHAIN_CONNECTOR_H #define OHOS_HICHAIN_CONNECTOR_H -#include -#include #include - -#include "nlohmann/json.hpp" +#include +#include +#include +#include #include "device_auth.h" - +#include "hichain_connector_callback.h" +#include "nlohmann/json.hpp" #include "single_instance.h" -#include "msg_response_auth.h" namespace OHOS { namespace DistributedHardware { -enum { - HICHAIN_SUCCESS = 0, - GROUP_CREATE_FAILED = 1, - MEMBER_ADD_FAILED = 2, - CREATE_CHANNEL_FAILED = 3, -}; - struct GroupInfo { std::string groupName; std::string groupId; @@ -43,54 +36,46 @@ struct GroupInfo { int32_t groupType; int32_t groupVisibility; - GroupInfo() : groupName(""), groupId(""), groupOwner(""), groupType(0), groupVisibility(0) {} + GroupInfo() : groupName(""), groupId(""), groupOwner(""), groupType(0), groupVisibility(0) + { + } }; -void from_json(const nlohmann::json& jsonObject, GroupInfo& groupInfo); +void from_json(const nlohmann::json &jsonObject, GroupInfo &groupInfo); -class HichainConnectorCallback { -public: - virtual void OnGroupCreated(int64_t requestId, const std::string &groupId) = 0; - virtual void OnMemberJoin(int64_t requestId, int32_t status) = 0; -}; - -class HichainAuthenCallBack { +class HiChainConnector { 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, int32_t operationCode, const char *returnData); static void onError(int64_t requestId, int32_t operationCode, int32_t errorCode, const char *errorReturn); static char *onRequest(int64_t requestId, int32_t operationCode, const char *reqParams); -}; -class HichainConnector { -DECLARE_SINGLE_INSTANCE(HichainConnector); public: - int32_t Init(); - bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); - int64_t GenRequestId(); - void RegisterConnectorCallback(std::shared_ptr callback); + HiChainConnector(); + ~HiChainConnector(); + int32_t RegisterHiChainCallback(const std::string &pkgName, std::shared_ptr callback); + int32_t UnRegisterHiChainCallback(const std::string &pkgName); int32_t CreateGroup(int64_t requestId, const std::string &groupName); - int32_t AddMemeber(std::string deviceId, std::shared_ptr msgResponseAuth); - void GetRelatedGroups(std::string DeviceId, std::vector &groupList); - void SyncGroups(std::string deviceId, std::vector &remoteGroupIdList); + int32_t AddMember(std::string deviceId, std::string &connectInfo); int32_t DelMemberFromGroup(std::string groupId, std::string deviceId); - void DeleteGroup(std::string &groupId); - void OnGroupCreated(int64_t requestId, const std::string &returnData); - void GetSyncGroupList(std::vector &groupList, std::vector &syncGroupList); - void OnMemberJoin(int64_t requestId, int32_t status); - int32_t GetGroupInfo(std::string queryParams, std::vector &groupList); - int32_t IsGroupCreated(std::string groupName, GroupInfo &groupInfo); + int32_t DeleteGroup(std::string &groupId); + bool IsDevicesInGroup(std::string hostDevice, std::string peerDevice); + int32_t GetRelatedGroups(std::string DeviceId, std::vector &groupList); private: - std::string GetConnectPara(std::string deviceId, std::shared_ptr msgResponseAuth); + int64_t GenRequestId(); + int32_t SyncGroups(std::string deviceId, std::vector &remoteGroupIdList); + int32_t GetSyncGroupList(std::vector &groupList, std::vector &syncGroupList); + int32_t GetGroupInfo(std::string queryParams, std::vector &groupList); + std::string GetConnectPara(std::string deviceId, std::string reqDeviceId); + bool IsGroupCreated(std::string groupName, GroupInfo &groupInfo); bool IsGroupInfoInvalid(GroupInfo &group); private: - std::shared_ptr hichainConnectorCallback_ = nullptr; const DeviceGroupManager *deviceGroupManager_ = nullptr; - DeviceAuthCallback deviceAuthCallback_ ; + DeviceAuthCallback deviceAuthCallback_; + static std::map> hiChainConnectorCallbackMap_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_HICHAIN_ADAPTER_H +#endif // OHOS_HICHAIN_CONNECTOR_H diff --git a/services/devicemanagerservice/include/dependency/hichain/hichain_connector_callback.h b/services/devicemanagerservice/include/dependency/hichain/hichain_connector_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..f6504949a50d3a82208b775c24e5042c8e65cfcb --- /dev/null +++ b/services/devicemanagerservice/include/dependency/hichain/hichain_connector_callback.h @@ -0,0 +1,30 @@ +/* + * 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_HICHAIN_CONNECTOR_CALLBACK_H +#define OHOS_DM_HICHAIN_CONNECTOR_CALLBACK_H + +namespace OHOS { +namespace DistributedHardware { +class IHiChainConnectorCallback { +public: + virtual void OnGroupCreated(int64_t requestId, const std::string &groupId) = 0; + virtual void OnMemberJoin(int64_t requestId, int32_t status) = 0; + virtual std::string GetConnectAddr(std::string deviceId) = 0; + virtual int32_t GetPinCode() = 0; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_HICHAIN_CONNECTOR_CALLBACK_H diff --git a/services/devicemanagerservice/include/softbus/softbus_adapter.h b/services/devicemanagerservice/include/dependency/softbus/softbus_connector.h similarity index 36% rename from services/devicemanagerservice/include/softbus/softbus_adapter.h rename to services/devicemanagerservice/include/dependency/softbus/softbus_connector.h index 25f472ff356295460b79b74b996ad2063941c0aa..ba60b083ddd6e6ded39aa71b10f1023069f0a533 100644 --- a/services/devicemanagerservice/include/softbus/softbus_adapter.h +++ b/services/devicemanagerservice/include/dependency/softbus/softbus_connector.h @@ -1,78 +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_SOFTBUS_ADAPTER_H -#define OHOS_DEVICE_MANAGER_SOFTBUS_ADAPTER_H - -#include -#include -#include -#include -#include -#include "softbus_bus_center.h" -#include "discovery_service.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -class PublishServiceCallBack { -public: - static void OnPublishSuccess(int32_t publishId); - static void OnPublishFail(int32_t publishId, PublishFailReason reason); -}; - -class SoftbusAdapter { -public: - static int32_t Init(); - static int32_t GetTrustDevices(const std::string &pkgName, NodeBasicInfo **info, int32_t *infoNum); - static int32_t StartDiscovery(std::string &pkgName, SubscribeInfo *info); - static int32_t StopDiscovery(std::string &pkgName, uint16_t subscribeId); - static bool IsDeviceOnLine(std::string &deviceId); - static int32_t GetConnectionIpAddr(std::string deviceId, std::string &ipAddr); - static ConnectionAddr *GetConnectAddr(std::string deviceId); -public: - static void OnSoftBusDeviceOnline(NodeBasicInfo *info); - static void OnSoftbusDeviceOffline(NodeBasicInfo *info); - static void OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info); - static void OnSoftbusDeviceFound(const DeviceInfo *device); - static void OnSoftbusDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason); - static void OnSoftbusDiscoverySuccess(int32_t subscribeId); -private: - static bool GetsubscribeIdAdapter(std::string &pkgName, int16_t originId, int32_t &adapterId); - static bool GetpkgNameBySubscribeId(int32_t adapterId, std::string &pkgName); - static void SaveDiscoverDeviceInfo(const DeviceInfo *deviceInfo); - static void RemoveDiscoverDeviceInfo(const std::string deviceId); - static void NodeBasicInfoCopyToDmDevice(DmDeviceInfo &dmDeviceInfo, NodeBasicInfo &nodeBasicInfo); - static void DeviceInfoCopyToDmDevice(DmDeviceInfo &dmDeviceInfo, const DeviceInfo &deviceInfo); - static ConnectionAddr *GetConnectAddrByType(DeviceInfo *deviceInfo, ConnectionAddrType type); -private: - struct SubscribeInfoAdapter { - SubscribeInfo info; - uint16_t subscribeIdOrigin; - uint16_t subscribeIdPrefix; - }; - static std::map>> subscribeInfos_; - static std::map> discoverDeviceInfoMap_; - static std::vector> discoverDeviceInfoVector_; - static uint16_t subscribeIdPrefix; - static std::mutex lock_; - static INodeStateCb softbusNodeStateCb_; - static IDiscoveryCallback softbusDiscoverCallback_; - static IPublishCallback servicePublishCallback_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SOFTBUS_ADAPTER_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_DM_SOFTBUS_CONNECTOR_H +#define OHOS_DM_SOFTBUS_CONNECTOR_H + +#include +#include +#include +#include +#include + +#include "discovery_service.h" +#include "dm_device_info.h" +#include "dm_subscribe_info.h" +#include "softbus_bus_center.h" +#include "softbus_discovery_callback.h" +#include "softbus_session.h" +#include "softbus_state_callback.h" + +namespace OHOS { +namespace DistributedHardware { +class SoftbusConnector { +public: + static void OnPublishSuccess(int32_t publishId); + static void OnPublishFail(int32_t publishId, PublishFailReason reason); + static void OnSoftBusDeviceOnline(NodeBasicInfo *info); + static void OnSoftbusDeviceOffline(NodeBasicInfo *info); + static void OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info); + static void OnSoftbusDeviceFound(const DeviceInfo *device); + static void OnSoftbusDiscoveryFailed(int32_t subscribeId, DiscoveryFailReason failReason); + static void OnSoftbusDiscoverySuccess(int32_t subscribeId); + static void OnParameterChgCallback(const char *key, const char *value, void *context); + static int32_t GetConnectionIpAddress(const std::string &deviceId, std::string &ipAddress); + static ConnectionAddr *GetConnectAddr(const std::string &deviceId, std::string &connectAddr); + static bool IsDeviceOnLine(const std::string &deviceId); + static int32_t GetUdidByNetworkId(const char *networkId, std::string &udid); + static int32_t GetUuidByNetworkId(const char *networkId, std::string &uuid); + static int32_t GetNodeKeyInfoByNetworkId(const char *networkId, NodeDeivceInfoKey key, uint8_t *info, + int32_t infoLen); + +public: + SoftbusConnector(); + ~SoftbusConnector(); + int32_t RegisterSoftbusStateCallback(const std::string &pkgName, + const std::shared_ptr callback); + int32_t UnRegisterSoftbusStateCallback(const std::string &pkgName); + int32_t RegisterSoftbusDiscoveryCallback(const std::string &pkgName, + const std::shared_ptr callback); + int32_t UnRegisterSoftbusDiscoveryCallback(const std::string &pkgName); + int32_t GetTrustedDeviceList(std::vector &deviceInfoList); + int32_t GetLocalDeviceInfo(DmDeviceInfo &deviceInfo); + int32_t StartDiscovery(const DmSubscribeInfo &subscribeInfo); + int32_t StopDiscovery(uint16_t subscribeId); + std::shared_ptr GetSoftbusSession(); + bool HaveDeviceInMap(std::string deviceId); + +private: + int32_t Init(); + static int32_t CovertNodeBasicInfoToDmDevice(const NodeBasicInfo &nodeBasicInfo, DmDeviceInfo &dmDeviceInfo); + static void CovertDeviceInfoToDmDevice(const DeviceInfo &deviceInfo, DmDeviceInfo &dmDeviceInfo); + static ConnectionAddr *GetConnectAddrByType(DeviceInfo *deviceInfo, ConnectionAddrType type); + +private: + enum PulishStatus { + STATUS_UNKNOWN = 0, + ALLOW_BE_DISCOVERY = 1, + NOT_ALLOW_BE_DISCOVERY = 2, + }; + static PulishStatus publishStatus; + static INodeStateCb softbusNodeStateCb_; + static IDiscoveryCallback softbusDiscoveryCallback_; + static IPublishCallback softbusPublishCallback_; + std::shared_ptr softbusSession_; + static std::map> discoveryDeviceInfoMap_; + static std::map> stateCallbackMap_; + static std::map> discoveryCallbackMap_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SOFTBUS_CONNECTOR_H diff --git a/services/devicemanagerservice/include/dependency/softbus/softbus_discovery_callback.h b/services/devicemanagerservice/include/dependency/softbus/softbus_discovery_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..c8b1f57cd514be32caaa04a9bca3ed1e10cc7f0b --- /dev/null +++ b/services/devicemanagerservice/include/dependency/softbus/softbus_discovery_callback.h @@ -0,0 +1,29 @@ +/* + * 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_SOFTBUS_DISCOVERY_CALLBACK_H +#define OHOS_DM_SOFTBUS_DISCOVERY_CALLBACK_H + +namespace OHOS { +namespace DistributedHardware { +class ISoftbusDiscoveryCallback { +public: + virtual void OnDeviceFound(const std::string &pkgName, const DmDeviceInfo &info) = 0; + virtual void OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId) = 0; + virtual void OnDiscoveryFailed(const std::string &pkgName, int32_t subscribeId, int32_t failedReason) = 0; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SOFTBUS_DISCOVERY_CALLBACK_H diff --git a/services/devicemanagerservice/include/softbus/softbus_session.h b/services/devicemanagerservice/include/dependency/softbus/softbus_session.h similarity index 41% rename from services/devicemanagerservice/include/softbus/softbus_session.h rename to services/devicemanagerservice/include/dependency/softbus/softbus_session.h index 03610be2cbcb6df81248044d040f0448a3dc98b4..e232b8e08e56a7479f7c8ddf14e012b81e4350f4 100644 --- a/services/devicemanagerservice/include/softbus/softbus_session.h +++ b/services/devicemanagerservice/include/dependency/softbus/softbus_session.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,41 +13,40 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_SOFTBUS_SESSION_H -#define OHOS_DEVICE_MANAGER_SOFTBUS_SESSION_H +#ifndef OHOS_DM_SOFTBUS_SESSION_H +#define OHOS_DM_SOFTBUS_SESSION_H +#include +#include #include -#include #include +#include +#include "inner_session.h" #include "session.h" -#include "single_instance.h" -#include "softbus_common.h" +#include "softbus_session_callback.h" namespace OHOS { namespace DistributedHardware { class SoftbusSession { -DECLARE_SINGLE_INSTANCE_BASE(SoftbusSession); public: - int32_t Start(); - int32_t OnSessionOpened(int32_t sessionId, int32_t result); - void OnSessionClosed(int32_t sessionId); - void OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen); - void CloseSession(int32_t sessionId); - int32_t SendMessages(const char *deviceId, std::vector &messages); - int32_t SendMsg(int32_t sessionId, std::string &message); - void GetPeerDeviceId(int32_t sessionId, std::string &peerDevId); -private: - SoftbusSession() = default; + static int32_t OnSessionOpened(int32_t sessionId, int32_t result); + static void OnSessionClosed(int32_t sessionId); + static void OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen); + +public: + SoftbusSession(); ~SoftbusSession(); + int32_t RegisterSessionCallback(const std::string &pkgName, std::shared_ptr callback); + int32_t UnRegisterSessionCallback(const std::string &pkgName); + int32_t OpenAuthSession(const std::string &deviceId); + int32_t CloseAuthSession(int32_t sessionId); + int32_t SendData(int32_t sessionId, std::string &message); + int32_t GetPeerDeviceId(int32_t sessionId, std::string &peerDevId); + private: - int32_t SendData(int32_t sessionId, const void *data, int32_t len); -private: - const char *PKG_NAME = "ohos.distributedhardware.devicemanager"; - const char *SESSION_NAME = "ohos.distributedhardware.devicemanager.resident"; - std::set sessionIdSet_; - std::vector messages_ {}; + static std::map> sessionCallbackMap_; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SOFTBUS_SESSION_H +#endif // OHOS_DM_SOFTBUS_SESSION_H diff --git a/services/devicemanagerservice/include/dependency/softbus/softbus_session_callback.h b/services/devicemanagerservice/include/dependency/softbus/softbus_session_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..9569a3313c58902f8508b76c6bb86ab9acaeb26c --- /dev/null +++ b/services/devicemanagerservice/include/dependency/softbus/softbus_session_callback.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_SOFTBUS_SESSION_CALLBACK_H +#define OHOS_DM_SOFTBUS_SESSION_CALLBACK_H + +namespace OHOS { +namespace DistributedHardware { +class ISoftbusSessionCallback { +public: + virtual void OnSessionOpened(const std::string &pkgName, int32_t sessionId, int32_t sessionSide, + int32_t result) = 0; + virtual void OnSessionClosed(const std::string &pkgName, int32_t sessionId) = 0; + virtual void OnDataReceived(const std::string &pkgName, int32_t sessionId, std::string message) = 0; + virtual void GetIsCryptoSupport(bool &isCryptoSupport) = 0; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SOFTBUS_SESSION_CALLBACK_H diff --git a/services/devicemanagerservice/include/dependency/softbus/softbus_state_callback.h b/services/devicemanagerservice/include/dependency/softbus/softbus_state_callback.h new file mode 100644 index 0000000000000000000000000000000000000000..15a08a2e345a787aec759d734ef2673ff4154f0e --- /dev/null +++ b/services/devicemanagerservice/include/dependency/softbus/softbus_state_callback.h @@ -0,0 +1,30 @@ +/* + * 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_SOFTBUS_STATE_CALLBACK_H +#define OHOS_DM_SOFTBUS_STATE_CALLBACK_H + +namespace OHOS { +namespace DistributedHardware { +class ISoftbusStateCallback { +public: + virtual void OnDeviceOnline(const std::string &pkgName, const DmDeviceInfo &info) = 0; + virtual void OnDeviceOffline(const std::string &pkgName, const DmDeviceInfo &info) = 0; + virtual void OnDeviceChanged(const std::string &pkgName, const DmDeviceInfo &info) = 0; + virtual void OnDeviceReady(const std::string &pkgName, const DmDeviceInfo &info) = 0; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SOFTBUS_STATE_CALLBACK_H diff --git a/services/devicemanagerservice/include/timer/dm_timer.h b/services/devicemanagerservice/include/dependency/timer/dm_timer.h similarity index 91% rename from services/devicemanagerservice/include/timer/dm_timer.h rename to services/devicemanagerservice/include/dependency/timer/dm_timer.h index 61b763e995ac27a779775df3c4ebbb7b4ccf5e78..66a0adbf357895875b51bbc6e0221090212f30d5 100644 --- a/services/devicemanagerservice/include/timer/dm_timer.h +++ b/services/devicemanagerservice/include/dependency/timer/dm_timer.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,20 +15,21 @@ #ifndef TIMER_H #define TIMER_H -#include #include -#include #include #include -#include +#include #include -#include -#include "device_manager_log.h" +#include +#include +#include +#include "dm_log.h" namespace OHOS { namespace DistributedHardware { + typedef void (*TimeoutHandle)(void *data); #define MAXEVENTS 255 @@ -47,7 +48,7 @@ public: ~DmTimer(); DmTimerStatus Start(uint32_t timeOut, TimeoutHandle handle, void *data); void Stop(int32_t code); - void WiteforTimeout(); + void WaitForTimeout(); private: int32_t CreateTimeFd(); @@ -65,7 +66,6 @@ private: std::thread mThread_; std::string mTimerName_; }; -} -} +} // namespace DistributedHardware +} // namespace OHOS #endif - diff --git a/services/devicemanagerservice/include/device_manager_service.h b/services/devicemanagerservice/include/device_manager_service.h new file mode 100644 index 0000000000000000000000000000000000000000..53e33b1d637dcfce2b88d12c884c2c6182c3e4d1 --- /dev/null +++ b/services/devicemanagerservice/include/device_manager_service.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_DM_SERVICE_H +#define OHOS_DM_SERVICE_H + +#include +#include + +#include "dm_ability_manager.h" +#include "dm_auth_manager.h" +#include "dm_device_info.h" +#include "dm_device_info_manager.h" +#include "dm_device_state_manager.h" +#include "dm_discovery_manager.h" +#include "single_instance.h" +#include "softbus_connector.h" + +namespace OHOS { +namespace DistributedHardware { +class DeviceManagerService { + DECLARE_SINGLE_INSTANCE(DeviceManagerService); + +public: + int32_t Init(); + int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList); + int32_t GetLocalDeviceInfo(DmDeviceInfo &info); + int32_t GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &udid); + int32_t GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &uuid); + int32_t StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra); + int32_t StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId); + int32_t AuthenticateDevice(const std::string &pkgName, int32_t authType, const std::string &deviceId, + const std::string &extra); + int32_t UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId); + int32_t VerifyAuthentication(const std::string &authParam); + int32_t GetFaParam(std::string &pkgName, DmAuthParam &authParam); + int32_t SetUserOperation(std::string &pkgName, int32_t action); + +private: + bool intFlag_ = false; + std::shared_ptr authMgr_; + std::shared_ptr deviceInfoMgr_; + std::shared_ptr deviceStateMgr_; + std::shared_ptr discoveryMgr_; + std::shared_ptr softbusConnector_; + std::shared_ptr listener_; + std::shared_ptr abilityMgr_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_SERVICE_H diff --git a/services/devicemanagerservice/include/ipc/ipc_server_listener_adapter.h b/services/devicemanagerservice/include/device_manager_service_listener.h similarity index 46% rename from services/devicemanagerservice/include/ipc/ipc_server_listener_adapter.h rename to services/devicemanagerservice/include/device_manager_service_listener.h index b812eca27533737f19037793342a3fbbf40e96e3..4ad17f9f805b03a31cc5c0923dd28fd2e91f724c 100644 --- a/services/devicemanagerservice/include/ipc/ipc_server_listener_adapter.h +++ b/services/devicemanagerservice/include/device_manager_service_listener.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,31 +13,34 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_ADAPTER_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_ADAPTER_H +#ifndef OHOS_DM_SERVICE_LISTENER_H +#define OHOS_DM_SERVICE_LISTENER_H -#include "discovery_service.h" +#include +#include -#include "ipc_server_listener.h" - -#include "single_instance.h" #include "dm_device_info.h" +#include "ipc_notify_dmfa_result_req.h" +#include "ipc_server_listener.h" namespace OHOS { namespace DistributedHardware { -class IpcServerListenerAdapter { -DECLARE_SINGLE_INSTANCE(IpcServerListenerAdapter); +class DeviceManagerServiceListener { 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 &deviceId, int32_t resultCode, int32_t flag); + void OnDeviceStateChange(const std::string &pkgName, const DmDeviceState &state, const DmDeviceInfo &info); + void OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, const DmDeviceInfo &info); + void OnDiscoveryFailed(const std::string &pkgName, uint16_t subscribeId, int32_t failedReason); + void OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId); + void OnAuthResult(const std::string &pkgName, const std::string &deviceId, const std::string &token, int32_t status, + const std::string &reason); + void OnVerifyAuthResult(const std::string &pkgName, const std::string &deviceId, int32_t resultCode, + const std::string &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 + +#endif // OHOS_DM_SERVICE_LISTENER_H diff --git a/services/devicemanagerservice/include/deviceinfo/dm_device_info_manager.h b/services/devicemanagerservice/include/deviceinfo/dm_device_info_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..9dfe5b1597fa5d587615cf0ac6619b573b360cd9 --- /dev/null +++ b/services/devicemanagerservice/include/deviceinfo/dm_device_info_manager.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_DM_DEVICEINFO_MANAGER_H +#define OHOS_DM_DEVICEINFO_MANAGER_H + +#include +#include + +#include "dm_adapter_manager.h" +#include "dm_device_info.h" +#include "softbus_connector.h" + +namespace OHOS { +namespace DistributedHardware { +class DmDeviceInfoManager { +public: + DmDeviceInfoManager(std::shared_ptr &softbusConnectorPtr); + int32_t GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList); + int32_t GetLocalDeviceInfo(DmDeviceInfo &info); + +private: + std::shared_ptr softbusConnector_; +}; +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_DEVICEINFO_MANAGER_H diff --git a/services/devicemanagerservice/include/devicestate/dm_device_state_manager.h b/services/devicemanagerservice/include/devicestate/dm_device_state_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..a54ef47ef12102bd5a5d4838bd135757e0b7e488 --- /dev/null +++ b/services/devicemanagerservice/include/devicestate/dm_device_state_manager.h @@ -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. + */ + +#ifndef OHOS_DM_DEVICE_STATE_MANAGER_H +#define OHOS_DM_DEVICE_STATE_MANAGER_H + +#include "device_manager_service_listener.h" +#include "dm_adapter_manager.h" +#include "softbus_connector.h" + +namespace OHOS { +namespace DistributedHardware { +class DmDeviceStateManager final : public ISoftbusStateCallback, + public std::enable_shared_from_this { +public: + DmDeviceStateManager(std::shared_ptr softbusConnector, + std::shared_ptr listener); + ~DmDeviceStateManager(); + void OnDeviceOnline(const std::string &pkgName, const DmDeviceInfo &info); + void OnDeviceOffline(const std::string &pkgName, const DmDeviceInfo &info); + void OnDeviceChanged(const std::string &pkgName, const DmDeviceInfo &info); + void OnDeviceReady(const std::string &pkgName, const DmDeviceInfo &info); + void OnProfileReady(const std::string &pkgName, const std::string deviceId); + int32_t RegisterSoftbusStateCallback(); + +private: + std::shared_ptr softbusConnector_; + std::shared_ptr adapterMgr_; + std::shared_ptr listener_; + std::map deviceStateMap_; + std::map remoteDeviceInfos_; + std::string profileSoName_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_DEVICE_STATE_MANAGER_H diff --git a/services/devicemanagerservice/include/discovery/dm_discovery_manager.h b/services/devicemanagerservice/include/discovery/dm_discovery_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..20c30ec8bda430bc9bdea6b78ae00d6c9163e36e --- /dev/null +++ b/services/devicemanagerservice/include/discovery/dm_discovery_manager.h @@ -0,0 +1,56 @@ +/* + * 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_DISCOVERY_MANAGER_H +#define OHOS_DM_DISCOVERY_MANAGER_H + +#include + +#include "device_manager_service_listener.h" +#include "dm_timer.h" +#include "softbus_connector.h" +namespace OHOS { +namespace DistributedHardware { + +typedef struct DmDiscoveryContext { + std::string pkgName; + std::string extra; + uint16_t subscribeId; +} DmDiscoveryContext; + +class DmDiscoveryManager final : public ISoftbusDiscoveryCallback, + public std::enable_shared_from_this { +public: + DmDiscoveryManager(std::shared_ptr softbusConnector, + std::shared_ptr listener); + ~DmDiscoveryManager(); + int32_t StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra); + int32_t StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId); + void OnDeviceFound(const std::string &pkgName, const DmDeviceInfo &info); + void OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId); + void OnDiscoveryFailed(const std::string &pkgName, int32_t subscribeId, int32_t failedReason); + void HandleDiscoveryTimeout(); + +private: + std::shared_ptr softbusConnector_; + std::shared_ptr listener_; + std::queue discoveryQueue_; + std::map discoveryContextMap_; + std::shared_ptr discoveryTimer_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_DISCOVERY_MANAGER_H diff --git a/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h b/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h index 9503191aa0b6430a4051deede3af5877b120bd5d..4cf1b62ce5666a0a86f729fcc3f9090cdd9fcfbe 100644 --- a/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h +++ b/services/devicemanagerservice/include/ipc/lite/ipc_server_listener.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,14 +13,13 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H +#ifndef OHOS_DM_IPC_SERVER_LISTENER_H +#define OHOS_DM_IPC_SERVER_LISTENER_H #include #include "ipc_req.h" #include "ipc_rsp.h" - #include "ipc_server_listenermgr.h" namespace OHOS { @@ -29,13 +28,15 @@ 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 +#endif // OHOS_DM_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 index 26d2ee114132da00563b88dbfb40062e8fb8043f..2d0ed61c4b32e29d3d674799a17dfbdc57540eeb 100644 --- a/services/devicemanagerservice/include/ipc/lite/ipc_server_listenermgr.h +++ b/services/devicemanagerservice/include/ipc/lite/ipc_server_listenermgr.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,13 +13,13 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_MGR_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_MGR_H +#ifndef OHOS_DM_IPC_SERVER_LISTENER_MGR_H +#define OHOS_DM_IPC_SERVER_LISTENER_MGR_H #include -#include #include #include +#include #include "liteipc_adapter.h" #include "single_instance.h" @@ -32,19 +32,21 @@ typedef struct CommonSvcId { uint32_t cookie; IpcContext *ipcCtx; uint32_t cbId; -}CommonSvcId; +} CommonSvcId; class IpcServerListenermgr { -DECLARE_SINGLE_INSTANCE(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 +#endif // OHOS_DM_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 index 9baa73d4a1b2b406b6970cd479854c95a3e8f062..fc22d94711a22cd24a54c100403e4da3d7b7121b 100644 --- a/services/devicemanagerservice/include/ipc/lite/ipc_server_stub.h +++ b/services/devicemanagerservice/include/ipc/lite/ipc_server_stub.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H +#ifndef OHOS_DM_IPC_SERVER_STUB_H +#define OHOS_DM_IPC_SERVER_STUB_H #include @@ -23,4 +23,4 @@ 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 +#endif // OHOS_DM_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 index 15b5e44a4ef46af22aef201c630823e4dc2eb829..f1fbd24058ae57c9b6ef4ba5ed48c9b9c98999f1 100644 --- a/services/devicemanagerservice/include/ipc/standard/ipc_server_client_proxy.h +++ b/services/devicemanagerservice/include/ipc/standard/ipc_server_client_proxy.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_CLIENT_PROXY_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_CLIENT_PROXY_H +#ifndef OHOS_DM_IPC_SERVER_CLIENT_PROXY_H +#define OHOS_DM_IPC_SERVER_CLIENT_PROXY_H #include "ipc_remote_broker.h" #include "iremote_proxy.h" @@ -23,13 +23,13 @@ namespace OHOS { namespace DistributedHardware { class IpcServerClientProxy : public IRemoteProxy { public: - explicit IpcServerClientProxy(const sptr &impl) - : IRemoteProxy(impl) {}; - ~IpcServerClientProxy() {}; + 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 +#endif // OHOS_DM_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 index 3737b7cdefa529f5f2af4eed65bfcccbe1248f01..1ee6680b9b01795fac399c7b3a4a8ef4904ff5b4 100644 --- a/services/devicemanagerservice/include/ipc/standard/ipc_server_listener.h +++ b/services/devicemanagerservice/include/ipc/standard/ipc_server_listener.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,8 +13,8 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_LISTENER_H +#ifndef OHOS_DM_IPC_SERVER_LISTENER_H +#define OHOS_DM_IPC_SERVER_LISTENER_H #include @@ -27,10 +27,11 @@ 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 +#endif // OHOS_DM_IPC_SERVER_LISTENER_H diff --git a/services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h b/services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h index 4e653eb97d1d38d97e728730a3b6e9366b592527..93d0f7878bd5190dfcbf4cba21a1cc959369e528 100644 --- a/services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h +++ b/services/devicemanagerservice/include/ipc/standard/ipc_server_stub.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,31 +13,26 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H -#define OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H +#ifndef OHOS_DM_IPC_SERVER_STUB_H +#define OHOS_DM_IPC_SERVER_STUB_H +#include #include #include -#include #include #include +#include "hichain_connector.h" +#include "ipc_remote_broker.h" +#include "iremote_stub.h" #include "nlohmann/json.hpp" - +#include "single_instance.h" #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 -}; +enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING }; class AppDeathRecipient : public IRemoteObject::DeathRecipient { public: @@ -47,23 +42,25 @@ public: }; class IpcServerStub : public SystemAbility, public IRemoteStub { -DECLARE_SYSTEM_ABILITY(IpcServerStub); -DECLARE_SINGLE_INSTANCE_BASE(IpcServerStub); + 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 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_; @@ -73,4 +70,4 @@ private: }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_SERVER_STUB_H +#endif // OHOS_DM_IPC_SERVER_STUB_H diff --git a/services/devicemanagerservice/include/message/msg_codec.h b/services/devicemanagerservice/include/message/msg_codec.h deleted file mode 100644 index b0b088047ec023002064ac414bd2d2dc77c30033..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/message/msg_codec.h +++ /dev/null @@ -1,46 +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_MSG_CODEC_H -#define OHOS_MSG_CODEC_H - -#include -#include - -#include "nlohmann/json.hpp" - -#include "msg_request_auth.h" -#include "msg_sync_group.h" -#include "msg_response_auth.h" - -namespace OHOS { -namespace DistributedHardware { -class MsgCodec { -public: - static int32_t DecodeMsgType(std::string &jsonStr); - static std::string EncodeSyncGroup(std::vector &groupIdList, std::string &deviceId); - static std::vector EncodeReqAppAuth(std::string &token, std::string hostPkg, std::string targetPkg, - const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, std::string &extras); - static std::string EncodeAcceptRespAuth(int32_t reply, int64_t requestId, std::string &groupId, - std::string &groupName, std::string &reqDeviceId); - static std::string EncodeRefuseRespAuth(int32_t reply, std::string &reqDeviceId); - static std::shared_ptr DecodeRequestAuth(std::string &jsonStr, - std::shared_ptr msgRequestAuth); - static std::shared_ptr DecodeResponseAuth(std::string &jsonStr); - static std::shared_ptr DecodeSyncGroup(std::string &jsonStr); -}; -} -} -#endif diff --git a/services/devicemanagerservice/include/message/msg_head.h b/services/devicemanagerservice/include/message/msg_head.h deleted file mode 100644 index b79b99f3e9822ad87e5bb5ee048613276c7da552..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/message/msg_head.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_MSG_HEAD_H -#define OHOS_MSG_HEAD_H - -#include "nlohmann/json.hpp" - -namespace OHOS { -namespace DistributedHardware { -enum DmMsgType : int32_t { - MSG_TYPE_UNKNOWN = 0, - MSG_TYPE_REQ_AUTH = 100, - MSG_TYPE_INVITE_AUTH_INFO = 102, - MSG_TYPE_RESP_AUTH = 200, - MSG_TYPE_JOIN_AUTH_INFO = 201, - MSG_TYPE_CHANNEL_CLOSED = 300, - MSG_TYPE_SYNC_GROUP = 400, - MSG_TYPE_AUTH_BY_PIN = 500, -}; - -class MsgHead { -public: - MsgHead(): mMsgType_(0), mItfVer_("") {}; - MsgHead(int32_t msg): mMsgType_(msg), mItfVer_("") {}; - ~MsgHead() = default; - void Encode(nlohmann::json &json); - static std::shared_ptr Decode(nlohmann::json &json); - int32_t GetMsgType(); -private: - int32_t mMsgType_; - std::string mItfVer_; -}; -} -} -#endif \ No newline at end of file diff --git a/services/devicemanagerservice/include/message/msg_request_auth.h b/services/devicemanagerservice/include/message/msg_request_auth.h deleted file mode 100644 index 2af901915e056edf10abd52146e15bac10188a8d..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/message/msg_request_auth.h +++ /dev/null @@ -1,79 +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_MSG_REQUEST_AUTH_H -#define OHOS_MSG_REQUEST_AUTH_H - -#include -#include - -#include "nlohmann/json.hpp" - -#include "msg_head.h" -#include "dm_app_image_info.h" -#include "dm_device_info.h" -#include "constants.h" - -namespace OHOS { -namespace DistributedHardware { -class MsgRequestAuth { -public: - MsgRequestAuth() = default; - ~MsgRequestAuth() = default; - MsgRequestAuth(std::string &token, std::string hostPkgName, std::string targetPkgName, - const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, std::string &extras) : MsgRequestAuth( - token, hostPkgName, targetPkgName, GROUP_VISIBILITY_IS_PRIVATE, devReqInfo, imageInfo, extras) {}; - MsgRequestAuth(std::string &token, std::string hostPkgName, std::string targetPkgName, - const int32_t groupVisibility, const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, - std::string &extras); - std::vector Encode(); - static std::shared_ptr Decode(nlohmann::json &json, std::shared_ptr msgIn); - static void SetThumbnailSize(nlohmann::json &json, std::shared_ptr msg); - int32_t GetMsgSlice(); - int32_t GetMsgCnt(); - std::string GetRequestDeviceId(); -public: - std::shared_ptr mHead_ {nullptr}; - std::string mHostPkg_; - std::string mTargetPkg_; - std::string mDeviceName_; - std::string mToken_; - std::string mDeviceId_; - std::string mDeviceType_; - std::string mAppName_; - std::string mAppDescription_; - int32_t mAuthType_ {AUTH_TYPE_PIN}; - int32_t mGroupVisibility_ {GROUP_VISIBILITY_IS_PRIVATE}; - int32_t mMsgSlice_ {0}; - int32_t mMsgCnt_ {0}; - int32_t mThumbnailSize_ {0}; - int32_t mAppIconSize_ {0}; - DmAppImageInfo mImageInfo_; -private: - std::string ToHexString(int32_t value); - std::string EncodeDevInfo(); - static void DecodeDeviceInfo(nlohmann::json &json, std::shared_ptr msg); - int32_t GetEncodedAppInfo(const uint8_t *dataSrc, int32_t srcLen, std::string &outString); - void GetDecodeAppInfo(const std::string appString, uint8_t **outBuffer, int32_t &outBufferLen); - static bool IsMsgValid(std::shared_ptr msgIn, nlohmann::json &json, std::string &deviceId, - int32_t index); - static bool IsAppInfoValid(nlohmann::json &json); - static void SetAuthType(nlohmann::json &json, std::shared_ptr msg); -}; -} -} - - -#endif diff --git a/services/devicemanagerservice/include/message/msg_response_auth.h b/services/devicemanagerservice/include/message/msg_response_auth.h deleted file mode 100644 index cec27b713f2b74bc5022cb1b207481c08b5d6c2d..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/message/msg_response_auth.h +++ /dev/null @@ -1,60 +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_MSG_RESPONSE_AUTH_H -#define OHOS_MSG_RESPONSE_AUTH_H - -#include -#include - -#include "constants.h" -#include "nlohmann/json.hpp" - -#include "msg_head.h" - -namespace OHOS { -namespace DistributedHardware { -class MsgResponseAuth { -public: - MsgResponseAuth() = default; - MsgResponseAuth(int32_t reply, std::string &reqDeviceId); - MsgResponseAuth(int32_t reply, int64_t requestId, std::string &groupId, std::string &groupName, - std::string &reqDeviceId); - ~MsgResponseAuth() = default; - void Encode(nlohmann::json &jsonObj); - int32_t Decode(nlohmann::json &jsonObj); - int32_t GetReply(); - std::string GetNetId(); - std::string GetGroupId(); - std::string GetDeviceId(); - std::string GetGroupName(); - int32_t GetPinCode(); - void SavePinCode(int32_t pinCode); - int64_t GetRequestId(); - std::vector GetSyncGroupList(); -private: - std::shared_ptr mHead_ {nullptr}; - int32_t mReply_ {SESSION_REPLY_UNKNOWN}; - std::string mNetId_; - std::string mGroupId_; - std::string mGroupName_; - std::string mDeviceId_; - int32_t mPinCode_ {-1}; - int64_t mRequestId_ {-1}; - std::vector mSyncGroupList_; -}; -} -} -#endif diff --git a/services/devicemanagerservice/include/requestauth/auth_manager.h b/services/devicemanagerservice/include/requestauth/auth_manager.h deleted file mode 100644 index 0fb99a70f6283102378b2295a4f916b9750693bd..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/requestauth/auth_manager.h +++ /dev/null @@ -1,65 +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_AUTH_MANAGER_H -#define OHOS_AUTH_MANAGER_H - -#include -#include - -#include "nlohmann/json.hpp" - -#include "single_instance.h" -#include "dm_device_info.h" -#include "dm_app_image_info.h" -#include "request_session.h" -#include "response_session.h" - -namespace OHOS { -namespace DistributedHardware { -class AuthManager { - DECLARE_SINGLE_INSTANCE(AuthManager); -public: - void AuthDeviceGroup(std::string &hostPkgName, const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, - std::string &extras); - void OnReceiveMsg(long long channelId, std::string &message); - int32_t CheckAuthentication(std::string &authPara); - int32_t GetAuthenticationParam(DmAuthParam &authParam); - void OnUserOperate(int32_t action); - int32_t GetPincode(int64_t requestId); - std::string GetAuthPara(); - int32_t GetDisplayOwner(); - void NotifyHostOnCheckAuthResult(int64_t requestId, int errorCode); - -private: - void SyncDmPrivateGroup(std::string &message); - void AuthAppGroup(std::string &hostPkgName, const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, - std::string &extrasJson); - void OnReceiveMessage(long long channelId, std::string &message, int32_t msgType); - bool CanStartNewSession(); - void MoveSessionToWaitScanMap(); - int32_t CheckAuthenticationByPin(nlohmann::json &authJson); - void OnPinInputResult(int32_t pinCode, int32_t pinToken); - -private: - std::string authParam_ = ""; - int32_t displayOwner_ = 0; - std::shared_ptr mPendingReqSessionPtr_ {nullptr}; - std::shared_ptr mPendingRespSessionPtr {}; - std::map> mWaitScanReqSessionMap_ = {}; -}; -} -} -#endif diff --git a/services/devicemanagerservice/include/requestauth/request_session.h b/services/devicemanagerservice/include/requestauth/request_session.h deleted file mode 100644 index b08b81ce69d3d62ea31c458ebf6727105bbb5007..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/include/requestauth/request_session.h +++ /dev/null @@ -1,86 +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_REQUEST_SESSION_H -#define OHOS_REQUEST_SESSION_H - -#include -#include - -#include "single_instance.h" -#include "dm_app_image_info.h" -#include "dm_device_info.h" -#include "msg_response_auth.h" - -namespace OHOS { -namespace DistributedHardware { -class RequestSession { -public: - RequestSession(std::string &hostPkgName, std::string &targetPkgName, const DmDeviceInfo &devReqInfo, - const DmAppImageInfo &imageInfo); - ~RequestSession() = default; - std::vector GetRequestCommand(std::string &extrasJson); - int32_t GetPinToken(); - void SetChannelId(long long channelId); - void Release(); - bool IsFinished(); - bool IsMyChannelId(long long channelId); - void OnReceiveMsg(std::string &msg); - bool IsWaitingForScan(); - std::string GetToken(); - bool IsMyPinToken(int32_t pinToken); - void OnReceivePinCode(int32_t pinCode); - void NotifyHostAppAuthResult(int32_t errorCode); - void OnUserOperate(int32_t action); - int64_t GetRequestId(); - std::string GetRequestDeviceId(); - -private: - int32_t StartFaService(); - std::string GetHostPkgName(); - std::string GetTargetPkgName(); - int32_t GetSessionType(); - void CloseChannel(); - int32_t ParseRespMsg(std::string &msg); - void SyncDmPrivateGroup(std::vector &remoteGroupList); - -private: - enum StatusType : int32_t { - STATUS_INIT = 0, - STATUS_WAITING_REPLY = 2, - STATUS_WATING_SCAN_OR_INPUT = 3, - STATUS_WAITING_ADD_GROUP = 4, - STATUS_FINISH = 6, - }; - int32_t mSessionType_ {SESSION_TYPE_IS_APP_AUTH}; - int32_t mStatus_ {StatusType::STATUS_INIT}; - std::string mHostPkgName_; - std::string mTargetPkgName; - std::string mToken_; - int32_t mPinToken_ {MIN_PIN_TOKEN}; - DmDeviceInfo mDevInfo_; - DmAppImageInfo mImageInfo_; - long long mChannelId_ {-1}; - bool mIsChannelOpened_ {false}; - std::string mRemoteDeviceId_; - std::string mRemoteNetId_; - std::string mRemoteGroupId_; - std::string mRemoteGroupName_; - int64_t mRequestId_ {-1}; - std::shared_ptr responseMsgPtr_; -}; -} -} -#endif diff --git a/services/devicemanagerservice/src/ability/lite/dm_ability_manager.cpp b/services/devicemanagerservice/src/ability/lite/dm_ability_manager.cpp index 3b588515998fa03b574b1b292fe359f18d88c9ba..6d87d130fe4532f9281505609527ff16347e5d25 100644 --- a/services/devicemanagerservice/src/ability/lite/dm_ability_manager.cpp +++ b/services/devicemanagerservice/src/ability/lite/dm_ability_manager.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,15 +15,10 @@ #include "dm_ability_manager.h" -#include "semaphore.h" - -#include "constants.h" -#include "device_manager_log.h" +#include "dm_constants.h" namespace OHOS { namespace DistributedHardware { -IMPLEMENT_SINGLE_INSTANCE(DmAbilityManager); - AbilityRole DmAbilityManager::GetAbilityRole() { return mAbilityStatus_; @@ -39,7 +34,7 @@ AbilityStatus DmAbilityManager::StartAbility(AbilityRole role) void DmAbilityManager::waitForTimeout(uint32_t timeout_s) { - struct timespec ts; + struct timespec ts; clock_gettime(CLOCK_REALTIME, &ts); ts.tv_sec += timeout_s; sem_timedwait(&mSem_, &ts); @@ -50,5 +45,5 @@ void DmAbilityManager::StartAbilityDone() mStatus_ = AbilityStatus::ABILITY_STATUS_SUCCESS; sem_post(&mSem_); } -} -} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ability/standard/dm_ability_manager.cpp b/services/devicemanagerservice/src/ability/standard/dm_ability_manager.cpp index 8cf00ecccdd3a6bbc0123256a019f05babbf7860..ce077df93f66fada57fa39c85bcb83da27a3e2a4 100644 --- a/services/devicemanagerservice/src/ability/standard/dm_ability_manager.cpp +++ b/services/devicemanagerservice/src/ability/standard/dm_ability_manager.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,22 +15,22 @@ #include "dm_ability_manager.h" -#include "auth_manager.h" #include "ability_manager_client.h" -#include "ability_record.h" #include "ability_manager_service.h" +#include "ability_record.h" +#include "dm_constants.h" +#include "dm_log.h" #include "parameter.h" #include "semaphore.h" - -#include "constants.h" -#include "device_manager_log.h" +#include "single_instance.h" namespace OHOS { namespace DistributedHardware { namespace { const int32_t ABILITY_START_TIMEOUT = 3; // 3 second -} -IMPLEMENT_SINGLE_INSTANCE(DmAbilityManager); +const std::string bundleName = "com.ohos.devicemanagerui"; +const std::string abilityName = "com.ohos.devicemanagerui.MainAbility"; +} // namespace AbilityRole DmAbilityManager::GetAbilityRole() { @@ -39,40 +39,18 @@ AbilityRole DmAbilityManager::GetAbilityRole() AbilityStatus DmAbilityManager::StartAbility(AbilityRole role) { - std::string roleStr; - if (role == AbilityRole::ABILITY_ROLE_INITIATIVE) { - roleStr = "initiative"; - } else if (role == AbilityRole::ABILITY_ROLE_PASSIVE) { - roleStr = "passive"; - } else { - DMLOG(DM_LOG_ERROR, "StartAbility, failed, role unknown"); - return AbilityStatus::ABILITY_STATUS_FAILED; - } - - DMLOG(DM_LOG_ERROR, "StartAbility, role %s", roleStr.c_str()); mAbilityStatus_ = role; - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); std::string deviceId = localDeviceId; - std::string bundleName = "com.ohos.devicemanagerui"; - std::string abilityName = "com.ohos.devicemanagerui.MainAbility"; - int32_t displayOwner = (role == AbilityRole::ABILITY_ROLE_INITIATIVE) ? - AuthManager::GetInstance().GetDisplayOwner() : DISPLAY_OWNER_SYSTEM; - mStatus_ = AbilityStatus::ABILITY_STATUS_START; AAFwk::Want want; AppExecFwk::ElementName element(deviceId, bundleName, abilityName); want.SetElement(element); - if (displayOwner == DISPLAY_OWNER_OTHER) { - return AbilityStatus::ABILITY_STATUS_SUCCESS; - } AAFwk::AbilityManagerClient::GetInstance()->Connect(); ErrCode result = AAFwk::AbilityManagerClient::GetInstance()->StartAbility(want); - if (result == OHOS::ERR_OK) { - DMLOG(DM_LOG_INFO, "Start Ability succeed"); - } else { - DMLOG(DM_LOG_INFO, "Start Ability faild"); + if (result != OHOS::ERR_OK) { + LOGE("Start Ability faild"); mStatus_ = AbilityStatus::ABILITY_STATUS_FAILED; return mStatus_; } @@ -93,5 +71,5 @@ void DmAbilityManager::StartAbilityDone() mStatus_ = AbilityStatus::ABILITY_STATUS_SUCCESS; sem_post(&mSem_); } -} -} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/adapter/lite/dm_adapter_manager.cpp b/services/devicemanagerservice/src/adapter/lite/dm_adapter_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..219002770a87bcb3f0bac2d2f21416b964c4b03d --- /dev/null +++ b/services/devicemanagerservice/src/adapter/lite/dm_adapter_manager.cpp @@ -0,0 +1,56 @@ +/* + * 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_adapter_manager.h" + +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { + +DmAdapterManager &DmAdapterManager::GetInstance() +{ + static DmAdapterManager instance; + return instance; +} + +DmAdapterManager::DmAdapterManager() +{ + LOGI("DmAdapterManager constructor"); +} + +DmAdapterManager::~DmAdapterManager() +{ + LOGI("DmAdapterManager destructor"); +} + +std::shared_ptr DmAdapterManager::GetDecisionAdapter() +{ + return decisionAdapterPtr_; +} + +std::shared_ptr DmAdapterManager::GetProfileAdapter() +{ + return profileAdapterPtr_; +} + +std::shared_ptr DmAdapterManager::GetCryptoAdapter() +{ + return cryptoAdapterPtr_; +} + +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/adapter/standard/dm_adapter_manager.cpp b/services/devicemanagerservice/src/adapter/standard/dm_adapter_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d7913a6df441e14c172759e99a73a136afdc56fb --- /dev/null +++ b/services/devicemanagerservice/src/adapter/standard/dm_adapter_manager.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 "dm_adapter_manager.h" + +#include "config_manager.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +DmAdapterManager &DmAdapterManager::GetInstance() +{ + static DmAdapterManager instance; + return instance; +} + +std::shared_ptr DmAdapterManager::GetDecisionAdapter(const std::string &soName) +{ + DmConfigManager &dmConfigManager = DmConfigManager::GetInstance(); + return dmConfigManager.GetDecisionAdapter(soName); +} + +std::shared_ptr DmAdapterManager::GetProfileAdapter(const std::string &soName) +{ + DmConfigManager &dmConfigManager = DmConfigManager::GetInstance(); + return dmConfigManager.GetProfileAdapter(soName); +} + +std::shared_ptr DmAdapterManager::GetCryptoAdapter(const std::string &soName) +{ + DmConfigManager &dmConfigManager = DmConfigManager::GetInstance(); + return dmConfigManager.GetCryptoAdapter(soName); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/authentication/auth_message_processor.cpp b/services/devicemanagerservice/src/authentication/auth_message_processor.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b12737381dea5e158b123700bda6ffe6cb1106d8 --- /dev/null +++ b/services/devicemanagerservice/src/authentication/auth_message_processor.cpp @@ -0,0 +1,289 @@ +/* + * 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 "auth_message_processor.h" + +#include "dm_auth_manager.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { + +AuthMessageProcessor::AuthMessageProcessor(std::shared_ptr authMgr) : authMgr_(authMgr) +{ + LOGI("AuthMessageProcessor constructor"); +} + +AuthMessageProcessor::~AuthMessageProcessor() +{ + authMgr_.reset(); +} + +std::vector AuthMessageProcessor::CreateAuthRequestMessage() +{ + LOGI("AuthMessageProcessor::CreateAuthRequestMessage start."); + std::vector jsonStrVec; + int32_t thumbnailSize = authRequestContext_->appThumbnail.size(); + int32_t thumbnailSlice = ((thumbnailSize / MSG_MAX_SIZE) + (thumbnailSize % MSG_MAX_SIZE) == 0 ? 0 : 1); + nlohmann::json jsonObj; + jsonObj[TAG_VER] = DM_ITF_VER; + jsonObj[TAG_TYPE] = MSG_TYPE_REQ_AUTH; + jsonObj[TAG_SLICE_NUM] = thumbnailSlice + 1; + jsonObj[TAG_INDEX] = 0; + jsonObj[TAG_REQUESTER] = authRequestContext_->deviceName; + jsonObj[TAG_DEVICE_ID] = authRequestContext_->deviceId; + jsonObj[TAG_DEVICE_TYPE] = authRequestContext_->deviceTypeId; + jsonObj[TAG_AUTH_TYPE] = authRequestContext_->authType; + jsonObj[TAG_TOKEN] = authRequestContext_->token; + jsonObj[TAG_VISIBILITY] = authRequestContext_->groupVisibility; + if (authRequestContext_->groupVisibility == GROUP_VISIBILITY_IS_PRIVATE) { + jsonObj[TAG_TARGET] = authRequestContext_->targetPkgName; + jsonObj[TAG_HOST] = authRequestContext_->hostPkgName; + } + jsonObj[TAG_APP_NAME] = authRequestContext_->appName; + jsonObj[TAG_APP_DESCRIPTION] = authRequestContext_->appDesc; + jsonObj[TAG_APP_ICON] = authRequestContext_->appIcon; + jsonObj[TAG_THUMBNAIL_SIZE] = thumbnailSize; + jsonStrVec.push_back(jsonObj.dump()); + + for (int32_t idx = 0; idx < thumbnailSlice; idx++) { + nlohmann::json jsonThumbnailObj; + jsonThumbnailObj[TAG_VER] = DM_ITF_VER; + jsonThumbnailObj[TAG_TYPE] = MSG_TYPE_REQ_AUTH; + jsonThumbnailObj[TAG_SLICE_NUM] = thumbnailSlice + 1; + jsonThumbnailObj[TAG_INDEX] = idx + 1; + jsonThumbnailObj[TAG_DEVICE_ID] = authRequestContext_->deviceId; + jsonThumbnailObj[TAG_THUMBNAIL_SIZE] = thumbnailSize; + + int32_t leftLen = thumbnailSize - idx * MSG_MAX_SIZE; + int32_t sliceLen = (leftLen > MSG_MAX_SIZE) ? MSG_MAX_SIZE : leftLen; + LOGD("TAG_APP_THUMBNAIL encode, idx %d, sliceLen %d, thumbnailSize %d", idx, sliceLen, thumbnailSize); + jsonObj[TAG_APP_THUMBNAIL] = authRequestContext_->appThumbnail.substr(idx * MSG_MAX_SIZE, sliceLen); + jsonStrVec.push_back(jsonThumbnailObj.dump()); + } + return jsonStrVec; +} + +std::string AuthMessageProcessor::CreateSimpleMessage(int32_t msgType) +{ + LOGI("AuthMessageProcessor::CreateSimpleMessage start. msgType is %d", msgType); + nlohmann::json jsonObj; + jsonObj[TAG_VER] = DM_ITF_VER; + jsonObj[TAG_TYPE] = msgType; + switch (msgType) { + case MSG_TYPE_NEGOTIATE: + case MSG_TYPE_RESP_NEGOTIATE: + CreateNegotiateMessage(jsonObj); + break; + case MSG_TYPE_SYNC_GROUP: + CreateSyncGroupMessage(jsonObj); + break; + case MSG_TYPE_RESP_AUTH: + CreateResponseAuthMessage(jsonObj); + break; + case MSG_TYPE_REQ_AUTH_TERMINATE: + CreateResponseFinishMessage(jsonObj); + break; + default: + break; + } + return jsonObj.dump(); +} + +void AuthMessageProcessor::CreateNegotiateMessage(nlohmann::json &json) +{ + if (cryptoAdapter_ == nullptr) { + json[TAG_CRYPTO_SUPPORT] = false; + } else { + json[TAG_CRYPTO_SUPPORT] = true; + json[TAG_CRYPTO_NAME] = cryptoAdapter_->GetName(); + json[TAG_CRYPTO_VERSION] = cryptoAdapter_->GetVersion(); + json[TAG_DEVICE_ID] = authRequestContext_->deviceId; + } + json[TAG_REPLY] = authResponseContext_->reply; + json[TAG_LOCAL_DEVICE_ID] = authResponseContext_->localDeviceId; +} + +void AuthMessageProcessor::CreateSyncGroupMessage(nlohmann::json &json) +{ + json[TAG_DEVICE_ID] = authRequestContext_->deviceId; + json[TAG_GROUPIDS] = authRequestContext_->syncGroupList; +} + +void AuthMessageProcessor::CreateResponseAuthMessage(nlohmann::json &json) +{ + json[TAG_REPLY] = authResponseContext_->reply; + json[TAG_DEVICE_ID] = authResponseContext_->deviceId; + json[TAG_TOKEN] = authResponseContext_->token; + // json[TAG_GROUPIDS] = authResponseContext_->deviceId; //? + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %d,%d", authResponseContext_->reply, + authResponseContext_->code); + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %s", authResponseContext_->deviceId.c_str()); + if (authResponseContext_->reply == 0) { + std::string groupId = authResponseContext_->groupId; + LOGI("AuthMessageProcessor::CreateSimpleMessage groupId %d", groupId.c_str()); + nlohmann::json jsonObject = nlohmann::json::parse(groupId, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("DecodeRequestAuth jsonStr error"); + return; + } + groupId = jsonObject[TAG_GROUP_ID]; + json[PIN_CODE_KEY] = authResponseContext_->code; + json[TAG_NET_ID] = authResponseContext_->networkId; + json[TAG_REQUEST_ID] = authResponseContext_->requestId; + json[TAG_GROUP_ID] = groupId; + json[TAG_GROUP_NAME] = authResponseContext_->groupName; + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %s,%s", groupId.c_str(), + authResponseContext_->groupName.c_str()); + } +} + +void AuthMessageProcessor::CreateResponseFinishMessage(nlohmann::json &json) +{ + json[TAG_REPLY] = authResponseContext_->reply; +} + +int32_t AuthMessageProcessor::ParseMessage(const std::string &message) +{ + LOGE(" AuthMessageProcessor ParseMessage"); + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("DecodeRequestAuth jsonStr error"); + return DM_FAILED; + } + if (!jsonObject.contains(TAG_TYPE)) { + LOGE("err json string, first time"); + return DM_FAILED; + } + int32_t sliceNum = 0; + int32_t msgType = jsonObject[TAG_TYPE]; + authResponseContext_->msgType = msgType; + LOGI("AuthMessageProcessor::ParseAuthRequestMessage======== %d", authResponseContext_->msgType); + switch (msgType) { + case MSG_TYPE_NEGOTIATE: + ParseNegotiateMessage(jsonObject); + break; + case MSG_TYPE_REQ_AUTH: + if (!jsonObject.contains(TAG_INDEX) || !jsonObject.contains(TAG_DEVICE_ID) || + !jsonObject.contains(TAG_SLICE_NUM)) { + LOGE("err json string, first time"); + return DM_FAILED; + } + authResponseContext_->deviceId = jsonObject[TAG_DEVICE_ID]; + authResponseContext_->authType = jsonObject[TAG_AUTH_TYPE]; + authResponseContext_->appDesc = jsonObject[TAG_APP_DESCRIPTION]; + authResponseContext_->token = jsonObject[TAG_TOKEN]; + authResponseContext_->targetPkgName = jsonObject[TAG_TARGET]; + authResponseContext_->appName = jsonObject[TAG_APP_NAME]; + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %s", authResponseContext_->deviceId.c_str()); + sliceNum = jsonObject[TAG_SLICE_NUM]; + if ((int32_t)authSplitJsonList_.size() < sliceNum) { + authSplitJsonList_.push_back(message); + } else { + ParseAuthRequestMessage(); + } + break; + case MSG_TYPE_RESP_AUTH: + ParseAuthResponseMessage(jsonObject); + break; + case MSG_TYPE_REQ_AUTH_TERMINATE: + ParseResponseFinishMessage(jsonObject); + break; + default: + break; + } + return DM_OK; +} + +void AuthMessageProcessor::ParseResponseFinishMessage(nlohmann::json &json) +{ + authResponseContext_->reply = json[TAG_REPLY]; +} + +void AuthMessageProcessor::ParseAuthResponseMessage(nlohmann::json &json) +{ + LOGI("AuthMessageProcessor::ParseAuthResponseMessage "); + authResponseContext_->reply = json[TAG_REPLY]; + authResponseContext_->deviceId = json[TAG_DEVICE_ID]; + authResponseContext_->token = json[TAG_TOKEN]; + if (authResponseContext_->reply == 0) { + authResponseContext_->code = json[PIN_CODE_KEY]; + authResponseContext_->networkId = json[TAG_NET_ID]; + authResponseContext_->requestId = json[TAG_REQUEST_ID]; + authResponseContext_->groupId = json[TAG_GROUP_ID]; + authResponseContext_->groupName = json[TAG_GROUP_NAME]; + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %s,%s", authResponseContext_->groupId.c_str(), + authResponseContext_->groupName.c_str()); + } + LOGI("AuthMessageProcessor::ParseAuthResponseMessage "); +} + +void AuthMessageProcessor::ParseAuthRequestMessage() +{ + nlohmann::json jsonObject = authSplitJsonList_.front(); + authResponseContext_->deviceId = jsonObject[TAG_DEVICE_ID]; + authResponseContext_->reply = jsonObject[TAG_REPLY]; + authResponseContext_->authType = jsonObject[TAG_AUTH_TYPE]; + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %d,%d", authResponseContext_->reply); + LOGI("AuthMessageProcessor::ParseAuthResponseMessage %s", authResponseContext_->deviceId.c_str()); + if (authResponseContext_->reply == AUTH_REPLY_ACCEPT) { + authResponseContext_->networkId = jsonObject[TAG_NET_ID]; + authResponseContext_->groupId = jsonObject[TAG_GROUP_ID]; + authResponseContext_->groupName = jsonObject[TAG_GROUP_NAME]; + authResponseContext_->requestId = jsonObject[TAG_REQUEST_ID]; + } + authSplitJsonList_.clear(); +} + +void AuthMessageProcessor::ParseNegotiateMessage(const nlohmann::json &json) +{ + if (json.contains(TAG_CRYPTO_SUPPORT)) { + authResponseContext_->cryptoSupport = json[TAG_CRYPTO_SUPPORT]; + } + if (json.contains(TAG_CRYPTO_NAME)) { + authResponseContext_->cryptoSupport = json[TAG_CRYPTO_NAME]; + } + if (json.contains(TAG_CRYPTO_VERSION)) { + authResponseContext_->cryptoSupport = json[TAG_CRYPTO_VERSION]; + } + if (json.contains(TAG_DEVICE_ID)) { + authResponseContext_->deviceId = json[TAG_DEVICE_ID]; + } + authResponseContext_->localDeviceId = json[TAG_LOCAL_DEVICE_ID]; + authResponseContext_->reply = json[TAG_REPLY]; +} + +void AuthMessageProcessor::SetRequestContext(std::shared_ptr authRequestContext) +{ + authRequestContext_ = authRequestContext; +} + +void AuthMessageProcessor::SetResponseContext(std::shared_ptr authResponseContext) +{ + authResponseContext_ = authResponseContext; +} + +std::shared_ptr AuthMessageProcessor::GetResponseContext() +{ + return authResponseContext_; +} + +std::shared_ptr AuthMessageProcessor::GetRequestContext() +{ + return authRequestContext_; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/devicemanagerservice/src/authentication/auth_request_state.cpp b/services/devicemanagerservice/src/authentication/auth_request_state.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e34ea708fa019c79d7f4f5dd109f10ef0603ab26 --- /dev/null +++ b/services/devicemanagerservice/src/authentication/auth_request_state.cpp @@ -0,0 +1,193 @@ +/* + * 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 "auth_request_state.h" + +#include "dm_auth_manager.h" +#include "dm_constants.h" + +namespace OHOS { +namespace DistributedHardware { + +void AuthRequestState::Leave() +{ +} + +void AuthRequestState::SetAuthManager(std::shared_ptr authManager) +{ + authManager_ = std::move(authManager); +} + +void AuthRequestState::SetAuthContext(std::shared_ptr context) +{ + context_ = std::move(context); +} + +std::shared_ptr AuthRequestState::GetAuthContext() +{ + return context_; +} + +void AuthRequestState::TransitionTo(std::shared_ptr state) +{ + LOGE("AuthRequestState::TransitionTo"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + state->SetAuthManager(stateAuthManager); + stateAuthManager->SetAuthRequestState(state); + state->SetAuthContext(context_); + this->Leave(); + state->Enter(); +} + +int32_t AuthRequestInitState::GetStateType() +{ + return AuthState::AUTH_REQUEST_INIT; +} + +void AuthRequestInitState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->EstablishAuthChannel(context_->deviceId); +} + +int32_t AuthRequestNegotiateState::GetStateType() +{ + return AuthState::AUTH_REQUEST_NEGOTIATE; +} + +void AuthRequestNegotiateState::Enter() +{ + // //1. 检查加解密模块是否存在并获取加解密的名称和版本信息 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->StartNegotiate(context_->sessionId); +} + +int32_t AuthRequestNegotiateDoneState::GetStateType() +{ + return AuthState::AUTH_REQUEST_NEGOTIATE_DONE; +} + +void AuthRequestNegotiateDoneState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->SendAuthRequest(context_->sessionId); +} + +int32_t AuthRequestReplyState::GetStateType() +{ + return AuthState::AUTH_REQUEST_REPLY; +} + +void AuthRequestReplyState::Enter() +{ + // 1. 收到请求响应，判断用户响应结果 + + // 2. 用户授权同意 + + // 3. 回调给认证实现模块，启动认证 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->StartRespAuthProcess(); +} + +int32_t AuthRequestInputState::GetStateType() +{ + return AuthState::AUTH_REQUEST_INPUT; +} + +void AuthRequestInputState::Enter() +{ + // //1. 获取用户输入 + // + // //2. 验证认证信息 + LOGE("DmAuthManager::AuthRequestInputState"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->ShowStartAuthDialog(); +} + +int32_t AuthRequestJoinState::GetStateType() +{ + return AuthState::AUTH_REQUEST_JOIN; +} + +void AuthRequestJoinState::Enter() +{ + // 1. 加入群组 + LOGE("DmAuthManager::AuthRequestJoinState"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->AddMember(context_->deviceId); +} + +int32_t AuthRequestNetworkState::GetStateType() +{ + return AuthState::AUTH_REQUEST_NETWORK; +} + +void AuthRequestNetworkState::Enter() +{ + // 1. 进行组网 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->JoinNetwork(); +} + +int32_t AuthRequestFinishState::GetStateType() +{ + return AuthState::AUTH_REQUEST_FINISH; +} + +void AuthRequestFinishState::Enter() +{ + // 1. 清理资源 + // 2. 通知对端认证结束，并关闭认证通道 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->AuthenticateFinish(); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/authentication/auth_response_state.cpp b/services/devicemanagerservice/src/authentication/auth_response_state.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d812b19fb36c47ba9dfaba824edf699c099f6a67 --- /dev/null +++ b/services/devicemanagerservice/src/authentication/auth_response_state.cpp @@ -0,0 +1,157 @@ +/* + * 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 "auth_response_state.h" + +#include "dm_auth_manager.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { + +void AuthResponseState::Leave() +{ +} + +void AuthResponseState::SetAuthContext(std::shared_ptr context) +{ + context_ = std::move(context); +} + +std::shared_ptr AuthResponseState::GetAuthContext() +{ + return context_; +} + +void AuthResponseState::SetAuthManager(std::shared_ptr authManager) +{ + authManager_ = std::move(authManager); +} + +void AuthResponseState::TransitionTo(std::shared_ptr state) +{ + LOGI("AuthRequestState:: TransitionTo"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + state->SetAuthManager(stateAuthManager); + stateAuthManager->SetAuthResponseState(state); + state->SetAuthContext(context_); + this->Leave(); + state->Enter(); +} + +int32_t AuthResponseInitState::GetStateType() +{ + return AuthState::AUTH_RESPONSE_INIT; +} + +void AuthResponseInitState::Enter() +{ + LOGI("AuthResponse:: AuthResponseInitState Enter"); + // 1.认证通道建立后，进入该状态 +} + +int32_t AuthResponseNegotiateState::GetStateType() +{ + return AuthState::AUTH_RESPONSE_NEGOTIATE; +} + +void AuthResponseNegotiateState::Enter() +{ + // 1.收到协商消息后进入 + + // 2. 获取本地加解密模块信息，并回复消 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->RespNegotiate(context_->sessionId); +} + +int32_t AuthResponseConfirmState::GetStateType() +{ + return AuthState::AUTH_RESPONSE_CONFIRM; +} + +void AuthResponseConfirmState::Enter() +{ + //委托授权UI模块进行用户交互 + //如果交互成功 + LOGI("AuthResponse:: AuthResponseConfirmState Enter"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->ShowConfigDialog(); +} + +int32_t AuthResponseGroupState::GetStateType() +{ + return AuthState::AUTH_RESPONSE_GROUP; +} + +void AuthResponseGroupState::Enter() +{ + // //1.创建群组, + LOGI("AuthResponse:: AuthResponseGroupState Enter"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->CreateGroup(); +} + +int32_t AuthResponseShowState::GetStateType() +{ + return AuthState::AUTH_RESPONSE_SHOW; +} + +void AuthResponseShowState::Enter() +{ + // 1.委托认证实现模块进行用户交互 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->ShowAuthInfoDialog(); +} + +int32_t AuthResponseFinishState::GetStateType() +{ + return AuthState::AUTH_RESPONSE_FINISH; +} + +void AuthResponseFinishState::Enter() +{ + // 1.结束UI显示 + + // 2.清理资源，结束状态机 + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return; + } + stateAuthManager->AuthenticateFinish(); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/authentication/auth_ui.cpp b/services/devicemanagerservice/src/authentication/auth_ui.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b3afce4537a85d43c4046347277ef0b71f0cacfd --- /dev/null +++ b/services/devicemanagerservice/src/authentication/auth_ui.cpp @@ -0,0 +1,49 @@ +/* + * 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 "auth_ui.h" + +#include "dm_ability_manager.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +AuthUi::AuthUi() +{ + LOGI("AuthUi constructor"); +} + +int32_t AuthUi::ShowConfirmDialog(std::shared_ptr dmAbilityManager) +{ + if (dmAbilityManager == nullptr) { + LOGE("AuthUi::dmAbilityManager is null"); + return DM_FAILED; + } + dmAbilityMgr_ = dmAbilityManager; + return StartFaService(); +} + +int32_t AuthUi::StartFaService() +{ + AbilityStatus status = dmAbilityMgr_->StartAbility(AbilityRole::ABILITY_ROLE_PASSIVE); + if (status != AbilityStatus::ABILITY_STATUS_SUCCESS) { + LOGE("AuthUi::StartFaService timeout"); + return DM_FAILED; + } + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/authentication/dm_auth_manager.cpp b/services/devicemanagerservice/src/authentication/dm_auth_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ccb269e4f9f03367fe7f1748188a67068595dd48 --- /dev/null +++ b/services/devicemanagerservice/src/authentication/dm_auth_manager.cpp @@ -0,0 +1,744 @@ +/* + * 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_auth_manager.h" + +#include "auth_message_processor.h" +#include "auth_ui.h" +#include "config_manager.h" +#include "dm_ability_manager.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "dm_random.h" +#include "nlohmann/json.hpp" +#include "parameter.h" + +namespace OHOS { +namespace DistributedHardware { +namespace { +std::string AUTHENTICATE_TIMEOUT_TASK = "authenticateTimeoutTask"; +std::string NEGOTIATE_TIMEOUT_TASK = "negotiateTimeoutTask"; +std::string CONFIRM_TIMEOUT_TASK = "confirmTimeoutTask"; +std::string SHOW_TIMEOUT_TASK = "showTimeoutTask"; +std::string INPUT_TIMEOUT_TASK = "inputTimeoutTask"; +std::string ADD_TIMEOUT_TASK = "addTimeoutTask"; +std::string WAIT_NEGOTIATE_TIMEOUT_TASK = "waitNegotiateTimeoutTask"; +std::string WAIT_REQUEST_TIMEOUT_TASK = "waitRequestTimeoutTask"; + +int32_t SESSION_CANCEL_TIMEOUT = 0; +int32_t AUTHENTICATE_TIMEOUT = 120; +int32_t CONFIRM_TIMEOUT = 60; +int32_t NEGOTIATE_TIMEOUT = 10; +int32_t INPUT_TIMEOUT = 60; +int32_t ADD_TIMEOUT = 10; +int32_t WAIT_NEGOTIATE_TIMEOUT = 10; +int32_t WAIT_REQUEST_TIMEOUT = 10; +int32_t CANCEL_PICODE_DISPLAY = 1; +int32_t DEVICE_ID_HALF = 2; +} // namespace + +static void TimeOut(void *data) +{ + LOGE("time out "); + DmAuthManager *authMgr = (DmAuthManager *)data; + if (authMgr == nullptr) { + LOGE("time out error"); + return; + } + authMgr->HandleAuthenticateTimeout(); +} + +DmAuthManager::DmAuthManager(std::shared_ptr softbusConnector, + std::shared_ptr listener) + : softbusConnector_(softbusConnector), listener_(listener) +{ + LOGI("DmAuthManager constructor"); + // TODO: load library so for different auth type + hiChainConnector_ = std::make_shared(); + + DmConfigManager &dmConfigManager = DmConfigManager::GetInstance(); + dmConfigManager.GetAuthAdapter(authenticationMap_); +} + +DmAuthManager::~DmAuthManager() +{ + LOGI("DmAuthManager destructor"); +} + +int32_t DmAuthManager::AuthenticateDevice(const std::string &pkgName, int32_t authType, const std::string &deviceId, + const std::string &extra) +{ + LOGE("DmAuthManager::AuthenticateDevice is"); + if (authRequestState_ != nullptr && authResponseState_ != nullptr) { + LOGE("DmAuthManager::AuthenticateDevice %s is request authentication.", + authRequestState_->GetAuthContext()->hostPkgName.c_str()); + listener_->OnAuthResult(pkgName, deviceId, "", AuthState::AUTH_REQUEST_INIT, + std::to_string(DM_AUTH_BUSINESS_BUSY)); + return DM_AUTH_BUSINESS_BUSY; + } + + if (!softbusConnector_->HaveDeviceInMap(deviceId)) { + LOGE("AuthenticateDevice failed, the discoveryDeviceInfoMap_ not have this device"); + listener_->OnAuthResult(pkgName, deviceId, "", AuthState::AUTH_REQUEST_INIT, + std::to_string(DM_AUTH_INPUT_FAILED)); + return DM_AUTH_INPUT_FAILED; + } + if (extra.empty()) { + LOGE("AuthenticateDevice failed, extra is empty"); + listener_->OnAuthResult(pkgName, deviceId, "", AuthState::AUTH_REQUEST_INIT, + std::to_string(DM_AUTH_BUSINESS_BUSY)); + return DM_INPUT_PARA_EMPTY; + } + if (authType != AUTH_TYPE_PIN && authType != AUTH_TYPE_SCAN && authType != AUTH_TYPE_TOUCH) { + LOGE("AuthenticateDevice failed, authType is not support"); + listener_->OnAuthResult(pkgName, deviceId, "", AuthState::AUTH_REQUEST_INIT, + std::to_string(DM_AUTH_NOT_SUPPORT)); + return DM_AUTH_NOT_SUPPORT; + } + softbusConnector_->GetSoftbusSession()->UnRegisterSessionCallback(pkgName); + softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(pkgName, shared_from_this()); + + authMessageProcessor_ = std::make_shared(shared_from_this()); + authRequestContext_ = std::make_shared(); + authRequestContext_->hostPkgName = pkgName; + authRequestContext_->authType = authType; + authRequestContext_->deviceId = deviceId; + nlohmann::json jsonObject = nlohmann::json::parse(extra, nullptr, false); + if (!jsonObject.is_discarded()) { + if (jsonObject.contains(TARGET_PKG_NAME_KEY)) { + authRequestContext_->targetPkgName = jsonObject[TARGET_PKG_NAME_KEY]; + } + if (jsonObject.contains(APP_NAME_KEY)) { + authRequestContext_->appName = jsonObject[APP_NAME_KEY]; + } + if (jsonObject.contains(APP_DESCRIPTION_KEY)) { + authRequestContext_->appDesc = jsonObject[APP_DESCRIPTION_KEY]; + } + if (jsonObject.contains(APP_THUMBNAIL)) { + authRequestContext_->appThumbnail = jsonObject[APP_THUMBNAIL]; + } + if (jsonObject.contains(APP_ICON_KEY)) { + authRequestContext_->appIcon = jsonObject[APP_ICON_KEY]; + } + } + authRequestContext_->token = std::to_string(GenRandInt(MIN_PIN_TOKEN, MAX_PIN_TOKEN)); + authRequestState_ = std::make_shared(); + authRequestState_->SetAuthManager(shared_from_this()); + authRequestState_->SetAuthContext(authRequestContext_); + authRequestState_->Enter(); + std::shared_ptr authenticateStartTimer = std::make_shared(AUTHENTICATE_TIMEOUT_TASK); + timerMap_[AUTHENTICATE_TIMEOUT_TASK] = authenticateStartTimer; + authenticateStartTimer->Start(AUTHENTICATE_TIMEOUT, TimeOut, this); + LOGI("DmAuthManager::AuthenticateDevice complete"); + return DM_OK; +} + +int32_t DmAuthManager::UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId) +{ + if (pkgName.empty()) { + LOGI(" DmAuthManager::UnAuthenticateDevice failed pkgName is null"); + return DM_FAILED; + } + + /* Get UDID by NetworkID */ + uint8_t udid[UDID_BUF_LEN] = {0}; + int32_t ret = SoftbusConnector::GetNodeKeyInfoByNetworkId(deviceId.c_str(), NodeDeivceInfoKey::NODE_KEY_UDID, udid, + sizeof(udid)); + if (ret != DM_OK) { + LOGE("UnAuthenticateDevice GetNodeKeyInfo failed"); + return DM_FAILED; + } + std::string deviceUdid = (char *)udid; + + std::string groupId = ""; + std::vector groupList; + hiChainConnector_->GetRelatedGroups(deviceUdid, groupList); + if (groupList.size() > 0) { + groupId = groupList.front().groupId; + LOGI(" DmAuthManager::UnAuthenticateDevice groupId=%s, deviceId=%s, deviceUdid=%s", groupId.c_str(), + deviceId.c_str(), deviceUdid.c_str()); + hiChainConnector_->DeleteGroup(groupId); + } else { + LOGE("DmAuthManager::UnAuthenticateDevice groupList.size = 0"); + return DM_FAILED; + } + return DM_OK; +} + +int32_t DmAuthManager::VerifyAuthentication(const std::string &authParam) +{ + LOGI("DmAuthManager::VerifyAuthentication"); + timerMap_[INPUT_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + + std::shared_ptr ptr; + if (authenticationMap_.find(1) == authenticationMap_.end()) { + LOGE("DmAuthManager::authenticationMap_ is null"); + return DM_FAILED; + } + ptr = authenticationMap_[1]; + + int32_t ret = ptr->VerifyAuthentication(authRequestContext_->token, authResponseContext_->code, authParam); + switch (ret) { + case DM_OK: + { + authRequestState_->TransitionTo(std::make_shared()); + } + break; + case DM_AUTH_INPUT_FAILED: + { + std::string flag = ""; + listener_->OnVerifyAuthResult(authRequestContext_->hostPkgName, authRequestContext_->deviceId, + DM_AUTH_INPUT_FAILED, flag); + } + break; + default: + { + CancelDisplay(); + authRequestState_->TransitionTo(std::make_shared()); + } + } + + LOGI("DmAuthManager::VerifyAuthentication complete"); + return DM_OK; +} + +void DmAuthManager::OnSessionOpened(const std::string &pkgName, int32_t sessionId, int32_t sessionSide, int32_t result) +{ + LOGI("DmAuthManager::OnSessionOpened sessionId=%d result=%d", sessionId, result); + if (sessionSide == AUTH_SESSION_SIDE_SERVER) { + if (authResponseState_ == nullptr) { + authMessageProcessor_ = std::make_shared(shared_from_this()); + authResponseState_ = std::make_shared(); + authResponseState_->SetAuthManager(shared_from_this()); + authResponseState_->Enter(); + hiChainConnector_->RegisterHiChainCallback(pkgName, shared_from_this()); + authResponseContext_ = std::make_shared(); + std::shared_ptr waitStartTimer = std::make_shared(WAIT_NEGOTIATE_TIMEOUT_TASK); + timerMap_[WAIT_NEGOTIATE_TIMEOUT_TASK] = waitStartTimer; + waitStartTimer->Start(WAIT_NEGOTIATE_TIMEOUT, TimeOut, this); + std::shared_ptr authenticateStartTimer = std::make_shared(AUTHENTICATE_TIMEOUT_TASK); + timerMap_[AUTHENTICATE_TIMEOUT_TASK] = authenticateStartTimer; + authenticateStartTimer->Start(AUTHENTICATE_TIMEOUT, TimeOut, this); + } else { + std::shared_ptr authMessageProcessor = + std::make_shared(shared_from_this()); + std::shared_ptr authResponseContext = std::make_shared(); + authResponseContext->reply = AuthState::AUTH_RESPONSE_INIT; + authMessageProcessor->SetResponseContext(authResponseContext); + std::string message = authMessageProcessor->CreateSimpleMessage(MSG_TYPE_REQ_AUTH_TERMINATE); + softbusConnector_->GetSoftbusSession()->SendData(sessionId, message); + } + } else { + if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_INIT) { + hiChainConnector_->RegisterHiChainCallback(pkgName, shared_from_this()); + authRequestContext_->sessionId = sessionId; + authRequestState_->SetAuthContext(authRequestContext_); + authMessageProcessor_->SetRequestContext(authRequestContext_); + authResponseContext_ = std::make_shared(); + authRequestState_->TransitionTo(std::make_shared()); + } else { + LOGE("DmAuthManager::OnSessionOpened but request state %d is wrong", authRequestState_->GetStateType()); + } + } +} + +void DmAuthManager::OnSessionClosed(const std::string &pkgName, int32_t sessionId) +{ + LOGI("DmAuthManager::OnSessionOpened sessionId=%d", sessionId); +} + +void DmAuthManager::OnDataReceived(const std::string &pkgName, int32_t sessionId, std::string message) +{ + LOGI("DmAuthManager::OnDataReceived start"); + if (authRequestState_ == nullptr && authResponseState_ == nullptr) { + LOGI("DmAuthManager::GetAuthState failed"); + return; + } + authResponseContext_->sessionId = sessionId; + authMessageProcessor_->SetResponseContext(authResponseContext_); + int32_t ret = authMessageProcessor_->ParseMessage(message); + if (ret != DM_OK) { + LOGE("OnDataReceived, parse message error"); + return; + } + authResponseContext_ = authMessageProcessor_->GetResponseContext(); + if (authResponseState_ == nullptr) { + authRequestContext_ = authMessageProcessor_->GetRequestContext(); + authRequestState_->SetAuthContext(authRequestContext_); + } else { + authResponseState_->SetAuthContext(authResponseContext_); + } + switch (authResponseContext_->msgType) { + case MSG_TYPE_NEGOTIATE: + if (authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_INIT) { + timerMap_[WAIT_NEGOTIATE_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + authResponseState_->TransitionTo(std::make_shared()); + } else { + LOGE("Device manager auth state error"); + } + break; + case MSG_TYPE_REQ_AUTH: + if (authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_NEGOTIATE) { + timerMap_[WAIT_REQUEST_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + authResponseState_->TransitionTo(std::make_shared()); + } else { + LOGE("Device manager auth state error"); + } + break; + case MSG_TYPE_RESP_AUTH: + if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE_DONE) { + authRequestState_->TransitionTo(std::make_shared()); + } else { + LOGE("Device manager auth state error"); + } + break; + case MSG_TYPE_RESP_NEGOTIATE: + if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE) { + authRequestState_->TransitionTo(std::make_shared()); + } else { + LOGE("Device manager auth state error"); + } + break; + case MSG_TYPE_REQ_AUTH_TERMINATE: + if (authResponseState_ != nullptr && + authResponseState_->GetStateType() != AuthState::AUTH_RESPONSE_FINISH) { + authResponseState_->TransitionTo(std::make_shared()); + } else if (authRequestState_ != nullptr && + authRequestState_->GetStateType() != AuthState::AUTH_REQUEST_FINISH) { + LOGE("Device manager auth state error"); + } + break; + default: + break; + } +} + +void DmAuthManager::OnGroupCreated(int64_t requestId, const std::string &groupId) +{ + //创建群组成功 + //发送认证响应消息给请求端 + LOGI("DmAuthManager::OnGroupCreated start"); + if (authResponseState_ == nullptr) { + LOGI("DmAuthManager::AuthenticateDevice end"); + return; + } + if (groupId == "{}") { + authResponseContext_->reply = DM_HICHAIN_GROUP_CREATE_FAILED; + authMessageProcessor_->SetResponseContext(authResponseContext_); + std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_RESP_AUTH); + softbusConnector_->GetSoftbusSession()->SendData(authResponseContext_->sessionId, message); + return; + } + authResponseContext_->groupId = groupId; + authMessageProcessor_->SetResponseContext(authResponseContext_); + std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_RESP_AUTH); + softbusConnector_->GetSoftbusSession()->SendData(authResponseContext_->sessionId, message); + authResponseState_->TransitionTo(std::make_shared()); +} + +void DmAuthManager::OnMemberJoin(int64_t requestId, int32_t status) +{ + LOGI("DmAuthManager OnMemberJoin start"); + CancelDisplay(); + + LOGE("DmAuthManager OnMemberJoin start"); + if (authRequestState_ != nullptr) { + timerMap_[ADD_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + if (status != DM_OK || authResponseContext_->requestId != requestId) { + if (authRequestState_ != nullptr) { + authResponseContext_->reply = AuthState::AUTH_REQUEST_JOIN; + authRequestContext_->reason = DM_AUTH_INPUT_FAILED; + authRequestState_->TransitionTo(std::make_shared()); + return; + } + } + authRequestState_->TransitionTo(std::make_shared()); + } +} + +void DmAuthManager::HandleAuthenticateTimeout() +{ + // 1. 状态机走到结束状态，并清理资源 + LOGI("DmAuthManager::HandleAuthenticateTimeout start"); + if (authRequestState_ != nullptr && authRequestState_->GetStateType() != AuthState::AUTH_REQUEST_FINISH) { + if (authResponseContext_ == nullptr) { + authResponseContext_ = std::make_shared(); + } + authResponseContext_->reply = authRequestState_->GetStateType(); + authRequestContext_->reason = DM_TIME_OUT; + authRequestState_->TransitionTo(std::make_shared()); + } + LOGI("DmAuthManager::HandleAuthenticateTimeout start complete"); +} + +void DmAuthManager::EstablishAuthChannel(const std::string &deviceId) +{ + // TODO:检查crypto模块是否适配 + // TODO：兼容性处理，兼容与手机的认证 + int32_t sessionId = softbusConnector_->GetSoftbusSession()->OpenAuthSession(deviceId); + if (sessionId < 0) { + LOGE("OpenAuthSession failed, stop the authentication"); + authResponseContext_ = std::make_shared(); + authResponseContext_->reply = AuthState::AUTH_REQUEST_NEGOTIATE; + authRequestContext_->reason = DM_AUTH_OPEN_SESSION_FAILED; + authRequestState_->TransitionTo(std::make_shared()); + } +} + +void DmAuthManager::StartNegotiate(const int32_t &sessionId) +{ + LOGE("DmAuthManager::EstablishAuthChannel session id is %d", sessionId); + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + authResponseContext_->localDeviceId = localDeviceId; + authResponseContext_->reply = DM_AUTH_NOT_AUTH; + authMessageProcessor_->SetResponseContext(authResponseContext_); + std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_NEGOTIATE); + softbusConnector_->GetSoftbusSession()->SendData(sessionId, message); + std::shared_ptr negotiateStartTimer = std::make_shared(NEGOTIATE_TIMEOUT_TASK); + timerMap_[NEGOTIATE_TIMEOUT_TASK] = negotiateStartTimer; + negotiateStartTimer->Start(NEGOTIATE_TIMEOUT, TimeOut, this); +} + +void DmAuthManager::RespNegotiate(const int32_t &sessionId) +{ + LOGE("DmAuthManager::EstablishAuthChannel session id is %d", sessionId); + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + bool ret = hiChainConnector_->IsDevicesInGroup(authResponseContext_->localDeviceId, localDeviceId); + if (ret != true){ + LOGE("DmAuthManager::EstablishAuthChannel device is in group"); + authResponseContext_->reply = DM_AUTH_PEER_REJECT; + } else { + authResponseContext_->reply = DM_AUTH_NOT_AUTH; + } + + std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_RESP_NEGOTIATE); + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + softbusConnector_->GetSoftbusSession()->SendData(sessionId, message); + } + authResponseContext_ = authResponseState_->GetAuthContext(); + if (jsonObject[TAG_CRYPTO_SUPPORT] == "true" && authResponseContext_->cryptoSupport == true) { + if (jsonObject[TAG_CRYPTO_NAME] == authResponseContext_->cryptoName && + jsonObject[TAG_CRYPTO_VERSION] == authResponseContext_->cryptoVer) { + isCryptoSupport_ = true; + softbusConnector_->GetSoftbusSession()->SendData(sessionId, message); + return; + } + } + jsonObject[TAG_CRYPTO_SUPPORT] = "false"; + message = jsonObject.dump(); + softbusConnector_->GetSoftbusSession()->SendData(sessionId, message); + std::shared_ptr waitStartTimer = std::make_shared(WAIT_REQUEST_TIMEOUT_TASK); + timerMap_[WAIT_REQUEST_TIMEOUT_TASK] = waitStartTimer; + waitStartTimer->Start(WAIT_REQUEST_TIMEOUT, TimeOut, this); +} + +void DmAuthManager::SendAuthRequest(const int32_t &sessionId) +{ + LOGE("DmAuthManager::EstablishAuthChannel session id"); + timerMap_[NEGOTIATE_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + if (authResponseContext_->cryptoSupport == true) { + isCryptoSupport_ = true; + } + + if (authResponseContext_->reply == DM_AUTH_PEER_REJECT) { + authRequestState_->TransitionTo(std::make_shared()); + return; + } + + std::vector messageList = authMessageProcessor_->CreateAuthRequestMessage(); + for (auto msg : messageList) { + softbusConnector_->GetSoftbusSession()->SendData(sessionId, msg); + } + std::shared_ptr confirmStartTimer = std::make_shared(CONFIRM_TIMEOUT_TASK); + timerMap_[CONFIRM_TIMEOUT_TASK] = confirmStartTimer; + confirmStartTimer->Start(CONFIRM_TIMEOUT, TimeOut, this); +} + +void DmAuthManager::StartAuthProcess(const int32_t &action) +{ + // 1. 收到请求响应，判断用户响应结果 + // 2. 用户授权同意 + // 3. 回调给认证实现模块，启动认证 + LOGI("DmAuthManager:: StartAuthProcess"); + authResponseContext_->reply = action; + if (authResponseContext_->reply == USER_OPERATION_TYPE_ALLOW_AUTH && + authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_CONFIRM) { + authResponseState_->TransitionTo(std::make_shared()); + } else { + authMessageProcessor_->SetResponseContext(authResponseContext_); + std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_RESP_AUTH); + softbusConnector_->GetSoftbusSession()->SendData(authResponseContext_->sessionId, message); + } +} + +void DmAuthManager::StartRespAuthProcess() +{ + LOGI("DmAuthManager::StartRespAuthProcess StartRespAuthProcess", authResponseContext_->sessionId); + timerMap_[CONFIRM_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + if (authResponseContext_->reply == USER_OPERATION_TYPE_ALLOW_AUTH) { + std::shared_ptr inputStartTimer = std::make_shared(INPUT_TIMEOUT_TASK); + timerMap_[INPUT_TIMEOUT_TASK] = inputStartTimer; + inputStartTimer->Start(INPUT_TIMEOUT, TimeOut, this); + authRequestState_->TransitionTo(std::make_shared()); + } else { + LOGE("do not accept"); + authResponseContext_->reply = AuthState::AUTH_REQUEST_REPLY; + authRequestContext_->reason = DM_AUTH_PEER_REJECT; + authRequestState_->TransitionTo(std::make_shared()); + } +} + +void DmAuthManager::CreateGroup() +{ + LOGI("DmAuthManager:: CreateGroup"); + authResponseContext_->groupName = GenerateGroupName(); + authResponseContext_->requestId = GenRandLongLong(MIN_REQUEST_ID, MAX_REQUEST_ID); + hiChainConnector_->CreateGroup(authResponseContext_->requestId, authResponseContext_->groupName); +} + +void DmAuthManager::AddMember(const std::string &deviceId) +{ + LOGI("DmAuthManager::AddMember start"); + nlohmann::json jsonObject; + jsonObject[TAG_GROUP_ID] = authResponseContext_->groupId; + jsonObject[TAG_GROUP_NAME] = authResponseContext_->groupName; + jsonObject[PIN_CODE_KEY] = authResponseContext_->code; + jsonObject[TAG_REQUEST_ID] = authResponseContext_->requestId; + jsonObject[TAG_DEVICE_ID] = authResponseContext_->deviceId; + std::string connectInfo = jsonObject.dump(); + std::shared_ptr joinStartTimer = std::make_shared(ADD_TIMEOUT_TASK); + timerMap_[ADD_TIMEOUT_TASK] = joinStartTimer; + joinStartTimer->Start(ADD_TIMEOUT, TimeOut, this); + int32_t ret = hiChainConnector_->AddMember(deviceId, connectInfo); + if (ret != 0) { + return; + } + LOGI("DmAuthManager::authRequestContext CancelDisplay start"); + CancelDisplay(); +} + +std::string DmAuthManager::GetConnectAddr(std::string deviceId) +{ + LOGI("DmAuthManager::GetConnectAddr"); + std::string connectAddr; + softbusConnector_->GetConnectAddr(deviceId, connectAddr); + return connectAddr; +} + +void DmAuthManager::JoinNetwork() +{ + // TODO: + LOGE("DmAuthManager JoinNetwork start"); + timerMap_[AUTHENTICATE_TIMEOUT_TASK]->Stop(SESSION_CANCEL_TIMEOUT); + authResponseContext_->reply = AuthState::AUTH_REQUEST_FINISH; + authRequestContext_->reason = DM_OK; + authRequestState_->TransitionTo(std::make_shared()); +} + +void DmAuthManager::AuthenticateFinish() +{ + LOGI("DmAuthManager::AuthenticateFinish start"); + if (authResponseState_ != nullptr) { + if (authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_FINISH) { + CancelDisplay(); + } + if (!timerMap_.empty()) { + for (auto &iter : timerMap_) { + iter.second->Stop(SESSION_CANCEL_TIMEOUT); + } + timerMap_.clear(); + } + authResponseContext_ = nullptr; + authResponseState_ = nullptr; + authMessageProcessor_ = nullptr; + } else if (authRequestState_ != nullptr) { + std::string flag = ""; + if (authResponseContext_->reply < AuthState::AUTH_RESPONSE_INIT) { + authMessageProcessor_->SetResponseContext(authResponseContext_); + std::string message = authMessageProcessor_->CreateSimpleMessage(MSG_TYPE_REQ_AUTH_TERMINATE); + softbusConnector_->GetSoftbusSession()->SendData(authResponseContext_->sessionId, message); + } + + + if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_INPUT) { + CancelDisplay(); + } + + listener_->OnAuthResult(authRequestContext_->hostPkgName, authRequestContext_->deviceId, + authRequestContext_->token, authResponseContext_->reply, + std::to_string(authRequestContext_->reason)); + + softbusConnector_->GetSoftbusSession()->UnRegisterSessionCallback(authRequestContext_->hostPkgName); + softbusConnector_->GetSoftbusSession()->CloseAuthSession(authRequestContext_->sessionId); + if (!timerMap_.empty()) { + for (auto &iter : timerMap_) { + iter.second->Stop(SESSION_CANCEL_TIMEOUT); + } + timerMap_.clear(); + } + authRequestContext_ = nullptr; + authResponseContext_ = nullptr; + authRequestState_ = nullptr; + authMessageProcessor_ = nullptr; + } + LOGI("DmAuthManager::AuthenticateFinish complete"); +} + +void DmAuthManager::CancelDisplay() +{ + LOGI("DmAuthManager::CancelDisplay start"); + nlohmann::json jsonObj; + jsonObj[CANCEL_DISPLAY_KEY] = CANCEL_PICODE_DISPLAY; + std::string paramJson = jsonObj.dump(); + std::string pkgName = "com.ohos.devicemanagerui"; + listener_->OnFaCall(pkgName, paramJson); +} + +int32_t DmAuthManager::GeneratePincode() +{ + return GenRandInt(MIN_PIN_CODE, MAX_PIN_CODE); +} + +std::string DmAuthManager::GenerateGroupName() +{ + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + std::string sLocalDeviceID = localDeviceId; + std::string groupName = authResponseContext_->targetPkgName + authResponseContext_->hostPkgName + + sLocalDeviceID.substr(0, sLocalDeviceID.size() / DEVICE_ID_HALF); + return groupName; +} + +void DmAuthManager::GetIsCryptoSupport(bool &isCryptoSupport) +{ + LOGI("DmAuthManager::GetIsCryptoSupport start"); + if (authResponseState_ == nullptr) { + isCryptoSupport = false; + return; + } + if (authRequestState_ == nullptr) { + if (authResponseState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE_DONE) { + isCryptoSupport = false; + return; + } + } else { + if (authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE || + authRequestState_->GetStateType() == AuthState::AUTH_REQUEST_NEGOTIATE_DONE) { + isCryptoSupport = false; + return; + } + } + + isCryptoSupport = isCryptoSupport_; +} + +void DmAuthManager::SetAuthRequestState(std::shared_ptr authRequestState) +{ + authRequestState_ = authRequestState; +} + +void DmAuthManager::SetAuthResponseState(std::shared_ptr authResponseState) +{ + authResponseState_ = authResponseState; +} + +int32_t DmAuthManager::GetPinCode() +{ + return authResponseContext_->code; +} + +void DmAuthManager::ShowConfigDialog() +{ + std::shared_ptr authUi_ = std::make_shared(); + dmAbilityMgr_ = std::make_shared(); + authUi_->ShowConfirmDialog(dmAbilityMgr_); +} + +void DmAuthManager::ShowAuthInfoDialog() +{ + return; +} + +void DmAuthManager::ShowStartAuthDialog() +{ + LOGI("DmAuthManager::ShowStartAuthDialog start"); + dmAbilityMgr_ = std::make_shared(); + std::shared_ptr ptr; + if (authenticationMap_.find(1) == authenticationMap_.end()) { + LOGE("DmAuthManager::authenticationMap_ is null"); + return; + } + ptr = authenticationMap_[1]; + ptr->StartAuth(dmAbilityMgr_); +} + +int32_t DmAuthManager::GetAuthenticationParam(DmAuthParam &authParam) +{ + dmAbilityMgr_->StartAbilityDone(); + AbilityRole role = dmAbilityMgr_->GetAbilityRole(); + authParam.direction = (int32_t)role; + // Currently, only Support PinCode, authType not save. + authParam.authType = AUTH_TYPE_PIN; + authParam.authToken = authResponseContext_->token; + + if (role == AbilityRole::ABILITY_ROLE_PASSIVE) { + // 生成pincode + authResponseContext_->code = GeneratePincode(); + authParam.packageName = authResponseContext_->targetPkgName; + authParam.appName = authResponseContext_->appName; + authParam.appDescription = authResponseContext_->appDesc; + // currently, only support BUSINESS_FA_MIRGRATION + authParam.business = BUSINESS_FA_MIRGRATION; + // 获取生成的pincode + authParam.pincode = authResponseContext_->code; + } + return DM_OK; +} + +int32_t DmAuthManager::RegisterSessionCallback() +{ + LOGI("DmAuthManager constructor111"); + softbusConnector_->GetSoftbusSession()->RegisterSessionCallback(DM_PKG_NAME, shared_from_this()); + return DM_OK; +} + +int32_t DmAuthManager::OnUserOperation(int32_t action) +{ + switch (action) + { + case USER_OPERATION_TYPE_ALLOW_AUTH: + case USER_OPERATION_TYPE_CANCEL_AUTH: + StartAuthProcess(action); + break; + case USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT: + AuthenticateFinish(); + break; + case USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY: + CancelDisplay(); + break; + case USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT: + AuthenticateFinish(); + break; + default: + LOGE("this action id not support"); + break; + } + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/config/config_manager.cpp b/services/devicemanagerservice/src/config/config_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..76b77a308b388bb150e19549486ed39fb0984cba --- /dev/null +++ b/services/devicemanagerservice/src/config/config_manager.cpp @@ -0,0 +1,299 @@ +/* + * 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 "config_manager.h" + +#include + +#include "dm_constants.h" +#include "dm_log.h" +#include "json_config.h" +#include "nlohmann/json.hpp" + +namespace OHOS { +namespace DistributedHardware { +void from_json(const nlohmann::json &jsonObject, AdapterSoLoadInfo &soLoadInfo) +{ + if (!jsonObject.contains("name") || !jsonObject.contains("type") || !jsonObject.contains("version") || + !jsonObject.contains("funcName") || !jsonObject.contains("soName") || !jsonObject.contains("soPath")) { + LOGE("AdapterSoLoadInfo json key Not complete"); + return; + } + + jsonObject["name"].get_to(soLoadInfo.name); + jsonObject["type"].get_to(soLoadInfo.type); + jsonObject["version"].get_to(soLoadInfo.version); + jsonObject["funcName"].get_to(soLoadInfo.funcName); + jsonObject["soName"].get_to(soLoadInfo.soName); + jsonObject["soPath"].get_to(soLoadInfo.soPath); +} + +void from_json(const nlohmann::json &jsonObject, AuthSoLoadInfo &soLoadInfo) +{ + if (!jsonObject.contains("name") || !jsonObject.contains("type") || !jsonObject.contains("version") || + !jsonObject.contains("funcName") || !jsonObject.contains("soName") || !jsonObject.contains("soPath") || + !jsonObject.contains("authType")) { + LOGE("AuthSoLoadInfo json key Not complete"); + return; + } + + jsonObject["name"].get_to(soLoadInfo.name); + jsonObject["type"].get_to(soLoadInfo.type); + jsonObject["version"].get_to(soLoadInfo.version); + jsonObject["authType"].get_to(soLoadInfo.authType); + jsonObject["funcName"].get_to(soLoadInfo.funcName); + jsonObject["soName"].get_to(soLoadInfo.soName); + jsonObject["soPath"].get_to(soLoadInfo.soPath); +} + +DmConfigManager &DmConfigManager::GetInstance() +{ + static DmConfigManager instance; + return instance; +} + +DmConfigManager::DmConfigManager() +{ + LOGI("DmConfigManager constructor"); + do { + nlohmann::json adapterJsonObject = nlohmann::json::parse(adapterJsonConfigString, nullptr, false); + if (adapterJsonObject.is_discarded()) { + LOGE("adapter json config string parse error"); + break; + } + const char *jsonKey = ADAPTER_LOAD_JSON_KEY.c_str(); + if (!adapterJsonObject.contains(jsonKey)) { + LOGE("adapter json config string key not exist"); + break; + } + auto soLoadInfo = adapterJsonObject[jsonKey].get>(); + for (uint32_t i = 0; i < soLoadInfo.size(); i++) { + if (soLoadInfo[i].name.size() == 0 || soLoadInfo[i].type.size() == 0 || soLoadInfo[i].version.size() == 0 || + soLoadInfo[i].funcName.size() == 0 || soLoadInfo[i].soName.size() == 0 || + soLoadInfo[i].soPath.size() == 0) { + LOGE("adapter json config string exist invalid members"); + continue; + } + soAdapterLoadInfo_[soLoadInfo[i].soName] = soLoadInfo[i]; + LOGI("soAdapterLoadInfo name is: %s", soLoadInfo[i].name.c_str()); + LOGI("soAdapterLoadInfo type is: %s", soLoadInfo[i].type.c_str()); + LOGI("soAdapterLoadInfo version is: %s", soLoadInfo[i].version.c_str()); + LOGI("soAdapterLoadInfo funcName is: %s", soLoadInfo[i].funcName.c_str()); + LOGI("soAdapterLoadInfo soName is: %s", soLoadInfo[i].soName.c_str()); + LOGI("soAdapterLoadInfo soPath is: %s", soLoadInfo[i].soPath.c_str()); + } + } while (0); + + do { + nlohmann::json authJsonObject = nlohmann::json::parse(authJsonConfigString, nullptr, false); + if (authJsonObject.is_discarded()) { + LOGE("auth json config string parse error!\n"); + break; + } + const char *jsonKey = AUTH_LOAD_JSON_KEY.c_str(); + if (!authJsonObject.contains(jsonKey)) { + LOGE("auth json config string key not exist!\n"); + break; + } + auto soLoadInfo = authJsonObject[jsonKey].get>(); + for (uint32_t i = 0; i < soLoadInfo.size(); i++) { + if (soLoadInfo[i].name.size() == 0 || soLoadInfo[i].type.size() == 0 || soLoadInfo[i].version.size() == 0 || + soLoadInfo[i].funcName.size() == 0 || soLoadInfo[i].soName.size() == 0 || + soLoadInfo[i].soPath.size() == 0) { + LOGE("adapter json config string exist invalid members"); + continue; + } + soAuthLoadInfo_[soLoadInfo[i].authType] = soLoadInfo[i]; + LOGI("soAuthLoadInfo name is: %s", soLoadInfo[i].name.c_str()); + LOGI("soAuthLoadInfo type is: %s", soLoadInfo[i].type.c_str()); + LOGI("soAuthLoadInfo version is: %s", soLoadInfo[i].version.c_str()); + LOGI("soAuthLoadInfo funcName is: %s", soLoadInfo[i].funcName.c_str()); + LOGI("soAuthLoadInfo soName is: %s", soLoadInfo[i].soName.c_str()); + LOGI("soAuthLoadInfo soPath is: %s", soLoadInfo[i].soPath.c_str()); + LOGI("soAuthLoadInfo authType is: %d", soLoadInfo[i].authType); + } + } while (0); +} + +DmConfigManager::~DmConfigManager() +{ + void *so_handle = nullptr; + for (auto iter = soAdapterLoadInfo_.begin(); iter != soAdapterLoadInfo_.end(); iter++) { + std::string soPathName = (iter->second).soPath + (iter->second).soName; + so_handle = dlopen(soPathName.c_str(), RTLD_NOW | RTLD_NOLOAD); + if (so_handle != nullptr) { + dlclose(so_handle); + } + } + for (auto iter = soAuthLoadInfo_.begin(); iter != soAuthLoadInfo_.end(); iter++) { + std::string soPathName = (iter->second).soPath + (iter->second).soName; + so_handle = dlopen(soPathName.c_str(), RTLD_NOW | RTLD_NOLOAD); + if (so_handle != nullptr) { + dlclose(so_handle); + } + } + LOGI("DmAdapterManager destructor"); +} + +std::shared_ptr DmConfigManager::GetDecisionAdapter(const std::string &soName) +{ + if (soName.empty()) { + LOGE("soName size is zero"); + return nullptr; + } + auto soInfoIter = soAdapterLoadInfo_.find(soName); + if (soInfoIter == soAdapterLoadInfo_.end() || (soInfoIter->second).type != DECISION_JSON_TYPE_KEY) { + LOGE("not find so info or type key not match"); + return nullptr; + } + std::unique_lock locker(decisionAdapterMutex_); + auto ptrIter = decisionAdapterPtr_.find(soName); + if (ptrIter != decisionAdapterPtr_.end()) { + return decisionAdapterPtr_[soName]; + } + void *so_handle = nullptr; + std::string soPathName = (soInfoIter->second).soPath + (soInfoIter->second).soName; + so_handle = dlopen(soPathName.c_str(), RTLD_NOW | RTLD_NOLOAD); + if (so_handle == nullptr) { + so_handle = dlopen(soPathName.c_str(), RTLD_NOW); + if (so_handle == nullptr) { + LOGE("load decision so %s failed", soName.c_str()); + return nullptr; + } + } + dlerror(); + auto func = (CreateIDecisionAdapterFuncPtr)dlsym(so_handle, (soInfoIter->second).funcName.c_str()); + if (dlerror() != nullptr || func == nullptr) { + LOGE("Create object function is not exist"); + return nullptr; + } + std::shared_ptr iDecisionAdapter(func()); + decisionAdapterPtr_[soName] = iDecisionAdapter; + return decisionAdapterPtr_[soName]; +} + +std::shared_ptr DmConfigManager::GetProfileAdapter(const std::string &soName) +{ + if (soName.empty()) { + LOGE("soName size is zero"); + return nullptr; + } + + auto soInfoIter = soAdapterLoadInfo_.find(soName); + if (soInfoIter == soAdapterLoadInfo_.end() || (soInfoIter->second).type != PROFILE_JSON_TYPE_KEY) { + LOGE("not find so info or type key not match"); + return nullptr; + } + std::unique_lock locker(profileAdapterMutex_); + auto ptrIter = profileAdapterPtr_.find(soName); + if (ptrIter != profileAdapterPtr_.end()) { + return profileAdapterPtr_[soName]; + } + void *so_handle = nullptr; + std::string soPathName = (soInfoIter->second).soPath + (soInfoIter->second).soName; + so_handle = dlopen(soPathName.c_str(), RTLD_NOW | RTLD_NOLOAD); + if (so_handle == nullptr) { + so_handle = dlopen(soPathName.c_str(), RTLD_NOW); + if (so_handle == nullptr) { + LOGE("load profile so %s failed", soName.c_str()); + return nullptr; + } + } + dlerror(); + auto func = (CreateIProfileAdapterFuncPtr)dlsym(so_handle, (soInfoIter->second).funcName.c_str()); + if (dlerror() != nullptr || func == nullptr) { + LOGE("Create object function is not exist"); + return nullptr; + } + std::shared_ptr iProfileAdapter(func()); + profileAdapterPtr_[soName] = iProfileAdapter; + return profileAdapterPtr_[soName]; +} + +std::shared_ptr DmConfigManager::GetCryptoAdapter(const std::string &soName) +{ + if (soName.empty()) { + LOGE("soName size is zero"); + return nullptr; + } + + auto soInfoIter = soAdapterLoadInfo_.find(soName); + if (soInfoIter == soAdapterLoadInfo_.end() || (soInfoIter->second).type != CPYPTO_JSON_TYPE_KEY) { + LOGE("not find so info or type key not match"); + return nullptr; + } + + std::unique_lock locker(cryptoAdapterMutex_); + auto ptrIter = cryptoAdapterPtr_.find(soName); + if (ptrIter != cryptoAdapterPtr_.end()) { + return cryptoAdapterPtr_[soName]; + } + + void *so_handle = nullptr; + std::string soPathName = (soInfoIter->second).soPath + (soInfoIter->second).soName; + so_handle = dlopen(soPathName.c_str(), RTLD_NOW | RTLD_NOLOAD); + if (so_handle == nullptr) { + so_handle = dlopen(soPathName.c_str(), RTLD_NOW); + if (so_handle == nullptr) { + LOGE("load crypto so %s failed", soName.c_str()); + return nullptr; + } + } + + dlerror(); + auto func = (CreateICryptoAdapterFuncPtr)dlsym(so_handle, (soInfoIter->second).funcName.c_str()); + if (dlerror() != nullptr || func == nullptr) { + LOGE("Create object function is not exist"); + return nullptr; + } + + std::shared_ptr iCryptoAdapter(func()); + cryptoAdapterPtr_[soName] = iCryptoAdapter; + return cryptoAdapterPtr_[soName]; +} + +void DmConfigManager::GetAuthAdapter(std::map> &authAdapter) +{ + authAdapter.clear(); + for (auto iter = soAuthLoadInfo_.begin(); iter != soAuthLoadInfo_.end(); iter++) { + if ((iter->second).type != AUTH_JSON_TYPE_KEY) { + LOGE("type key not match"); + continue; + } + + void *so_handle = nullptr; + std::string soPathName = (iter->second).soPath + (iter->second).soName; + so_handle = dlopen(soPathName.c_str(), RTLD_NOW | RTLD_NOLOAD); + if (so_handle == nullptr) { + so_handle = dlopen(soPathName.c_str(), RTLD_NOW); + if (so_handle == nullptr) { + LOGE("load auth so %s failed", (iter->second).soName.c_str()); + continue; + } + } + + dlerror(); + auto func = (CreateIAuthAdapterFuncPtr)dlsym(so_handle, (iter->second).funcName.c_str()); + if (dlerror() != nullptr || func == nullptr) { + LOGE("Create object function is not exist"); + continue; + } + + std::shared_ptr iAuthentication(func()); + authAdapter[iter->first] = iAuthentication; + LOGI("so name: %s, auth type: %d", (iter->second).soName.c_str(), iter->first); + } +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/devicemanagerservice/src/dependency/commonevent/event_manager_adapt.cpp b/services/devicemanagerservice/src/dependency/commonevent/event_manager_adapt.cpp new file mode 100644 index 0000000000000000000000000000000000000000..91e7fba25b9a97ed357431412c7b267aaa131d12 --- /dev/null +++ b/services/devicemanagerservice/src/dependency/commonevent/event_manager_adapt.cpp @@ -0,0 +1,151 @@ +/* + * 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 "event_manager_adapt.h" + +#include + +#include "dm_constants.h" + +using namespace OHOS::EventFwk; + +namespace OHOS { +namespace DistributedHardware { +std::once_flag DmCommonEventManager::onceFlag_; +std::list DmCommonEventManager::callbackQueue_; +std::mutex DmCommonEventManager::callbackQueueMutex_; +std::condition_variable DmCommonEventManager::notEmpty_; + +DmCommonEventManager &DmCommonEventManager::GetInstance() +{ + static DmCommonEventManager instance; + std::call_once(onceFlag_, [] { + std::thread th(DealCallback); + th.detach(); + }); + return instance; +} + +void DmCommonEventManager::DealCallback(void) +{ + while (1) { + std::unique_lock callbackQueueLock(callbackQueueMutex_); + notEmpty_.wait(callbackQueueLock, [] { return !callbackQueue_.empty(); }); + CommomEventCallback funcPrt = callbackQueue_.front(); + funcPrt(); + callbackQueue_.pop_front(); + } +} + +bool DmCommonEventManager::SubscribeServiceEvent(const std::string &event, CommomEventCallback callback) +{ + LOGI("Subscribe event: %s", event.c_str()); + if (dmEventSubscriber_.find(event) != dmEventSubscriber_.end()) { + LOGE("Subscribe event：%s has been added", event.c_str()); + return false; + } + + MatchingSkills matchingSkills; + matchingSkills.AddEvent(event); + CommonEventSubscribeInfo subscriberInfo(matchingSkills); + std::shared_ptr subscriber = std::make_shared(subscriberInfo); + if (subscriber == nullptr) { + LOGE("subscriber is nullptr %s", event.c_str()); + return false; + } + subscriber->addEventCallback(event, callback); + + bool subscribeResult = CommonEventManager::SubscribeCommonEvent(subscriber); + if (subscribeResult) { + LOGE("Subscribe service event success: %s", event.c_str()); + dmEventSubscriber_[event] = subscriber; + return subscribeResult; + } else { + LOGE("Subscribe service event failed: %s", event.c_str()); + return false; + } +} + +bool DmCommonEventManager::UnsubscribeServiceEvent(const std::string &event) +{ + LOGI("UnSubscribe event: %s", event.c_str()); + if (dmEventSubscriber_.find(event) != dmEventSubscriber_.end()) { + LOGE("UnSubscribe event: %s not been exist", event.c_str()); + return false; + } + + bool unsubscribeResult = CommonEventManager::UnSubscribeCommonEvent(dmEventSubscriber_[event]); + if (unsubscribeResult) { + LOGI("Unsubscribe service event success: %s", event.c_str()); + dmEventSubscriber_[event]->deleteEventCallback(event); + dmEventSubscriber_.erase(event); + return unsubscribeResult; + } else { + LOGE("Unsubscribe service event failed: %s", event.c_str()); + return false; + } +} + +DmCommonEventManager::~DmCommonEventManager() +{ + for (auto iter = dmEventSubscriber_.begin(); iter != dmEventSubscriber_.end(); iter++) { + bool unsubscribeResult = CommonEventManager::UnSubscribeCommonEvent(iter->second); + if (unsubscribeResult) { + LOGI("Unsubscribe service event success: %s", iter->first.c_str()); + } + } +} + +void DmCommonEventManager::EventSubscriber::OnReceiveEvent(const CommonEventData &data) +{ + std::string event = data.GetWant().GetAction(); + LOGI("Received event: %s, value: %d", event.c_str()); + + std::unique_lock callbackLock(callbackLock_); + auto iter = dmEventCallback_.find(event); + if (iter != dmEventCallback_.end()) { + CommomEventCallback funcPrt = iter->second; + callbackLock_.unlock(); + + std::unique_lock callbackQueueLock(callbackQueueMutex_); + if (callbackQueue_.size() <= COMMON_CALLBACK_MAX_SIZE) { + callbackQueue_.push_back(funcPrt); + notEmpty_.notify_one(); + } else { + LOGE("event callback Queue is too long"); + } + } +} + +void DmCommonEventManager::EventSubscriber::addEventCallback(const std::string &event, CommomEventCallback callback) +{ + std::unique_lock callbackLock(callbackLock_); + if (dmEventCallback_.find(event) == dmEventCallback_.end()) { + dmEventCallback_[event] = callback; + LOGI("add event success: %s", event.c_str()); + } +} + +void DmCommonEventManager::EventSubscriber::deleteEventCallback(const std::string &event) +{ + std::unique_lock callbackLock(callbackLock_); + if (dmEventCallback_.find(event) != dmEventCallback_.end()) { + dmEventCallback_.erase(event); + LOGI("delete event failed: %s", event.c_str()); + } +} + +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/auth/hichain_connector.cpp b/services/devicemanagerservice/src/dependency/hichain/hichain_connector.cpp similarity index 39% rename from services/devicemanagerservice/src/auth/hichain_connector.cpp rename to services/devicemanagerservice/src/dependency/hichain/hichain_connector.cpp index 88516aebdefde1f38cde431a52a2540780384802..5898ed3f08dbbcb420de79c39d646a6b682ff53a 100644 --- a/services/devicemanagerservice/src/auth/hichain_connector.cpp +++ b/services/devicemanagerservice/src/dependency/hichain/hichain_connector.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,48 +15,23 @@ #include "hichain_connector.h" +#include + #include #include #include -#include +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "dm_random.h" +#include "hichain_connector_callback.h" #include "nlohmann/json.hpp" - #include "parameter.h" -#include "anonymous_string.h" -#include "device_manager_log.h" -#include "encrypt_utils.h" -#include "softbus_adapter.h" -#include "constants.h" -#include "ipc_server_listener_adapter.h" -#include "ipc_check_authenticate_req.h" -#include "softbus_session.h" -#include "auth_manager.h" -#include "ipc_server_stub.h" -#include "dm_ability_manager.h" - namespace OHOS { namespace DistributedHardware { -namespace { -const std::string DEVICE_ID = "DEVICE_ID"; -const std::string WIFI_IP = "WIFI_IP"; -const std::string WIFI_PORT = "WIFI_PORT"; -const std::string BR_MAC = "BR_MAC"; -const std::string BLE_MAC = "BLE_MAC"; -const std::string ETH_IP = "ETH_IP"; -const std::string ETH_PORT = "ETH_PORT"; -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 FIELD_EXPIRE_TIME_VALUE = 7; -} - -IMPLEMENT_SINGLE_INSTANCE(HichainConnector); - -void from_json(const nlohmann::json& jsonObject, GroupInfo& groupInfo) +void from_json(const nlohmann::json &jsonObject, GroupInfo &groupInfo) { if (jsonObject.find(FIELD_GROUP_NAME) != jsonObject.end()) { groupInfo.groupName = jsonObject.at(FIELD_GROUP_NAME).get(); @@ -79,49 +54,57 @@ void from_json(const nlohmann::json& jsonObject, GroupInfo& groupInfo) } } -int HichainConnector::Init() +std::map> HiChainConnector::hiChainConnectorCallbackMap_ = {}; + +HiChainConnector::HiChainConnector() { - DMLOG(DM_LOG_INFO, "HichainConnector::init, init device auth service."); + LOGI("HiChainConnector::constructor"); + deviceAuthCallback_ = {.onTransmit = nullptr, + .onFinish = HiChainConnector::onFinish, + .onError = HiChainConnector::onError, + .onRequest = HiChainConnector::onRequest}; InitDeviceAuthService(); - deviceGroupManager_ = GetGmInstance(); if (deviceGroupManager_ == nullptr) { - DMLOG(DM_LOG_INFO, "HichainConnector::init, failed to init group manager!"); - return -1; + LOGI("HiChainConnector::constructor, failed to init group manager!"); + return; } + deviceGroupManager_->regCallback(DM_PKG_NAME.c_str(), &deviceAuthCallback_); + LOGI("HiChainConnector::constructor success."); +} - deviceAuthCallback_.onTransmit = nullptr; - deviceAuthCallback_.onFinish = HichainAuthenCallBack::onFinish; - deviceAuthCallback_.onError = HichainAuthenCallBack::onError; - deviceAuthCallback_.onRequest = HichainAuthenCallBack::onRequest; +HiChainConnector::~HiChainConnector() +{ + LOGI("HiChainConnector::destructor."); +} - deviceGroupManager_->regCallback(DEVICE_MANAGER_APP.c_str(), &deviceAuthCallback_); - DMLOG(DM_LOG_INFO, "HichainConnector::init, init hichain adapter success."); - return 0; +int32_t HiChainConnector::RegisterHiChainCallback(const std::string &pkgName, + std::shared_ptr callback) +{ + hiChainConnectorCallbackMap_.emplace(pkgName, callback); + return DM_OK; } -int64_t HichainConnector::GenRequestId() +int32_t HiChainConnector::UnRegisterHiChainCallback(const std::string &pkgName) { - return EncryptUtils::GenRandLongLong(MIN_REQUEST_ID, MAX_REQUEST_ID); + hiChainConnectorCallbackMap_.erase(pkgName); + return DM_OK; } -int32_t HichainConnector::CreateGroup(int64_t requestId, const std::string &groupName) +int32_t HiChainConnector::CreateGroup(int64_t requestId, const std::string &groupName) { if (deviceGroupManager_ == nullptr) { - DMLOG(DM_LOG_ERROR, "HichainConnector::CreateGroup group manager is null, requestId %lld.", requestId); - return FAIL; + LOGE("HiChainConnector::CreateGroup group manager is null, requestId %lld.", requestId); + return DM_INVALID_VALUE; } - GroupInfo groupInfo; if (IsGroupCreated(groupName, groupInfo)) { DeleteGroup(groupInfo.groupId); } - - DMLOG(DM_LOG_INFO, "HichainConnector::CreateGroup requestId %lld", requestId); + LOGI("HiChainConnector::CreateGroup requestId %lld", requestId); char localDeviceId[DEVICE_UUID_LENGTH] = {0}; GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); std::string sLocalDeviceID = localDeviceId; - nlohmann::json jsonObj; jsonObj[FIELD_GROUP_TYPE] = GROUP_TYPE_PEER_TO_PEER_GROUP; jsonObj[FIELD_DEVICE_ID] = sLocalDeviceID; @@ -129,240 +112,271 @@ int32_t HichainConnector::CreateGroup(int64_t requestId, const std::string &grou jsonObj[FIELD_USER_TYPE] = 0; jsonObj[FIELD_GROUP_VISIBILITY] = GROUP_VISIBILITY_PUBLIC; jsonObj[FIELD_EXPIRE_TIME] = FIELD_EXPIRE_TIME_VALUE; - int32_t ret = deviceGroupManager_->createGroup(requestId, DEVICE_MANAGER_APP.c_str(), jsonObj.dump().c_str()); + int32_t ret = deviceGroupManager_->createGroup(requestId, DM_PKG_NAME.c_str(), jsonObj.dump().c_str()); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "Faild to start CreateGroup task, ret: %d, requestId %lld.", ret, requestId); - return ret; + LOGE("Failed to start CreateGroup task, ret: %d, requestId %lld.", ret, requestId); + return DM_HICHAIN_GROUP_CREATE_FAILED; } - - return SUCCESS; + return DM_OK; } -int32_t HichainConnector::IsGroupCreated(std::string groupName, GroupInfo &groupInfo) +bool HiChainConnector::IsGroupCreated(std::string groupName, GroupInfo &groupInfo) { nlohmann::json jsonObj; jsonObj[FIELD_GROUP_NAME] = groupName.c_str(); std::string queryParams = jsonObj.dump(); - std::vector groupList; if (GetGroupInfo(queryParams, groupList)) { groupInfo = groupList[0]; return true; } - return false; } -int32_t HichainConnector::GetGroupInfo(std::string queryParams, std::vector &groupList) +int32_t HiChainConnector::GetGroupInfo(std::string queryParams, std::vector &groupList) { char *groupVec = nullptr; uint32_t num = 0; - int32_t ret = deviceGroupManager_->getGroupInfo(DEVICE_MANAGER_APP.c_str(), queryParams.c_str(), &groupVec, &num); + int32_t ret = deviceGroupManager_->getGroupInfo(DM_PKG_NAME.c_str(), queryParams.c_str(), &groupVec, &num); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetGroupInfo faild , ret: %d.", ret); + LOGE("HiChainConnector::GetGroupInfo failed , ret: %d.", ret); return false; } - if (groupVec == nullptr) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetGroupInfo faild , returnGroups is nullptr"); + LOGE("HiChainConnector::GetGroupInfo failed , returnGroups is nullptr"); return false; } - if (num == 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetGroupInfo group failed, groupNum is 0."); + LOGE("HiChainConnector::GetGroupInfo group failed, groupNum is 0."); return false; } - - DMLOG(DM_LOG_INFO, "HichainConnector::GetGroupInfo group(%s), groupNum(%d)", groupVec, num); + LOGI("HiChainConnector::GetGroupInfo group(%s), groupNum(%d)", groupVec, num); std::string relatedGroups = std::string(groupVec); deviceGroupManager_->destroyInfo(&groupVec); nlohmann::json jsonObject = nlohmann::json::parse(relatedGroups); if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "returnGroups parse error"); + LOGE("returnGroups parse error"); return false; } - std::vector groupInfos = jsonObject.get>(); if (groupInfos.size() == 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetGroupInfo group failed, groupInfos is empty."); + LOGE("HiChainConnector::GetGroupInfo group failed, groupInfos is empty."); return false; } - groupList = groupInfos; return true; } -void HichainConnector::RegisterConnectorCallback(std::shared_ptr callback) +int32_t HiChainConnector::AddMember(std::string deviceId, std::string &connectInfo) { - hichainConnectorCallback_ = callback; + LOGI("HiChainConnector::AddMember"); + if (deviceGroupManager_ == nullptr) { + LOGI("HiChainConnector::AddMember group manager is null."); + return -1; + } + nlohmann::json jsonObject = nlohmann::json::parse(connectInfo, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("DecodeRequestAuth jsonStr error"); + return DM_FAILED; + } + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + std::string connectInfomation = GetConnectPara(deviceId, jsonObject[TAG_DEVICE_ID]); + + int32_t pinCode = jsonObject[PIN_CODE_KEY]; + std::string groupId = jsonObject[TAG_GROUP_ID]; + nlohmann::json jsonObj; + jsonObj[FIELD_GROUP_ID] = groupId; + jsonObj[FIELD_GROUP_TYPE] = GROUP_TYPE_PEER_TO_PEER_GROUP; + jsonObj[FIELD_PIN_CODE] = std::to_string(pinCode).c_str(); + jsonObj[FIELD_IS_ADMIN] = false; + jsonObj[FIELD_DEVICE_ID] = localDeviceId; + jsonObj[FIELD_GROUP_NAME] = jsonObject[TAG_GROUP_NAME]; + jsonObj[FIELD_CONNECT_PARAMS] = connectInfomation.c_str(); + std::string tmpStr = jsonObj.dump(); + int64_t requestId = jsonObject[TAG_REQUEST_ID]; + int32_t ret = deviceGroupManager_->addMemberToGroup(requestId, DM_PKG_NAME.c_str(), tmpStr.c_str()); + LOGI("HiChainConnector::AddMember completed"); + return ret; } -void HichainConnector::OnGroupCreated(int64_t requestId, const std::string &returnData) +void HiChainConnector::onFinish(int64_t requestId, int32_t operationCode, const char *returnData) { - if (hichainConnectorCallback_ == nullptr) { - DMLOG(DM_LOG_ERROR, "HichainConnector::OnGroupCreated hichainConnectorCallback_ not registe."); - return; + std::string data = ""; + if (returnData != nullptr) { + data = std::string(returnData); } - - nlohmann::json jsonObject = nlohmann::json::parse(returnData); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "HichainConnector::OnGroupCreated returnData not json."); - hichainConnectorCallback_->OnGroupCreated(requestId, ""); - return; + LOGI("HiChainConnector::onFinish reqId:%lld, operation:%d", requestId, operationCode); + if (operationCode == GroupOperationCode::MEMBER_JOIN) { + LOGI("Add Member To Group success"); + for (auto &iter : hiChainConnectorCallbackMap_) { + iter.second->OnMemberJoin(requestId, DM_OK); + } } - - if (jsonObject.find(FIELD_GROUP_ID) == jsonObject.end()) { - DMLOG(DM_LOG_ERROR, "HichainConnector::OnGroupCreated failed to get groupId."); - hichainConnectorCallback_->OnGroupCreated(requestId, ""); - return; + if (operationCode == GroupOperationCode::GROUP_CREATE) { + LOGI("Create group success"); + for (auto &iter : hiChainConnectorCallbackMap_) { + iter.second->OnGroupCreated(requestId, data); + } + } + if (operationCode == GroupOperationCode::MEMBER_DELETE) { + LOGI("Delete Member from group success"); + } + if (operationCode == GroupOperationCode::GROUP_DISBAND) { + LOGI("Disband group success"); } - - std::string groupId = jsonObject.at(FIELD_GROUP_ID).get(); - DMLOG(DM_LOG_INFO, "group create success, groupId:%s.", GetAnonyString(groupId).c_str()); - hichainConnectorCallback_->OnGroupCreated(requestId, groupId); } -void HichainConnector::OnMemberJoin(int64_t requestId, int32_t status) +void HiChainConnector::onError(int64_t requestId, int32_t operationCode, int32_t errorCode, const char *errorReturn) { - AbilityRole role = DmAbilityManager::GetInstance().GetAbilityRole(); - DMLOG(DM_LOG_INFO, "HichainConnector::OnMemberJoin:: role = %d", (int32_t)role); - - if (role == AbilityRole::ABILITY_ROLE_INITIATIVE) { - AuthManager::GetInstance().NotifyHostOnCheckAuthResult(requestId, status); - return; + (void)errorReturn; + LOGI("HichainAuthenCallBack::onError reqId:%lld, operation:%d, errorCode:%d.", requestId, operationCode, errorCode); + if (operationCode == GroupOperationCode::MEMBER_JOIN) { + LOGE("Add Member To Group failed"); + for (auto &iter : hiChainConnectorCallbackMap_) { + iter.second->OnMemberJoin(requestId, DM_FAILED); + } } - - if (hichainConnectorCallback_ == nullptr) { - DMLOG(DM_LOG_ERROR, "HichainConnector::OnMemberJoin hichainConnectorCallback_ not registe."); - return; + if (operationCode == GroupOperationCode::GROUP_CREATE) { + LOGE("Create group failed"); + for (auto &iter : hiChainConnectorCallbackMap_) { + iter.second->OnGroupCreated(requestId, "{}"); + } + } + if (operationCode == GroupOperationCode::MEMBER_DELETE) { + LOGE("Delete Member from group failed"); + } + if (operationCode == GroupOperationCode::GROUP_DISBAND) { + LOGE("Disband group failed"); } - hichainConnectorCallback_->OnMemberJoin(requestId, status); } -int32_t HichainConnector::AddMemeber(std::string deviceId, std::shared_ptr msgResponseAuth) +char *HiChainConnector::onRequest(int64_t requestId, int32_t operationCode, const char *reqParams) { - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber"); - if (deviceGroupManager_ == nullptr) { - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber group manager is null."); - return -1; + if (operationCode != GroupOperationCode::MEMBER_JOIN) { + LOGE("HiChainAuthCallBack::onRequest operationCode %d", operationCode); + return nullptr; } - + int32_t pinCode = 0; + for (auto &iter : hiChainConnectorCallbackMap_) { + pinCode = iter.second->GetPinCode(); + } + nlohmann::json jsonObj; + if (pinCode == DM_FAILED) { + jsonObj[FIELD_CONFIRMATION] = REQUEST_REJECTED; + } else { + jsonObj[FIELD_CONFIRMATION] = REQUEST_ACCEPTED; + } + jsonObj[FIELD_PIN_CODE] = std::to_string(pinCode).c_str(); char localDeviceId[DEVICE_UUID_LENGTH] = {0}; GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - std::string connectInfo = GetConnectPara(deviceId, msgResponseAuth); - - nlohmann::json jsonObj; - jsonObj[FIELD_GROUP_ID] = msgResponseAuth->GetGroupId(); - jsonObj[FIELD_GROUP_TYPE] = GROUP_TYPE_PEER_TO_PEER_GROUP; - jsonObj[FIELD_PIN_CODE] = std::to_string(msgResponseAuth->GetPinCode()).c_str(); - jsonObj[FIELD_IS_ADMIN] = false; jsonObj[FIELD_DEVICE_ID] = localDeviceId; - jsonObj[FIELD_GROUP_NAME] = msgResponseAuth->GetGroupName(); - jsonObj[FIELD_CONNECT_PARAMS] = connectInfo.c_str(); - std::string tmpStr = jsonObj.dump(); - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber completed"); - return deviceGroupManager_->addMemberToGroup(msgResponseAuth->GetRequestId(), DEVICE_MANAGER_APP.c_str(), - tmpStr.c_str()); + std::string jsonStr = jsonObj.dump(); + char *buffer = strdup(jsonStr.c_str()); + return buffer; } -std::string HichainConnector::GetConnectPara(std::string deviceId, std::shared_ptr msgResponseAuth) +int64_t HiChainConnector::GenRequestId() { - ConnectionAddr *addrInfo = SoftbusAdapter::GetConnectAddr(deviceId); - if (addrInfo == nullptr) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetConnectPara addrInfo error"); - return ""; - } - - DMLOG(DM_LOG_ERROR, "HichainConnector::GetConnectPara get addrInfo"); - nlohmann::json jsonPara; - jsonPara[DEVICE_ID] = msgResponseAuth->GetDeviceId(); - if (addrInfo->type == ConnectionAddrType::CONNECTION_ADDR_ETH) { - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber addr type is ETH"); - jsonPara[ETH_IP] = addrInfo->info.ip.ip; - jsonPara[ETH_PORT] = addrInfo->info.ip.port; - } else if (addrInfo->type == ConnectionAddrType::CONNECTION_ADDR_WLAN) { - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber addr type is WIFI"); - jsonPara[WIFI_IP] = addrInfo->info.ip.ip; - jsonPara[WIFI_PORT] = addrInfo->info.ip.port; - } else if (addrInfo->type == ConnectionAddrType::CONNECTION_ADDR_BR) { - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber addr type is br"); - jsonPara[BR_MAC] = addrInfo->info.br.brMac; - } else if (addrInfo->type == ConnectionAddrType::CONNECTION_ADDR_BLE) { - DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber addr type is ble"); - jsonPara[BLE_MAC] = addrInfo->info.ble.bleMac; - } else { - DMLOG(DM_LOG_ERROR, "HichainConnector::AddMemeber addrInfo not right"); - return ""; + return GenRandLongLong(MIN_REQUEST_ID, MAX_REQUEST_ID); +} + +std::string HiChainConnector::GetConnectPara(std::string deviceId, std::string reqDeviceId) +{ + std::string connectAddr = ""; + for (auto &iter : hiChainConnectorCallbackMap_) { + connectAddr = iter.second->GetConnectAddr(deviceId); + } + LOGE("HiChainConnector::GetConnectPara get addrInfo"); + nlohmann::json jsonObject = nlohmann::json::parse(connectAddr, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("DecodeRequestAuth jsonStr error"); + return connectAddr; } - return jsonPara.dump(); + jsonObject[DEVICE_ID] = reqDeviceId; + + return jsonObject.dump(); } -void HichainConnector::GetRelatedGroups(std::string deviceId, std::vector &groupList) +int32_t HiChainConnector::GetRelatedGroups(std::string deviceId, std::vector &groupList) { - DMLOG(DM_LOG_INFO, "HichainConnector::GetRelatedGroups Start to get local related groups."); + LOGI("HiChainConnector::GetRelatedGroups Start to get local related groups."); uint32_t groupNum = 0; char *returnGroups = nullptr; - int32_t ret = deviceGroupManager_->getRelatedGroups(DEVICE_MANAGER_APP.c_str(), deviceId.c_str(), - &returnGroups, &groupNum); + int32_t ret = + deviceGroupManager_->getRelatedGroups(DM_PKG_NAME.c_str(), deviceId.c_str(), &returnGroups, &groupNum); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups faild , ret: %d.", ret); - return; + LOGE("HiChainConnector::GetRelatedGroups faild , ret: %d.", ret); + return DM_FAILED; } - if (returnGroups == nullptr) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups faild , returnGroups is nullptr"); - return; + LOGE("HiChainConnector::GetRelatedGroups failed , returnGroups is nullptr"); + return DM_FAILED; } - if (groupNum == 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups group failed, groupNum is 0."); - return; + LOGE("HiChainConnector::GetRelatedGroups group failed, groupNum is 0."); + return DM_FAILED; } - std::string relatedGroups = std::string(returnGroups); nlohmann::json jsonObject = nlohmann::json::parse(relatedGroups); if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "returnGroups parse error"); - return; + LOGE("returnGroups parse error"); + return DM_FAILED; } - std::vector groupInfos = jsonObject.get>(); if (groupInfos.size() == 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups group failed, groupInfos is empty."); - return; + LOGE("HiChainConnector::GetRelatedGroups group failed, groupInfos is empty."); + return DM_FAILED; } - groupList = groupInfos; - return; + return DM_OK; } -void HichainConnector::GetSyncGroupList(std::vector &groupList, std::vector &syncGroupList) +int32_t HiChainConnector::GetSyncGroupList(std::vector &groupList, std::vector &syncGroupList) { if (groupList.empty()) { - DMLOG(DM_LOG_ERROR, "groupList is empty."); - return; + LOGE("groupList is empty."); + return DM_FAILED; } - for (auto group : groupList) { if (IsGroupInfoInvalid(group)) { continue; } syncGroupList.push_back(group.groupId); } + return DM_OK; } -bool HichainConnector::IsGroupInfoInvalid(GroupInfo &group) +bool HiChainConnector::IsDevicesInGroup(std::string hostDevice, std::string peerDevice) +{ + LOGE("HiChainConnector::IsDevicesInGroup"); + std::vector hostGroupInfoList; + GetRelatedGroups(hostDevice, hostGroupInfoList); + std::vector peerGroupInfoList; + GetRelatedGroups(peerDevice, peerGroupInfoList); + for (auto &hostGroupInfo : hostGroupInfoList) { + for (auto &peerGroupInfo : peerGroupInfoList) { + if (hostGroupInfo.groupId == peerGroupInfo.groupId && hostGroupInfo.groupName == peerGroupInfo.groupName) { + LOGE("these are authenticated"); + return false; + } + } + } + return true; +} + +bool HiChainConnector::IsGroupInfoInvalid(GroupInfo &group) { if (group.groupType == GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP || group.groupVisibility == GROUP_VISIBILITY_PUBLIC || - group.groupOwner != DEVICE_MANAGER_APP) { + group.groupOwner != DM_PKG_NAME) { return true; } return false; } -void HichainConnector::SyncGroups(std::string deviceId, std::vector &remoteGroupIdList) +int32_t HiChainConnector::SyncGroups(std::string deviceId, std::vector &remoteGroupIdList) { std::vector groupInfoList; GetRelatedGroups(deviceId, groupInfoList); @@ -370,121 +384,43 @@ void HichainConnector::SyncGroups(std::string deviceId, std::vector if (IsGroupInfoInvalid(groupInfo)) { continue; } - auto iter = std::find(remoteGroupIdList.begin(), remoteGroupIdList.end(), groupInfo.groupId); if (iter == remoteGroupIdList.end()) { (void)DelMemberFromGroup(groupInfo.groupId, deviceId); } } + return DM_OK; } -int32_t HichainConnector::DelMemberFromGroup(std::string groupId, std::string deviceId) +int32_t HiChainConnector::DelMemberFromGroup(std::string groupId, std::string deviceId) { int64_t requestId = GenRequestId(); - DMLOG(DM_LOG_INFO, "Start to delete memeber from group, requestId %lld, deviceId %s, groupId %s", - requestId, GetAnonyString(deviceId).c_str(), GetAnonyString(groupId).c_str()); + LOGI("Start to delete memeber from group, requestId %lld, deviceId %s, groupId %s", requestId, + GetAnonyString(deviceId).c_str(), GetAnonyString(groupId).c_str()); nlohmann::json jsonObj; jsonObj[FIELD_GROUP_ID] = groupId; jsonObj[FIELD_DELETE_ID] = deviceId; std::string deleteParams = jsonObj.dump(); - - int32_t ret = deviceGroupManager_->deleteMemberFromGroup(requestId, DEVICE_MANAGER_APP.c_str(), - deleteParams.c_str()); + int32_t ret = deviceGroupManager_->deleteMemberFromGroup(requestId, DM_PKG_NAME.c_str(), deleteParams.c_str()); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::DelMemberFromGroup faild , ret: %d.", ret); + LOGE("HiChainConnector::DelMemberFromGroup failed , ret: %d.", ret); return ret; } - return 0; + return DM_OK; } -void HichainConnector::DeleteGroup(std::string &groupId) +int32_t HiChainConnector::DeleteGroup(std::string &groupId) { int64_t requestId = GenRequestId(); nlohmann::json jsonObj; jsonObj[FIELD_GROUP_ID] = groupId; std::string disbandParams = jsonObj.dump(); - - int32_t ret = deviceGroupManager_->deleteGroup(requestId, DEVICE_MANAGER_APP.c_str(), disbandParams.c_str()); + int32_t ret = deviceGroupManager_->deleteGroup(requestId, DM_PKG_NAME.c_str(), disbandParams.c_str()); if (ret != 0) { - DMLOG(DM_LOG_ERROR, "HichainConnector::DeleteGroup faild , ret: %d.", ret); - } -} - -void HichainAuthenCallBack::onFinish(int64_t requestId, int32_t operationCode, const char *returnData) -{ - std::string data = ""; - if (returnData != nullptr) { - data = std::string(returnData); - } - - DMLOG(DM_LOG_INFO, "HichainAuthenCallBack::onFinish reqId:%lld, operation:%d", requestId, operationCode); - if (operationCode == GroupOperationCode::MEMBER_JOIN) { - DMLOG(DM_LOG_INFO, "Add Member To Group success"); - HichainConnector::GetInstance().OnMemberJoin(requestId, SUCCESS); - } - - if (operationCode == GroupOperationCode::GROUP_CREATE) { - DMLOG(DM_LOG_INFO, "Create group success"); - HichainConnector::GetInstance().OnGroupCreated(requestId, data); + LOGE("HiChainConnector::DeleteGroup failed , ret: %d.", ret); + return DM_FAILED; } - - if (operationCode == GroupOperationCode::MEMBER_DELETE) { - DMLOG(DM_LOG_INFO, "Delete Member from group success"); - } - - if (operationCode == GroupOperationCode::GROUP_DISBAND) { - DMLOG(DM_LOG_INFO, "Disband group success"); - } -} - -void HichainAuthenCallBack::onError(int64_t requestId, int32_t operationCode, int32_t errorCode, - const char *errorReturn) -{ - (void)errorReturn; - DMLOG(DM_LOG_INFO, "HichainAuthenCallBack::onError reqId:%lld, operation:%d, errorCode:%d.", - requestId, operationCode, errorCode); - - if (operationCode == GroupOperationCode::MEMBER_JOIN) { - DMLOG(DM_LOG_ERROR, "Add Member To Group failed"); - HichainConnector::GetInstance().OnMemberJoin(requestId, FAIL); - } - - if (operationCode == GroupOperationCode::GROUP_CREATE) { - DMLOG(DM_LOG_ERROR, "Create group failed"); - HichainConnector::GetInstance().OnGroupCreated(requestId, "{}"); - } - - if (operationCode == GroupOperationCode::MEMBER_DELETE) { - DMLOG(DM_LOG_ERROR, "Delete Member from group failed"); - } - - if (operationCode == GroupOperationCode::GROUP_DISBAND) { - DMLOG(DM_LOG_ERROR, "Disband group failed"); - } -} - -char *HichainAuthenCallBack::onRequest(int64_t requestId, int32_t operationCode, const char *reqParams) -{ - if (operationCode != GroupOperationCode::MEMBER_JOIN) { - DMLOG(DM_LOG_ERROR, "HichainAuthenCallBack::onRequest operationCode %d", operationCode); - return nullptr; - } - - int32_t pinCode = AuthManager::GetInstance().GetPincode(requestId); - nlohmann::json jsonObj; - if (pinCode == FAIL) { - jsonObj[FIELD_CONFIRMATION] = REQUEST_REJECTED; - } else { - jsonObj[FIELD_CONFIRMATION] = REQUEST_ACCEPTED; - } - jsonObj[FIELD_PIN_CODE] = std::to_string(pinCode).c_str(); - 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; -} -} + return DM_OK; } +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/dependency/softbus/softbus_connector.cpp b/services/devicemanagerservice/src/dependency/softbus/softbus_connector.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c5b376176a723d08bc25daccf46ab592154e9afc --- /dev/null +++ b/services/devicemanagerservice/src/dependency/softbus/softbus_connector.cpp @@ -0,0 +1,559 @@ +/* + * 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_connector.h" + +#include +#include + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" +#include "nlohmann/json.hpp" +#include "parameter.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace DistributedHardware { + +SoftbusConnector::PulishStatus SoftbusConnector::publishStatus = SoftbusConnector::STATUS_UNKNOWN; +std::map> SoftbusConnector::discoveryDeviceInfoMap_ = {}; +std::map> SoftbusConnector::stateCallbackMap_ = {}; +std::map> SoftbusConnector::discoveryCallbackMap_ = {}; + +IPublishCallback SoftbusConnector::softbusPublishCallback_ = {.OnPublishSuccess = SoftbusConnector::OnPublishSuccess, + .OnPublishFail = SoftbusConnector::OnPublishFail}; + +IDiscoveryCallback SoftbusConnector::softbusDiscoveryCallback_ = { + .OnDeviceFound = SoftbusConnector::OnSoftbusDeviceFound, + .OnDiscoverFailed = SoftbusConnector::OnSoftbusDiscoveryFailed, + .OnDiscoverySuccess = SoftbusConnector::OnSoftbusDiscoverySuccess}; + +INodeStateCb SoftbusConnector::softbusNodeStateCb_ = { + .events = EVENT_NODE_STATE_ONLINE | EVENT_NODE_STATE_OFFLINE | EVENT_NODE_STATE_INFO_CHANGED, + .onNodeOnline = SoftbusConnector::OnSoftBusDeviceOnline, + .onNodeOffline = SoftbusConnector::OnSoftbusDeviceOffline, + .onNodeBasicInfoChanged = SoftbusConnector::OnSoftbusDeviceInfoChanged}; + +SoftbusConnector::SoftbusConnector() +{ + softbusSession_ = std::make_shared(); + Init(); +} + +SoftbusConnector::~SoftbusConnector() +{ + LOGI("SoftbusConnector destructor"); +} + +int32_t SoftbusConnector::Init() +{ + int32_t ret; + int32_t retryTimes = 0; + do { + ret = RegNodeDeviceStateCb(DM_PKG_NAME.c_str(), &softbusNodeStateCb_); + if (ret != DM_OK) { + ++retryTimes; + LOGE("RegNodeDeviceStateCb failed with ret %d, retryTimes %d", ret, retryTimes); + usleep(SOFTBUS_CHECK_INTERVAL); + } + } while (ret != DM_OK); + LOGI("RegNodeDeviceStateCb success."); + + PublishInfo dmPublishInfo; + dmPublishInfo.publishId = DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID; + dmPublishInfo.mode = DiscoverMode::DISCOVER_MODE_ACTIVE; + dmPublishInfo.medium = ExchanageMedium::AUTO; + dmPublishInfo.freq = ExchangeFreq::HIGH; + dmPublishInfo.capability = DM_CAPABILITY_OSD; + dmPublishInfo.capabilityData = nullptr; + dmPublishInfo.dataLen = 0; + + char discoverStatus[DISCOVER_STATUS_LEN + 1] = {0}; + ret = GetParameter(DISCOVER_STATUS_KEY.c_str(), "not exist", discoverStatus, DISCOVER_STATUS_LEN); + if (strcmp(discoverStatus, "not exist") == 0) { + ret = SetParameter(DISCOVER_STATUS_KEY.c_str(), DISCOVER_STATUS_ON.c_str()); + LOGI("service set poatrameter result is : %d", ret); + + ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_); + if (ret == DM_OK) { + publishStatus = ALLOW_BE_DISCOVERY; + } + LOGI("service publish result is : %d", ret); + } else if (ret >= 0 && strcmp(discoverStatus, DISCOVER_STATUS_ON.c_str()) == 0) { + ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_); + if (ret == DM_OK) { + publishStatus = ALLOW_BE_DISCOVERY; + } + LOGI("service publish result is : %d", ret); + } else if (ret >= 0 && strcmp(discoverStatus, DISCOVER_STATUS_OFF.c_str()) == 0) { + ret = UnPublishService(DM_PKG_NAME.c_str(), DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID); + if (ret == DM_OK) { + publishStatus = NOT_ALLOW_BE_DISCOVERY; + } + LOGI("service unpublish result is : %d", ret); + } + + ret = WatchParameter(DISCOVER_STATUS_KEY.c_str(), &SoftbusConnector::OnParameterChgCallback, nullptr); + LOGI("register Watch Parameter result is : %d"); + return ret; +} + +int32_t SoftbusConnector::RegisterSoftbusDiscoveryCallback(const std::string &pkgName, + const std::shared_ptr callback) +{ + discoveryCallbackMap_.emplace(pkgName, callback); + return DM_OK; +} + +int32_t SoftbusConnector::UnRegisterSoftbusDiscoveryCallback(const std::string &pkgName) +{ + discoveryCallbackMap_.erase(pkgName); + return DM_OK; +} + +int32_t SoftbusConnector::RegisterSoftbusStateCallback(const std::string &pkgName, + const std::shared_ptr callback) +{ + stateCallbackMap_.emplace(pkgName, callback); + return DM_OK; +} + +int32_t SoftbusConnector::UnRegisterSoftbusStateCallback(const std::string &pkgName) +{ + stateCallbackMap_.erase(pkgName); + return DM_OK; +} + +int32_t SoftbusConnector::GetTrustedDeviceList(std::vector &deviceInfoList) +{ + LOGD("SoftbusConnector::GetTrustDevices start"); + int32_t infoNum = 0; + NodeBasicInfo *nodeInfo = nullptr; + int32_t ret = GetAllNodeDeviceInfo(DM_PKG_NAME.c_str(), &nodeInfo, &infoNum); + if (ret != 0) { + LOGE("GetAllNodeDeviceInfo failed with ret %d", ret); + return DM_FAILED; + } + DmDeviceInfo *info = (DmDeviceInfo *)malloc(sizeof(DmDeviceInfo) * (infoNum)); + if (info == nullptr) { + FreeNodeInfo(nodeInfo); + return DM_MALLOC_ERROR; + } + DmDeviceInfo **pInfoList = &info; + for (int32_t i = 0; i < infoNum; ++i) { + NodeBasicInfo *nodeBasicInfo = nodeInfo + i; + DmDeviceInfo *deviceInfo = *pInfoList + i; + CovertNodeBasicInfoToDmDevice(*nodeBasicInfo, *deviceInfo); + deviceInfoList.push_back(*deviceInfo); + } + FreeNodeInfo(nodeInfo); + free(info); + LOGD("SoftbusConnector::GetTrustDevices success, deviceCount %d", infoNum); + return DM_OK; +} + +int32_t SoftbusConnector::GetLocalDeviceInfo(DmDeviceInfo &deviceInfo) +{ + LOGD("SoftbusConnector::GetLocalDeviceInfo start"); + NodeBasicInfo nodeBasicInfo; + int32_t ret = GetLocalNodeDeviceInfo(DM_PKG_NAME.c_str(), &nodeBasicInfo); + if (ret != 0) { + LOGE("GetLocalNodeDeviceInfo failed with ret %d", ret); + return DM_FAILED; + } + CovertNodeBasicInfoToDmDevice(nodeBasicInfo, deviceInfo); + LOGD("SoftbusConnector::GetLocalDeviceInfo success"); + return DM_OK; +} + +int32_t SoftbusConnector::StartDiscovery(const DmSubscribeInfo &dmSubscribeInfo) +{ + 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; + int32_t ret = ::StartDiscovery(DM_PKG_NAME.c_str(), &subscribeInfo, &softbusDiscoveryCallback_); + if (ret != 0) { + LOGE("StartDiscovery failed with ret %d.", ret); + return DM_DISCOVERY_FAILED; + } + return DM_OK; +} + +int32_t SoftbusConnector::StopDiscovery(uint16_t subscribeId) +{ + LOGI("StopDiscovery begin, subscribeId:%d", (int32_t)subscribeId); + int32_t ret = ::StopDiscovery(DM_PKG_NAME.c_str(), subscribeId); + if (ret != 0) { + LOGE("StopDiscovery failed with ret %d", ret); + return ret; + } + LOGI("SoftbusConnector::StopDiscovery completed"); + return DM_OK; +} + +int32_t SoftbusConnector::GetNodeKeyInfoByNetworkId(const char *networkId, NodeDeivceInfoKey key, uint8_t *info, + int32_t infoLen) +{ + LOGI("GetNodeKeyInfoByNetworkId begin"); + + int32_t ret = GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId, key, info, infoLen); + if (ret != DM_OK) { + LOGE("GetNodeKeyInfoByNetworkId GetNodeKeyInfo failed"); + return DM_FAILED; + } + + LOGI("SoftbusConnector::GetNodeKeyInfoByNetworkId completed"); + return DM_OK; +} + +int32_t SoftbusConnector::GetUdidByNetworkId(const char *networkId, std::string &udid) +{ + LOGI("GetUdidByNetworkId begin"); + uint8_t mUdid[UDID_BUF_LEN] = {0}; + int32_t ret = + GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId, NodeDeivceInfoKey::NODE_KEY_UDID, mUdid, sizeof(mUdid)); + if (ret != DM_OK) { + LOGE("GetUdidByNetworkId GetNodeKeyInfo failed"); + return DM_FAILED; + } + udid = (char *)mUdid; + LOGI("SoftbusConnector::GetUdidByNetworkId completed"); + return DM_OK; +} + +int32_t SoftbusConnector::GetUuidByNetworkId(const char *networkId, std::string &uuid) +{ + LOGI("GetUuidByNetworkId begin"); + uint8_t mUuid[UUID_BUF_LEN] = {0}; + int32_t ret = + GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId, NodeDeivceInfoKey::NODE_KEY_UUID, mUuid, sizeof(mUuid)); + if (ret != DM_OK) { + LOGE("GetUuidByNetworkId GetNodeKeyInfo failed"); + return DM_FAILED; + } + uuid = (char *)mUuid; + LOGI("SoftbusConnector::GetUuidByNetworkId completed"); + return DM_OK; +} + +bool SoftbusConnector::IsDeviceOnLine(const std::string &deviceId) +{ + NodeBasicInfo *info = nullptr; + int32_t infoNum = 0; + if (GetAllNodeDeviceInfo(DM_PKG_NAME.c_str(), &info, &infoNum) != DM_OK) { + LOGE("GetAllNodeDeviceInfo failed"); + return false; + } + bool bDeviceOnline = false; + for (int32_t i = 0; i < infoNum; ++i) { + NodeBasicInfo *nodeBasicInfo = info + i; + if (nodeBasicInfo == nullptr) { + LOGE("nodeBasicInfo is empty for index %d, infoNum %d.", i, infoNum); + continue; + } + std::string networkId = nodeBasicInfo->networkId; + if (networkId == deviceId) { + LOGI("DM_IsDeviceOnLine device %s online", GetAnonyString(deviceId).c_str()); + bDeviceOnline = true; + break; + } + uint8_t udid[UDID_BUF_LEN] = {0}; + int32_t ret = GetNodeKeyInfo(DM_PKG_NAME.c_str(), networkId.c_str(), NodeDeivceInfoKey::NODE_KEY_UDID, udid, + sizeof(udid)); + if (ret != DM_OK) { + LOGE("DM_IsDeviceOnLine GetNodeKeyInfo failed"); + break; + } + if (strcmp((char *)udid, deviceId.c_str()) == 0) { + LOGI("DM_IsDeviceOnLine device %s online", GetAnonyString(deviceId).c_str()); + bDeviceOnline = true; + break; + } + } + FreeNodeInfo(info); + return bDeviceOnline; +} + +std::shared_ptr SoftbusConnector::GetSoftbusSession() +{ + return softbusSession_; +} + +bool SoftbusConnector::HaveDeviceInMap(std::string deviceId) +{ + auto iter = discoveryDeviceInfoMap_.find(deviceId); + if (iter == discoveryDeviceInfoMap_.end()) { + LOGE("deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str()); + return false; + } + return true; +} + +int32_t SoftbusConnector::GetConnectionIpAddress(const std::string &deviceId, std::string &ipAddress) +{ + auto iter = discoveryDeviceInfoMap_.find(deviceId); + if (iter == discoveryDeviceInfoMap_.end()) { + LOGE("deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str()); + return DM_FAILED; + } + DeviceInfo *deviceInfo = iter->second.get(); + if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { + LOGE("deviceInfo address num not valid, addrNum %d", deviceInfo->addrNum); + return DM_FAILED; + } + for (uint32_t 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; + } + ipAddress = deviceInfo->addr[i].info.ip.ip; + LOGI("DM_GetConnectionIpAddr get ip ok."); + return DM_OK; + } + LOGE("failed to get ipAddress for deviceId %s", GetAnonyString(deviceId).c_str()); + return DM_FAILED; +} + +ConnectionAddr *SoftbusConnector::GetConnectAddrByType(DeviceInfo *deviceInfo, ConnectionAddrType type) +{ + if (deviceInfo == nullptr) { + return nullptr; + } + for (uint32_t i = 0; i < deviceInfo->addrNum; ++i) { + if (deviceInfo->addr[i].type == type) { + return &deviceInfo->addr[i]; + } + } + return nullptr; +} + +ConnectionAddr *SoftbusConnector::GetConnectAddr(const std::string &deviceId, std::string &connectAddr) +{ + auto iter = discoveryDeviceInfoMap_.find(deviceId); + if (iter == discoveryDeviceInfoMap_.end()) { + LOGE("deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str()); + return nullptr; + } + DeviceInfo *deviceInfo = iter->second.get(); + if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { + LOGE("deviceInfo addrNum not valid, addrNum %d", deviceInfo->addrNum); + return nullptr; + } + nlohmann::json jsonPara; + ConnectionAddr *addr = nullptr; + addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_ETH); + if (addr != nullptr) { + LOGI("get ETH ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); + jsonPara[ETH_IP] = addr->info.ip.ip; + jsonPara[ETH_PORT] = addr->info.ip.port; + connectAddr = jsonPara.dump(); + return addr; + } + addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_WLAN); + if (addr != nullptr) { + jsonPara[WIFI_IP] = addr->info.ip.ip; + jsonPara[WIFI_PORT] = addr->info.ip.port; + LOGI("get WLAN ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); + connectAddr = jsonPara.dump(); + return addr; + } + addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_BLE); + if (addr != nullptr) { + jsonPara[BR_MAC] = addr->info.br.brMac; + LOGI("get BLE ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); + connectAddr = jsonPara.dump(); + return addr; + } + addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_BR); + if (addr != nullptr) { + jsonPara[BLE_MAC] = addr->info.ble.bleMac; + LOGI("get BR ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); + connectAddr = jsonPara.dump(); + return addr; + } + LOGE("failed to get ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); + return nullptr; +} + +int32_t SoftbusConnector::CovertNodeBasicInfoToDmDevice(const NodeBasicInfo &nodeBasicInfo, DmDeviceInfo &dmDeviceInfo) +{ + (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); + if (memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), nodeBasicInfo.networkId, + std::min(sizeof(dmDeviceInfo.deviceId), sizeof(nodeBasicInfo.networkId))) != DM_OK) { + LOGE("copy data failed"); + } + if (memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), nodeBasicInfo.deviceName, + std::min(sizeof(dmDeviceInfo.deviceName), sizeof(nodeBasicInfo.deviceName))) != DM_OK) { + LOGE("copy data failed"); + } + dmDeviceInfo.deviceTypeId = nodeBasicInfo.deviceTypeId; + return DM_OK; +} + +void SoftbusConnector::CovertDeviceInfoToDmDevice(const DeviceInfo &deviceInfo, DmDeviceInfo &dmDeviceInfo) +{ + (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); + if (memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), deviceInfo.devId, + std::min(sizeof(dmDeviceInfo.deviceId), sizeof(deviceInfo.devId))) != DM_OK) { + LOGE("copy data failed"); + } + if (memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), deviceInfo.devName, + std::min(sizeof(dmDeviceInfo.deviceName), sizeof(deviceInfo.devName))) != DM_OK) { + LOGE("copy data failed"); + } + dmDeviceInfo.deviceTypeId = deviceInfo.devType; +} + +void SoftbusConnector::OnPublishSuccess(int32_t publishId) +{ + LOGI("SoftbusConnector::OnPublishSuccess, publishId: %d", publishId); +} + +void SoftbusConnector::OnPublishFail(int32_t publishId, PublishFailReason reason) +{ + LOGI("SoftbusConnector::OnPublishFail failed, publishId: %d, reason: %d", publishId, reason); +} + +void SoftbusConnector::OnSoftBusDeviceOnline(NodeBasicInfo *info) +{ + LOGI("device online"); + if (info == nullptr) { + LOGE("SoftbusConnector::OnSoftbusDeviceOffline NodeBasicInfo is nullptr"); + return; + } + + if (discoveryDeviceInfoMap_.empty()) { + return; + } + DmDeviceInfo dmDeviceInfo; + CovertNodeBasicInfoToDmDevice(*info, dmDeviceInfo); + for (auto &iter : stateCallbackMap_) { + iter.second->OnDeviceOnline(iter.first, dmDeviceInfo); + } + // remove the discovery node map + uint8_t udid[UDID_BUF_LEN] = {0}; + int32_t ret = + GetNodeKeyInfo(DM_PKG_NAME.c_str(), info->networkId, NodeDeivceInfoKey::NODE_KEY_UDID, udid, sizeof(udid)); + if (ret != DM_OK) { + LOGE("GetNodeKeyInfo failed"); + return; + } + std::string deviceId = (char *)udid; + LOGI("device online, deviceId: %s", GetAnonyString(deviceId).c_str()); + discoveryDeviceInfoMap_.erase(deviceId); +} + +void SoftbusConnector::OnSoftbusDeviceOffline(NodeBasicInfo *info) +{ + if (info == nullptr) { + LOGE("OnSoftbusDeviceOffline NodeBasicInfo is nullptr"); + return; + } + DmDeviceInfo dmDeviceInfo; + CovertNodeBasicInfoToDmDevice(*info, dmDeviceInfo); + for (auto &iter : stateCallbackMap_) { + iter.second->OnDeviceOffline(iter.first, dmDeviceInfo); + } +} + +void SoftbusConnector::OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info) +{ + LOGI("SoftbusConnector::OnSoftbusDeviceInfoChanged."); +} + +void SoftbusConnector::OnSoftbusDeviceFound(const DeviceInfo *device) +{ + if (device == nullptr) { + LOGE("device is null"); + return; + } + std::string deviceId = device->devId; + LOGI("SoftbusConnector::OnSoftbusDeviceFound device %s found.", GetAnonyString(deviceId).c_str()); + if (IsDeviceOnLine(deviceId)) { + return; + } + std::shared_ptr infoPtr = std::make_shared(); + DeviceInfo *srcInfo = infoPtr.get(); + if (memcpy_s(srcInfo, sizeof(DeviceInfo), device, sizeof(DeviceInfo)) != 0) { + LOGE("save discovery device info failed"); + return; + } + discoveryDeviceInfoMap_[deviceId] = infoPtr; + // Remove the earliest element when reached the max size + if (discoveryDeviceInfoMap_.size() == SOFTBUS_DISCOVER_DEVICE_INFO_MAX_SIZE) { + auto iter = discoveryDeviceInfoMap_.begin(); + discoveryDeviceInfoMap_.erase(iter->second->devId); + } + DmDeviceInfo dmDeviceInfo; + CovertDeviceInfoToDmDevice(*device, dmDeviceInfo); + for (auto &iter : discoveryCallbackMap_) { + iter.second->OnDeviceFound(iter.first, dmDeviceInfo); + } +} + +void SoftbusConnector::OnSoftbusDiscoveryFailed(int32_t subscribeId, DiscoveryFailReason failReason) +{ + LOGI("In, subscribeId %d, failReason %d", subscribeId, (int32_t)failReason); + uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SOFTBUS_SUBSCRIBE_ID_MASK); + for (auto &iter : discoveryCallbackMap_) { + iter.second->OnDiscoveryFailed(iter.first, originId, (int32_t)failReason); + } +} + +void SoftbusConnector::OnSoftbusDiscoverySuccess(int32_t subscribeId) +{ + LOGI("In, subscribeId %d", subscribeId); + uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SOFTBUS_SUBSCRIBE_ID_MASK); + for (auto &iter : discoveryCallbackMap_) { + iter.second->OnDiscoverySuccess(iter.first, originId); + } +} + +void SoftbusConnector::OnParameterChgCallback(const char *key, const char *value, void *context) +{ + if (strcmp(value, DISCOVER_STATUS_ON.c_str()) == 0 && publishStatus != ALLOW_BE_DISCOVERY) { + PublishInfo dmPublishInfo; + dmPublishInfo.publishId = DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID; + dmPublishInfo.mode = DiscoverMode::DISCOVER_MODE_ACTIVE; + dmPublishInfo.medium = ExchanageMedium::AUTO; + dmPublishInfo.freq = ExchangeFreq::HIGH; + dmPublishInfo.capability = DM_CAPABILITY_OSD; + dmPublishInfo.capabilityData = nullptr; + dmPublishInfo.dataLen = 0; + int32_t ret = PublishService(DM_PKG_NAME.c_str(), &dmPublishInfo, &softbusPublishCallback_); + if (ret == DM_OK) { + publishStatus = ALLOW_BE_DISCOVERY; + } + LOGI("service publish result is : %d", ret); + } else if (strcmp(value, DISCOVER_STATUS_OFF.c_str()) == 0 && publishStatus != NOT_ALLOW_BE_DISCOVERY) { + int32_t ret = UnPublishService(DM_PKG_NAME.c_str(), DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID); + if (ret == DM_OK) { + publishStatus = NOT_ALLOW_BE_DISCOVERY; + } + LOGI("service unpublish result is : %d", ret); + } +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/services/devicemanagerservice/src/dependency/softbus/softbus_session.cpp b/services/devicemanagerservice/src/dependency/softbus/softbus_session.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dc2c971fa26223eb58d970b6fb1aaa2e0aa12e46 --- /dev/null +++ b/services/devicemanagerservice/src/dependency/softbus/softbus_session.cpp @@ -0,0 +1,165 @@ +/* + * 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_session.h" + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "nlohmann/json.hpp" +#include "softbus_connector.h" + +namespace OHOS { +namespace DistributedHardware { + +std::map> SoftbusSession::sessionCallbackMap_ = {}; + +SoftbusSession::SoftbusSession() +{ + ISessionListener sessionListener = {.OnSessionOpened = SoftbusSession::OnSessionOpened, + .OnSessionClosed = SoftbusSession::OnSessionClosed, + .OnBytesReceived = SoftbusSession::OnBytesReceived, + .OnMessageReceived = nullptr, + .OnStreamReceived = nullptr}; + int32_t ret = CreateSessionServer(DM_PKG_NAME.c_str(), DM_SESSION_NAME.c_str(), &sessionListener); + if (ret != DM_OK) { + LOGD("CreateSessionServer failed"); + } else { + LOGI("CreateSessionServer ok"); + } +} + +SoftbusSession::~SoftbusSession() +{ + RemoveSessionServer(DM_PKG_NAME.c_str(), DM_SESSION_NAME.c_str()); +} + +int32_t SoftbusSession::RegisterSessionCallback(const std::string &pkgName, + std::shared_ptr callback) +{ + sessionCallbackMap_[pkgName] = callback; + return DM_OK; +} + +int32_t SoftbusSession::UnRegisterSessionCallback(const std::string &pkgName) +{ + sessionCallbackMap_.erase(pkgName); + return DM_OK; +} + +int32_t SoftbusSession::OpenAuthSession(const std::string &deviceId) +{ + LOGE("SoftbusSession::OpenAuthSession"); + int32_t sessionId = -1; + std::string connectAddr; + ConnectionAddr *addrInfo = SoftbusConnector::GetConnectAddr(deviceId, connectAddr); + if (addrInfo == nullptr) { + LOGE("GetConnectAddr error"); + return sessionId; + } + sessionId = ::OpenAuthSession(DM_SESSION_NAME.c_str(), addrInfo, 1, nullptr); + if (sessionId < 0) { + LOGE("open session error, ret:%d", sessionId); + return sessionId; + } + LOGI("SoftbusSession::OpenAuthSession success. sessionId is:%d", sessionId); + return sessionId; +} + +int32_t SoftbusSession::CloseAuthSession(int32_t sessionId) +{ + LOGI("SoftbusSession::CloseAuthSession"); + ::CloseSession(sessionId); + return DM_OK; +} + +int32_t SoftbusSession::GetPeerDeviceId(int32_t sessionId, std::string &peerDevId) +{ + char peerDeviceId[DEVICE_UUID_LENGTH] = {0}; + int32_t ret = ::GetPeerDeviceId(sessionId, &peerDeviceId[0], DEVICE_UUID_LENGTH); + if (ret == 0) { + peerDevId = peerDeviceId; + LOGI("GetPeerDeviceId success for session:%d, peerDeviceId:%s", sessionId, GetAnonyString(peerDevId).c_str()); + return DM_FAILED; + } + LOGE("GetPeerDeviceId failed for session:%d", sessionId); + peerDevId = ""; + return DM_OK; +} + +int32_t SoftbusSession::SendData(int32_t sessionId, std::string &message) +{ + LOGE("SendData Start"); + nlohmann::json jsonObject = nlohmann::json::parse(message, nullptr, false); + if (jsonObject.is_discarded()) { + LOGE("extrasJson error"); + return DM_FAILED; + } + int32_t msgType = jsonObject[TAG_TYPE]; + LOGI("AuthMessageProcessor::ParseAuthRequestMessage msgType = %d", msgType); + bool isCryptoSupport = false; + for (auto &iter : sessionCallbackMap_) { + iter.second->GetIsCryptoSupport(isCryptoSupport); + } + if (isCryptoSupport) { + LOGI("SoftbusSession::SendData Start encryption"); + } + int32_t ret = SendBytes(sessionId, message.c_str(), strlen(message.c_str())); + if (ret != DM_OK) { + LOGE("SendData Start failed"); + return DM_FAILED; + } + LOGE("SendData Start success"); + return DM_OK; +} + +int32_t SoftbusSession::OnSessionOpened(int32_t sessionId, int32_t result) +{ + int32_t sessionSide = GetSessionSide(sessionId); + for (auto &iter : sessionCallbackMap_) { + iter.second->OnSessionOpened(iter.first, sessionId, sessionSide, result); + } + LOGI("OnSessionOpened, success:"); + return DM_OK; +} + +void SoftbusSession::OnSessionClosed(int32_t sessionId) +{ + LOGI("OnSessionClosed, sessionId:%d", sessionId); +} + +void SoftbusSession::OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen) +{ + LOGI("OnBytesReceived, sessionId:%d, dataLen:%d", sessionId, dataLen); + if (sessionId < 0 || data == nullptr || dataLen <= 0) { + LOGI("OnBytesReceived param check failed"); + return; + } + bool isCryptoSupport = false; + for (auto &iter : sessionCallbackMap_) { + iter.second->GetIsCryptoSupport(isCryptoSupport); + } + if (isCryptoSupport) { + LOGI("SoftbusSession::OnBytesReceived Start decryption"); + } + std::string message = std::string((const char *)data, dataLen); + for (auto &iter : sessionCallbackMap_) { + iter.second->OnDataReceived(iter.first, sessionId, message); + } + LOGI("OnBytesReceived completed"); +} + +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/timer/dm_timer.cpp b/services/devicemanagerservice/src/dependency/timer/dm_timer.cpp similarity index 67% rename from services/devicemanagerservice/src/timer/dm_timer.cpp rename to services/devicemanagerservice/src/dependency/timer/dm_timer.cpp index 8e736945a88d92ece0f0111ed72dd1f6ffe7b5ad..dc9a82b9c21cbffde95d35d894c073a1ef3ed171 100644 --- a/services/devicemanagerservice/src/timer/dm_timer.cpp +++ b/services/devicemanagerservice/src/dependency/timer/dm_timer.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -39,13 +39,13 @@ DmTimer::DmTimer(std::string &name) DmTimer::~DmTimer() { - DMLOG(DM_LOG_INFO, "DmTimer %s Destory in", mTimerName_.c_str()); + LOGI("DmTimer %s Destory in", mTimerName_.c_str()); Release(); } DmTimerStatus DmTimer::Start(uint32_t timeOut, TimeoutHandle handle, void *data) { - DMLOG(DM_LOG_INFO, "DmTimer %s start timeout(%d)", mTimerName_.c_str(), timeOut); + LOGI("DmTimer %s start timeout(%d)", mTimerName_.c_str(), timeOut); if (mStatus_ != DmTimerStatus::DM_STATUS_INIT) { return DmTimerStatus::DM_STATUS_BUSY; } @@ -59,7 +59,7 @@ DmTimerStatus DmTimer::Start(uint32_t timeOut, TimeoutHandle handle, void *data) } mStatus_ = DmTimerStatus::DM_STATUS_RUNNING; - mThread_ = std::thread(&DmTimer::WiteforTimeout, this); + mThread_ = std::thread(&DmTimer::WaitForTimeout, this); mThread_.detach(); return mStatus_; @@ -67,26 +67,26 @@ DmTimerStatus DmTimer::Start(uint32_t timeOut, TimeoutHandle handle, void *data) void DmTimer::Stop(int32_t code) { - DMLOG(DM_LOG_INFO, "DmTimer %s Stop code (%d)", mTimerName_.c_str(), code); + LOGI("DmTimer %s Stop code (%d)", mTimerName_.c_str(), code); if (mTimeFd_[1]) { char event = 'S'; if (write(mTimeFd_[1], &event, 1) < 0) { - DMLOG(DM_LOG_ERROR, "DmTimer %s Stop timer failed, errno %d", mTimerName_.c_str(), errno); + LOGE("DmTimer %s Stop timer failed, errno %d", mTimerName_.c_str(), errno); return; } - DMLOG(DM_LOG_INFO, "DmTimer %s Stop success", mTimerName_.c_str()); + LOGI("DmTimer %s Stop success", mTimerName_.c_str()); } return; } -void DmTimer::WiteforTimeout() +void DmTimer::WaitForTimeout() { - DMLOG(DM_LOG_INFO, "DmTimer %s start timer at (%d)s", mTimerName_.c_str(), mTimeOutSec_); + LOGI("DmTimer %s start timer at (%d)s", mTimerName_.c_str(), mTimeOutSec_); int32_t nfds = epoll_wait(mEpFd_, mEvents_, MAXEVENTS, mTimeOutSec_ * MILL_SECONDS_PER_SECOND); if (nfds < 0) { - DMLOG(DM_LOG_ERROR, "DmTimer %s epoll_wait returned n=%d, error: %d", mTimerName_.c_str(), nfds, errno); + LOGE("DmTimer %s epoll_wait returned n=%d, error: %d", mTimerName_.c_str(), nfds, errno); } char event = 0; @@ -94,9 +94,9 @@ void DmTimer::WiteforTimeout() if (mEvents_[0].events & EPOLLIN) { int num = read(mTimeFd_[0], &event, 1); if (num > 0) { - DMLOG(DM_LOG_INFO, "DmTimer %s exit with event %d", mTimerName_.c_str(), event); + LOGI("DmTimer %s exit with event %d", mTimerName_.c_str(), event); } else { - DMLOG(DM_LOG_ERROR, "DmTimer %s exit with errno %d", mTimerName_.c_str(), errno); + LOGE("DmTimer %s exit with errno %d", mTimerName_.c_str(), errno); } } Release(); @@ -106,18 +106,18 @@ void DmTimer::WiteforTimeout() mHandle_(mHandleData_); Release(); - DMLOG(DM_LOG_ERROR, "DmTimer %s end timer at (%d)s", mTimerName_.c_str(), mTimeOutSec_); + LOGE("DmTimer %s end timer at (%d)s", mTimerName_.c_str(), mTimeOutSec_); return; } int32_t DmTimer::CreateTimeFd() { - DMLOG(DM_LOG_INFO, "DmTimer %s creatTimeFd", mTimerName_.c_str()); + LOGI("DmTimer %s creatTimeFd", mTimerName_.c_str()); int ret = 0; ret = pipe(mTimeFd_); if (ret < 0) { - DMLOG(DM_LOG_ERROR, "DmTimer %s CreateTimeFd fail:(%d) errno(%d)", mTimerName_.c_str(), ret, errno); + LOGE("DmTimer %s CreateTimeFd fail:(%d) errno(%d)", mTimerName_.c_str(), ret, errno); return ret; } @@ -134,9 +134,9 @@ int32_t DmTimer::CreateTimeFd() void DmTimer::Release() { - DMLOG(DM_LOG_INFO, "DmTimer %s Release in", mTimerName_.c_str()); + LOGI("DmTimer %s Release in", mTimerName_.c_str()); if (mStatus_ == DmTimerStatus::DM_STATUS_INIT) { - DMLOG(DM_LOG_INFO, "DmTimer %s already Release", mTimerName_.c_str()); + LOGI("DmTimer %s already Release", mTimerName_.c_str()); return; } mStatus_ = DmTimerStatus::DM_STATUS_INIT; @@ -149,5 +149,5 @@ void DmTimer::Release() mTimeFd_[1] = 0; mEpFd_ = 0; } -} -} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/device_manager_service.cpp b/services/devicemanagerservice/src/device_manager_service.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dd013d4e6e19073e2b4f275153294c0b1b69a9c2 --- /dev/null +++ b/services/devicemanagerservice/src/device_manager_service.cpp @@ -0,0 +1,229 @@ +/* + * 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 "device_manager_service_listener.h" +#include "dm_constants.h" +#include "dm_device_info_manager.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { + +IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService); + +int32_t DeviceManagerService::Init() +{ + if (intFlag_) { + LOGE("Init failed, singleton cannot be initialized multiple times"); + return DM_INT_MULTIPLE; + } + if (softbusConnector_ == nullptr) { + softbusConnector_ = std::make_shared(); + if (softbusConnector_ == nullptr) { + LOGE("Init failed, softbusConnector_ apply for failure"); + return DM_MAKE_SHARED_FAIL; + } + } + if (listener_ == nullptr) { + listener_ = std::make_shared(); + if (softbusConnector_ == nullptr) { + LOGE("Init failed, listener_ apply for failure"); + return DM_MAKE_SHARED_FAIL; + } + } + if (deviceInfoMgr_ == nullptr) { + deviceInfoMgr_ = std::make_shared(softbusConnector_); + if (deviceInfoMgr_ == nullptr) { + LOGE("Init failed, deviceInfoMgr_ apply for failure"); + return DM_MAKE_SHARED_FAIL; + } + } + if (deviceStateMgr_ == nullptr) { + deviceStateMgr_ = std::make_shared(softbusConnector_, listener_); + if (deviceStateMgr_ == nullptr) { + LOGE("Init failed, deviceStateMgr_ apply for failure"); + return DM_MAKE_SHARED_FAIL; + } + deviceStateMgr_->RegisterSoftbusStateCallback(); + } + if (discoveryMgr_ == nullptr) { + discoveryMgr_ = std::make_shared(softbusConnector_, listener_); + if (discoveryMgr_ == nullptr) { + LOGE("Init failed, discoveryMgr_ apply for failure"); + return DM_MAKE_SHARED_FAIL; + } + } + if (authMgr_ == nullptr) { + authMgr_ = std::make_shared(softbusConnector_, listener_); + if (authMgr_ == nullptr) { + LOGE("Init failed, authMgr_ apply for failure"); + return DM_MAKE_SHARED_FAIL; + } + authMgr_->RegisterSessionCallback(); + } + LOGI("Init success, singleton initialized"); + intFlag_ = true; + return DM_OK; +} + +int32_t DeviceManagerService::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList) +{ + if (!intFlag_) { + LOGE("GetTrustedDeviceList failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + if (pkgName.empty()) { + LOGE("GetTrustedDeviceList failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + return deviceInfoMgr_->GetTrustedDeviceList(pkgName, extra, deviceList); +} + +int32_t DeviceManagerService::GetLocalDeviceInfo(DmDeviceInfo &info) +{ + if (!intFlag_) { + LOGE("GetLocalDeviceInfo failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + return deviceInfoMgr_->GetLocalDeviceInfo(info); +} + +int32_t DeviceManagerService::GetUdidByNetworkId(const std::string &pkgName, const std::string &netWorkId, + std::string &udid) +{ + if (!intFlag_) { + LOGE("GetLocalDeviceInfo failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + + if (pkgName.empty()) { + LOGE("StartDeviceDiscovery failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + SoftbusConnector::GetUdidByNetworkId(netWorkId.c_str(), udid); + return DM_OK; +} + +int32_t DeviceManagerService::GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, + std::string &uuid) +{ + if (!intFlag_) { + LOGE("GetLocalDeviceInfo failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + + if (pkgName.empty()) { + LOGE("StartDeviceDiscovery failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + SoftbusConnector::GetUuidByNetworkId(netWorkId.c_str(), uuid); + return DM_OK; +} + +int32_t DeviceManagerService::StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra) +{ + if (!intFlag_) { + LOGE("StartDeviceDiscovery failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + if (pkgName.empty()) { + LOGE("StartDeviceDiscovery failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + return discoveryMgr_->StartDeviceDiscovery(pkgName, subscribeInfo, extra); +} + +int32_t DeviceManagerService::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId) +{ + if (!intFlag_) { + LOGE("StopDeviceDiscovery failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + if (pkgName.empty()) { + LOGE("StopDeviceDiscovery failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + return discoveryMgr_->StopDeviceDiscovery(pkgName, subscribeId); +} + +int32_t DeviceManagerService::AuthenticateDevice(const std::string &pkgName, int32_t authType, + const std::string &deviceId, const std::string &extra) +{ + if (!intFlag_) { + LOGE("AuthenticateDevice failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + if (pkgName.empty()) { + LOGE("AuthenticateDevice failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + if (deviceId.empty()) { + LOGE("AuthenticateDevice failed, deviceId is empty"); + return DM_INPUT_PARA_EMPTY; + } + return authMgr_->AuthenticateDevice(pkgName, authType, deviceId, extra); +} + +int32_t DeviceManagerService::UnAuthenticateDevice(const std::string &pkgName, const std::string &deviceId) +{ + if (!intFlag_) { + LOGE("UnAuthenticateDevice failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + if (pkgName.empty()) { + LOGE("UnAuthenticateDevice failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + if (deviceId.empty()) { + LOGE("UnAuthenticateDevice failed, deviceId is empty"); + return DM_INPUT_PARA_EMPTY; + } + return authMgr_->UnAuthenticateDevice(pkgName, deviceId); +} + +int32_t DeviceManagerService::VerifyAuthentication(const std::string &authParam) +{ + if (!intFlag_) { + LOGE("VerifyAuthentication failed, singleton not init or init fail"); + return DM_NOT_INIT; + } + return authMgr_->VerifyAuthentication(authParam); +} + +int32_t DeviceManagerService::GetFaParam(std::string &pkgName, DmAuthParam &authParam) +{ + if (pkgName.empty()) { + LOGE("GetFaParam failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + authMgr_->GetAuthenticationParam(authParam); + return DM_OK; +} + +int32_t DeviceManagerService::SetUserOperation(std::string &pkgName, int32_t action) +{ + if (pkgName.empty()) { + LOGE("SetUserOperation failed, pkgName is empty"); + return DM_INPUT_PARA_EMPTY; + } + authMgr_->OnUserOperation(action); + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/ipc_server_listener_adapter.cpp b/services/devicemanagerservice/src/device_manager_service_listener.cpp similarity index 52% rename from services/devicemanagerservice/src/ipc/ipc_server_listener_adapter.cpp rename to services/devicemanagerservice/src/device_manager_service_listener.cpp index 2fd07e261d0ddb585ea8a93ef51e5b95c3f7057e..b2290edeb2007baed1c964cf5378ce233c173aab 100644 --- a/services/devicemanagerservice/src/ipc/ipc_server_listener_adapter.cpp +++ b/services/devicemanagerservice/src/device_manager_service_listener.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,116 +13,105 @@ * 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 "device_manager_service_listener.h" +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.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" +#include "ipc_notify_verify_auth_result_req.h" namespace OHOS { namespace DistributedHardware { -IMPLEMENT_SINGLE_INSTANCE(IpcServerListenerAdapter); -void IpcServerListenerAdapter::OnDeviceStateChange(DmDeviceState state, DmDeviceInfo &deviceInfo) +void DeviceManagerServiceListener::OnDeviceStateChange(const std::string &pkgName, const DmDeviceState &state, + const DmDeviceInfo &info) { - DMLOG(DM_LOG_INFO, "OnDeviceStateChange"); + LOGI("OnDeviceStateChange, state=%d", state); std::shared_ptr pReq = std::make_shared(); std::shared_ptr pRsp = std::make_shared(); pReq->SetDeviceState(state); - pReq->SetDeviceInfo(deviceInfo); + pReq->SetDeviceInfo(info); ipcServerListener_.SendAll(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp); } -void IpcServerListenerAdapter::OnDeviceFound(std::string &pkgName, uint16_t originId, - DmDeviceInfo &deviceInfo) +void DeviceManagerServiceListener::OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, + const DmDeviceInfo &info) { - DMLOG(DM_LOG_INFO, "call OnDeviceFound for %s, originId %d, deviceId %s", - pkgName.c_str(), originId, GetAnonyString(std::string(deviceInfo.deviceId)).c_str()); + LOGI("call OnDeviceFound for %s, originId %d, deviceId %s", pkgName.c_str(), subscribeId, + GetAnonyString(std::string(info.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); + pReq->SetSubscribeId(subscribeId); + pReq->SetDeviceInfo(info); ipcServerListener_.SendRequest(SERVER_DEVICE_FOUND, pReq, pRsp); } -void IpcServerListenerAdapter::OnDiscoverFailed(std::string &pkgName, uint16_t originId, - DiscoveryFailReason failReason) +void DeviceManagerServiceListener::OnDiscoveryFailed(const std::string &pkgName, uint16_t subscribeId, + int32_t failedReason) { - DMLOG(DM_LOG_INFO, "OnDiscoverFailed"); + LOGI("OnDiscoveryFailed"); std::shared_ptr pReq = std::make_shared(); std::shared_ptr pRsp = std::make_shared(); pReq->SetPkgName(pkgName); - pReq->SetSubscribeId(originId); - pReq->SetResult(failReason); + pReq->SetSubscribeId(subscribeId); + pReq->SetResult(failedReason); ipcServerListener_.SendRequest(SERVER_DISCOVER_FINISH, pReq, pRsp); } -void IpcServerListenerAdapter::OnDiscoverySuccess(std::string &pkgName, uint16_t originId) +void DeviceManagerServiceListener::OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId) { - DMLOG(DM_LOG_INFO, "OnDiscoverySuccess"); + LOGI("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); + pReq->SetSubscribeId(subscribeId); + pReq->SetResult(DM_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) +void DeviceManagerServiceListener::OnAuthResult(const std::string &pkgName, const std::string &deviceId, + const std::string &token, int32_t status, const std::string &reason) { - DMLOG(DM_LOG_INFO, "%s, package: %s, deviceId: %s", __FUNCTION__, pkgName.c_str(), - GetAnonyString(deviceId).c_str()); + LOGI("%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->SetToken(token); pReq->SetStatus(status); - pReq->SetReason(reason); ipcServerListener_.SendRequest(SERVER_AUTH_RESULT, pReq, pRsp); } -void IpcServerListenerAdapter::OnCheckAuthResult(std::string &authParam, int32_t resultCode, - int32_t flag) +void DeviceManagerServiceListener::OnVerifyAuthResult(const std::string &pkgName, const std::string &deviceId, + int32_t resultCode, const std::string &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 pReq = std::make_shared(); std::shared_ptr pRsp = std::make_shared(); - pReq->SetDeviceId(authParam); + pReq->SetDeviceId(deviceId); pReq->SetResult(resultCode); - pReq->SetFlag(flag); - ipcServerListener_.SendAll(SERVER_CHECK_AUTH_RESULT, pReq, pRsp); + ipcServerListener_.SendAll(SERVER_VERIFY_AUTH_RESULT, pReq, pRsp); } -void IpcServerListenerAdapter::OnFaCall(std::string &pkgName, std::string ¶mJson) +void DeviceManagerServiceListener::OnFaCall(std::string &pkgName, std::string ¶mJson) { - DMLOG(DM_LOG_INFO, "OnFaCall in"); + LOGI("OnFaCall in"); 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); + ipcServerListener_.SendRequest(SERVER_DEVICE_FA_NOTIFY, pReq, pRsp); } } // namespace DistributedHardware } // namespace OHOS diff --git a/services/devicemanagerservice/src/deviceinfo/dm_device_info_manager.cpp b/services/devicemanagerservice/src/deviceinfo/dm_device_info_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dcf240abf089cfb91eb3b53d8357e4ea853aae11 --- /dev/null +++ b/services/devicemanagerservice/src/deviceinfo/dm_device_info_manager.cpp @@ -0,0 +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. + */ + +#include "dm_device_info_manager.h" + +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +DmDeviceInfoManager::DmDeviceInfoManager(std::shared_ptr &softbusConnectorPtr) + : softbusConnector_(softbusConnectorPtr) +{ + LOGI("DmDeviceInfoManager constructor"); +} + +int32_t DmDeviceInfoManager::GetTrustedDeviceList(const std::string &pkgName, const std::string &extra, + std::vector &deviceList) +{ + int32_t ret = softbusConnector_->GetTrustedDeviceList(deviceList); + if (ret != DM_OK) { + LOGE("GetTrustedDeviceList failed"); + return ret; + } + + if (!extra.empty() && !deviceList.empty()) { + std::string soName; + DmAdapterManager &adapterMgrPtr = DmAdapterManager::GetInstance(); + std::shared_ptr decisionAdapter = adapterMgrPtr.GetDecisionAdapter(soName); + if (decisionAdapter != nullptr) { + decisionAdapter->FilterDeviceList(deviceList, extra); + } else { + LOGE("GetTrustedDeviceList decisionAdapter is nullptr"); + } + } + + return DM_OK; +} + +int32_t DmDeviceInfoManager::GetLocalDeviceInfo(DmDeviceInfo &info) +{ + int32_t ret = softbusConnector_->GetLocalDeviceInfo(info); + if (ret != DM_OK) { + LOGE("GetLocalDeviceInfo failed"); + return ret; + } + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/devicestate/dm_device_state_manager.cpp b/services/devicemanagerservice/src/devicestate/dm_device_state_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..9e7a479f6d63a6bfa2b17e044e4beba43f25cd2a --- /dev/null +++ b/services/devicemanagerservice/src/devicestate/dm_device_state_manager.cpp @@ -0,0 +1,121 @@ +/* + * 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_state_manager.h" + +#include "dm_adapter_manager.h" +#include "dm_constants.h" +#include "dm_log.h" +namespace OHOS { +namespace DistributedHardware { + +DmDeviceStateManager::DmDeviceStateManager(std::shared_ptr softbusConnector, + std::shared_ptr listener) + : softbusConnector_(softbusConnector), listener_(listener) +{ + LOGI("DmDeviceStateManager constructor"); + profileSoName_ = "libdevicemanagerext_profile.z.so"; +} + +DmDeviceStateManager::~DmDeviceStateManager() +{ + LOGI("DmDeviceStateManager destructor"); + softbusConnector_->UnRegisterSoftbusStateCallback(""); +} + +void DmDeviceStateManager::OnDeviceOnline(const std::string &pkgName, const DmDeviceInfo &info) +{ + LOGI("DmDeviceStateManager::OnDeviceOnline in"); + DmAdapterManager &adapterMgrPtr = DmAdapterManager::GetInstance(); + std::shared_ptr profileAdapter = adapterMgrPtr.GetProfileAdapter(profileSoName_); + if (profileAdapter == nullptr) { + LOGE("OnDeviceOnline profile adapter is null"); + } else { + uint8_t udid[UDID_BUF_LEN] = {0}; + int32_t ret = SoftbusConnector::GetNodeKeyInfoByNetworkId(info.deviceId, NodeDeivceInfoKey::NODE_KEY_UDID, udid, + sizeof(udid)); + if (ret != DM_OK) { + LOGE("DmDeviceStateManager::OnDeviceOnline GetNodeKeyInfo failed"); + } else { + std::string deviceUdid = (char *)udid; + DmDeviceInfo saveInfo = info; + std::string uuid; + SoftbusConnector::GetUuidByNetworkId(info.deviceId, uuid); + remoteDeviceInfos_[uuid] = saveInfo; + LOGI("RegisterProfileListener in, deviceId = %s, deviceUdid = %s, uuid = %s", + info.deviceId, deviceUdid.c_str(), uuid.c_str()); + //set networkId or udid; + profileAdapter->RegisterProfileListener(pkgName, deviceUdid, shared_from_this()); + LOGI("RegisterProfileListener out"); + } + } + DmDeviceState state = DEVICE_STATE_ONLINE; + deviceStateMap_[info.deviceId] = DEVICE_STATE_ONLINE; + listener_->OnDeviceStateChange(pkgName, state, info); + LOGI("DmDeviceStateManager::OnDeviceOnline out"); +} + +void DmDeviceStateManager::OnDeviceOffline(const std::string &pkgName, const DmDeviceInfo &info) +{ + DmAdapterManager &adapterMgrPtr = DmAdapterManager::GetInstance(); + std::shared_ptr profileAdapter = adapterMgrPtr.GetProfileAdapter(profileSoName_); + if (profileAdapter == nullptr) { + LOGE("OnDeviceOffline profile adapter is null"); + } else { + profileAdapter->UnRegisterProfileListener(pkgName); + std::string uuid; + SoftbusConnector::GetUuidByNetworkId(info.deviceId, uuid); + auto iter = remoteDeviceInfos_.find(std::string(info.deviceId)); + if (iter == remoteDeviceInfos_.end()) { + } else { + remoteDeviceInfos_.erase(std::string(info.deviceId)); + } + } + DmDeviceState state = DEVICE_STATE_OFFLINE; + deviceStateMap_[info.deviceId] = DEVICE_STATE_OFFLINE; + listener_->OnDeviceStateChange(pkgName, state, info); +} + +void DmDeviceStateManager::OnDeviceChanged(const std::string &pkgName, const DmDeviceInfo &info) +{ + deviceStateMap_[info.deviceId] = DEVICE_INFO_CHANGED; +} + +void DmDeviceStateManager::OnDeviceReady(const std::string &pkgName, const DmDeviceInfo &info) +{ + deviceStateMap_[info.deviceId] = DEVICE_INFO_READY; +} + +void DmDeviceStateManager::OnProfileReady(const std::string &pkgName, const std::string deviceId) +{ + DmDeviceInfo saveInfo; + auto iter = remoteDeviceInfos_.find(deviceId); + if (iter == remoteDeviceInfos_.end()) { + LOGE("DmDeviceStateManager::OnProfileReady complete not find deviceID = %s", deviceId.c_str()); + } else { + saveInfo = iter->second; + } + DmDeviceState state = DEVICE_INFO_READY; + listener_->OnDeviceStateChange(pkgName, state, saveInfo); +} + +int32_t DmDeviceStateManager::RegisterSoftbusStateCallback() +{ + softbusConnector_->RegisterSoftbusStateCallback(DM_PKG_NAME, + std::shared_ptr(shared_from_this())); + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/discovery/dm_discovery_manager.cpp b/services/devicemanagerservice/src/discovery/dm_discovery_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cb4c8f8d5049e0cd921e285d28b1721904428e1c --- /dev/null +++ b/services/devicemanagerservice/src/discovery/dm_discovery_manager.cpp @@ -0,0 +1,119 @@ +/* + * 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_discovery_manager.h" + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +namespace { +std::string DISCOVERY_TIMEOUT_TASK = "discoveryTimeout"; +int32_t DISCOVERY_TIMEOUT = 120; +int32_t SESSION_CANCEL_TIMEOUT = 0; +} // namespace +static void TimeOut(void *data) +{ + LOGE("time out "); + DmDiscoveryManager *discoveryMgr = (DmDiscoveryManager *)data; + if (discoveryMgr == nullptr) { + LOGE("time out error"); + return; + } + discoveryMgr->HandleDiscoveryTimeout(); +} + +DmDiscoveryManager::DmDiscoveryManager(std::shared_ptr softbusConnector, + std::shared_ptr listener) + : softbusConnector_(softbusConnector), listener_(listener) +{ + LOGI("DmDiscoveryManager constructor"); +} + +DmDiscoveryManager::~DmDiscoveryManager() +{ + LOGI("DmDiscoveryManager destructor"); +} + +int32_t DmDiscoveryManager::StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo, + const std::string &extra) +{ + if (!discoveryQueue_.empty()) { + if (pkgName == discoveryQueue_.front()) { + LOGE("DmDiscoveryManager::StartDeviceDiscovery repeated, pkgName:%s", pkgName.c_str()); + return DM_DISCOVERY_REPEATED; + } else { + LOGD("DmDiscoveryManager::StartDeviceDiscovery stop preview discovery first, the preview pkgName is %s", + discoveryQueue_.front().c_str()); + StopDeviceDiscovery(discoveryQueue_.front(), discoveryContextMap_[discoveryQueue_.front()].subscribeId); + } + } + discoveryQueue_.push(pkgName); + DmDiscoveryContext context = {pkgName, extra, subscribeInfo.subscribeId}; + discoveryContextMap_.emplace(pkgName, context); + softbusConnector_->RegisterSoftbusDiscoveryCallback(pkgName, + std::shared_ptr(shared_from_this())); + discoveryTimer_ = std::make_shared(DISCOVERY_TIMEOUT_TASK); + discoveryTimer_->Start(DISCOVERY_TIMEOUT, TimeOut, this); + return softbusConnector_->StartDiscovery(subscribeInfo); +} + +int32_t DmDiscoveryManager::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId) +{ + if (!discoveryQueue_.empty()) { + discoveryQueue_.pop(); + } + if (!discoveryContextMap_.empty()) { + discoveryContextMap_.erase(pkgName); + softbusConnector_->UnRegisterSoftbusDiscoveryCallback(pkgName); + discoveryTimer_->Stop(SESSION_CANCEL_TIMEOUT); + } + return softbusConnector_->StopDiscovery(subscribeId); +} + +void DmDiscoveryManager::OnDeviceFound(const std::string &pkgName, const DmDeviceInfo &info) +{ + LOGI("DmDiscoveryManager::OnDeviceFound deviceId=%s", GetAnonyString(info.deviceId).c_str()); + auto iter = discoveryContextMap_.find(pkgName); + if (iter == discoveryContextMap_.end()) { + LOGE("subscribeId not found by pkgName %s", GetAnonyString(pkgName).c_str()); + return; + } + listener_->OnDeviceFound(pkgName, iter->second.subscribeId, info); +} + +void DmDiscoveryManager::OnDiscoveryFailed(const std::string &pkgName, int32_t subscribeId, int32_t failedReason) +{ + LOGI("DmDiscoveryManager::OnDiscoveryFailed subscribeId=%d reason=%d", subscribeId, failedReason); + StopDeviceDiscovery(pkgName, subscribeId); + listener_->OnDiscoveryFailed(pkgName, subscribeId, failedReason); +} + +void DmDiscoveryManager::OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId) +{ + LOGI("DmDiscoveryManager::OnDiscoverySuccess subscribeId=%d", subscribeId); + discoveryContextMap_[pkgName].subscribeId = subscribeId; + listener_->OnDiscoverySuccess(pkgName, subscribeId); +} + +void DmDiscoveryManager::HandleDiscoveryTimeout() +{ + LOGI("DmDiscoveryManager::HandleDiscoveryTimeout"); + StopDeviceDiscovery(discoveryQueue_.front(), discoveryContextMap_[discoveryQueue_.front()].subscribeId); +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/ipc/ipc_server_adapter.cpp b/services/devicemanagerservice/src/ipc/ipc_server_adapter.cpp deleted file mode 100644 index 584da618bb667883e97f9e8576269c4e3c0420f1..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/ipc/ipc_server_adapter.cpp +++ /dev/null @@ -1,198 +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 - -#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) -{ - if (info == nullptr || infoNum == nullptr) { - return DEVICEMANAGER_NULLPTR; - } - DMLOG(DM_LOG_INFO, "In, pkgName: %s", pkgName.c_str()); - NodeBasicInfo *nodeInfo = nullptr; - *info = nullptr; - *infoNum = 0; - int32_t ret = SoftbusAdapter::GetTrustDevices(pkgName, &nodeInfo, infoNum); - if (ret != DEVICEMANAGER_OK || *infoNum <= 0 || nodeInfo == nullptr) { - DMLOG(DM_LOG_ERROR, "GetTrustDevices errCode:%d, num:%d", ret, *infoNum); - return ret; - } - *info = (DmDeviceInfo *)malloc(sizeof(DmDeviceInfo) * (*infoNum)); - if (*info == nullptr) { - FreeNodeInfo(nodeInfo); - return DEVICEMANAGER_MALLOC_ERROR; - } - for (int32_t i = 0; i < *infoNum; ++i) { - NodeBasicInfo *nodeBasicInfo = nodeInfo + i; - DmDeviceInfo *deviceInfo = *info + i; - if (memcpy_s(deviceInfo->deviceId, sizeof(deviceInfo->deviceId), nodeBasicInfo->networkId, - std::min(sizeof(deviceInfo->deviceId), sizeof(nodeBasicInfo->networkId))) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "memcpy failed"); - } - if (memcpy_s(deviceInfo->deviceName, sizeof(deviceInfo->deviceName), nodeBasicInfo->deviceName, - std::min(sizeof(deviceInfo->deviceName), sizeof(nodeBasicInfo->deviceName))) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "memcpy failed"); - } - 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/lite/ipc_cmd_parser.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_cmd_parser.cpp index b71b3edfd6f95e21d45cdc533a3ddd9024f23eff..6e14961b372fb70bf8f008de6d6064e8c27a888b 100644 --- a/services/devicemanagerservice/src/ipc/lite/ipc_cmd_parser.cpp +++ b/services/devicemanagerservice/src/ipc/lite/ipc_cmd_parser.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,26 +13,22 @@ * limitations under the License. */ -#include "constants.h" +#include "device_manager_service.h" +#include "dm_constants.h" +#include "dm_log.h" #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_notify_dmfa_result_req.h" -#include "ipc_server_adapter.h" +#include "ipc_notify_verify_auth_result_req.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) +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(); @@ -43,17 +39,17 @@ ON_IPC_SET_REQUEST(SERVER_DEVICE_STATE_NOTIFY, std::shared_ptr pBaseReq, IpcIoPushString(&request, pkgName.c_str()); IpcIoPushInt32(&request, deviceState); IpcIoPushFlatObj(&request, &deviceInfo, sizeof(DmDeviceInfo)); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_DEVICE_STATE_NOTIFY, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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(); @@ -64,17 +60,17 @@ ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr pBaseReq, IpcIo IpcIoPushString(&request, pkgName.c_str()); IpcIoPushUint16(&request, subscribeId); IpcIoPushFlatObj(&request, &deviceInfo, sizeof(DmDeviceInfo)); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_DEVICE_FOUND, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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(); @@ -85,44 +81,45 @@ ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr pBaseReq, Ipc IpcIoPushString(&request, pkgName.c_str()); IpcIoPushUint16(&request, subscribeId); IpcIoPushInt32(&request, result); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_DISCOVER_FINISH, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(SERVER_AUTH_RESULT, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +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(); + std::string token = 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); + IpcIoPushString(&request, token.c_str()); IpcIoPushInt32(&request, status); IpcIoPushInt32(&request, reason); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_AUTH_RESULT, IpcIo &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(SERVER_CHECK_AUTH_RESULT, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen) +ON_IPC_SET_REQUEST(SERVER_VERIFY_AUTH_RESULT, std::shared_ptr pBaseReq, IpcIo &request, uint8_t *buffer, + size_t buffLen) { - std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::shared_ptr pReq = + std::static_pointer_cast(pBaseReq); std::string pkgName = pReq->GetPkgName(); std::string deviceId = pReq->GetDeviceId(); int32_t result = pReq->GetResult(); @@ -133,30 +130,13 @@ ON_IPC_SET_REQUEST(SERVER_CHECK_AUTH_RESULT, std::shared_ptr pBaseReq, I IpcIoPushString(&request, deviceId.c_str()); IpcIoPushInt32(&request, result); IpcIoPushInt32(&request, flag); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_READ_RESPONSE(SERVER_CHECK_AUTH_RESULT, IpcIo &reply, std::shared_ptr pBaseRsp) +ON_IPC_READ_RESPONSE(SERVER_VERIFY_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); + return DM_OK; } ON_IPC_SERVER_CMD(REGISTER_DEVICE_MANAGER_LISTENER, IpcIo &req, IpcIo &reply) @@ -171,113 +151,106 @@ ON_IPC_SERVER_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, IpcIo &req, IpcIo &reply) IpcIoPushInt32(&reply, errCode); } +ON_IPC_SERVER_CMD(GET_TRUST_DEVICE_LIST, IpcIo &req, IpcIo &reply) +{ + LOGI("enter GetTrustedDeviceList."); + std::string pkgName = (const char *)IpcIoPopString(&req, nullptr); + std::string extra = (const char *)IpcIoPopString(&req, nullptr); + + std::vector deviceList; + int32_t ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); + IpcIoPushInt32(&reply, deviceList.size()); + if (deviceList.size() > 0) { + IpcIoPushFlatObj(&reply, deviceList.data(), sizeof(DmDeviceInfo) * deviceList.size()); + } + IpcIoPushInt32(&reply, ret); +} + +ON_IPC_SERVER_CMD(GET_LOCAL_DEVICE_INFO, IpcIo &req, IpcIo &reply) +{ + LOGI("enter GetLocalDeviceInfo."); + DmDeviceInfo dmDeviceInfo; + int32_t ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(dmDeviceInfo); + IpcIoPushFlatObj(&reply, &dmDeviceInfo, sizeof(DmDeviceInfo)); + IpcIoPushInt32(&reply, ret); +} + 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); + LOGI("StartDeviceDiscovery service listener."); + std::string pkgName = (const char *)IpcIoPopString(&req, nullptr); + std::string extra = (const char *)IpcIoPopString(&req, nullptr); - int32_t ret = IpcServerAdapter::GetInstance().StartDeviceDiscovery(pkgName, *pDmSubscribeInfo); + uint32_t size = 0; + DmSubscribeInfo *pDmSubscribeInfo = (DmSubscribeInfo *)IpcIoPopFlatObj(&req, &size); + int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, *pDmSubscribeInfo, extra); 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); + LOGI("StopDeviceDiscovery service listener."); + std::string pkgName = (const char *)IpcIoPopString(&req, nullptr); uint16_t subscribeId = IpcIoPopUint16(&req); - int32_t ret = IpcServerAdapter::GetInstance().StopDiscovery(pkgName, subscribeId); + int32_t ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(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); + LOGI("AuthenticateDevice service listener."); + std::string pkgName = (const char *)IpcIoPopString(&req, nullptr); + std::string extra = (const char *)IpcIoPopString(&req, nullptr); + std::string deviceId = (const char *)IpcIoPopString(&req, nullptr); + int32_t authType = IpcIoPopInt32(&req); + int32_t ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); IpcIoPushInt32(&reply, ret); } -ON_IPC_SERVER_CMD(CHECK_AUTHENTICATION, IpcIo &req, IpcIo &reply) +ON_IPC_SERVER_CMD(UNAUTHENTICATE_DEVICE, 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); + LOGI("UnAuthenticateDevice service listener."); + std::string pkgName = (const char *)IpcIoPopString(&req, nullptr); + std::string deviceId = (const char *)IpcIoPopString(&req, nullptr); + + int32_t ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId); IpcIoPushInt32(&reply, ret); } -ON_IPC_SERVER_CMD(SERVER_GET_AUTHENTCATION_INFO, IpcIo &req, IpcIo &reply) +ON_IPC_SERVER_CMD(VERIFY_AUTHENTICATION, IpcIo &req, IpcIo &reply) { - size_t len = 0; - std::string packName = (const char *)IpcIoPopString(&req, &len); - DmAuthParam authParam = {0}; - 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) { - IpcIoPushInt32(&reply, authParam.direction); - IpcIoPushInt32(&reply, authParam.authType); - IpcIoPushInt32(&reply, authParam.pinToken); - DMLOG(DM_LOG_DEBUG, "DeviceManagerStub::is Client so just return direction"); - return; - } - - int32_t appIconLen = authParam.imageinfo.GetAppIconLen(); - int32_t appThumbnailLen = authParam.imageinfo.GetAppThumbnailLen(); - - IpcIoPushInt32(&reply, authParam.direction); - IpcIoPushInt32(&reply, authParam.authType); - IpcIoPushString(&reply, authParam.packageName.c_str()); - IpcIoPushString(&reply, authParam.appName.c_str()); - IpcIoPushString(&reply, authParam.appDescription.c_str()); - IpcIoPushInt32(&reply, authParam.business); - IpcIoPushInt32(&reply, authParam.pincode); - IpcIoPushInt32(&reply, appIconLen); - IpcIoPushInt32(&reply, appThumbnailLen); - - if (appIconLen > 0 && authParam.imageinfo.GetAppIcon() != nullptr) { - IpcIoPushFlatObj(&reply, authParam.imageinfo.GetAppIcon(), appIconLen); - } + LOGI("VerifyAuthentication service listener."); + std::string pkgName = (const char *)IpcIoPopString(&req, nullptr); + std::string authParam = (const char *)IpcIoPopString(&req, nullptr); - if (appThumbnailLen > 0 && authParam.imageinfo.GetAppThumbnail() != nullptr) { - IpcIoPushFlatObj(&reply, authParam.imageinfo.GetAppThumbnail(), appThumbnailLen); - } + int32_t ret = DeviceManagerService::GetInstance().VerifyAuthentication(pkgName, authParam); + IpcIoPushInt32(&reply, ret); } -ON_IPC_SERVER_CMD(SERVER_USER_AUTHORIZATION_OPERATION, IpcIo &req, IpcIo &reply) +ON_IPC_SERVER_CMD(SERVER_USER_AUTH_OPERATION, IpcIo &req, IpcIo &reply) { size_t len = 0; std::string packName = (const char *)IpcIoPopString(&req, &len); int32_t action = IpcIoPopInt32(&reply); - IpcServerAdapter::GetInstance().SetUserOperation(packName, action); - + DeviceManagerService::GetInstance().SetUserOperation(packName, action); IpcIoPushInt32(&reply, action); } -ON_IPC_SET_REQUEST(SERVER_DEVICEMANAGER_FA_NOTIFY, std::shared_ptr pBaseReq, IpcIo& request, - uint8_t *buffer, size_t buffLen) +ON_IPC_SET_REQUEST(SERVER_DEVICE_FA_NOTIFY, std::shared_ptr pBaseReq, IpcIo &request, uint8_t *buffer, + size_t buffLen) { std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); std::string packagname = pReq->GetPkgName(); std::string paramJson = pReq->GetJsonParam(); IpcIoPushString(&request, packagname.c_str()); IpcIoPushString(&request, paramJson.c_str()); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_READ_RESPONSE(SERVER_DEVICEMANAGER_FA_NOTIFY, IpcIo& reply, std::shared_ptr pBaseRsp) +ON_IPC_READ_RESPONSE(SERVER_DEVICE_FA_NOTIFY, IpcIo &request, std::shared_ptr pBaseRsp) { - pBaseRsp->SetErrCode(IpcIoPopInt32(&reply)); - return DEVICEMANAGER_OK; + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DM_OK; } } // 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 index 7fe96002cda0eca59dce719316e55774688f2832..6436427d63ad3694a0f6399efe10acae7693d2b6 100644 --- a/services/devicemanagerservice/src/ipc/lite/ipc_server_listener.cpp +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_listener.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,13 +15,11 @@ #include "ipc_server_listener.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" - +#include "dm_constants.h" +#include "dm_log.h" #include "ipc_cmd_register.h" #include "ipc_def.h" #include "ipc_server_listenermgr.h" -#include "ipc_server_adapter.h" namespace OHOS { namespace DistributedHardware { @@ -38,33 +36,34 @@ void IpcServerListener::CommonSvcToIdentity(CommonSvcId *svcId, SvcIdentity *ide 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; + if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(name, &svcId) != DM_OK) { + LOGE("get identity failed."); + return DM_FAILED; } CommonSvcToIdentity(&svcId, svc); - return DEVICEMANAGER_OK; + return DM_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; + if (GetIdentityByPkgName(pkgName, &svc) != DM_OK) { + LOGE("OnDeviceFound callback get listener failed."); + return DM_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 (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, io, data, MAX_DM_IPC_LEN) != DM_OK) { + LOGD("SetRequest failed cmdCode:%d", cmdCode); + return DM_FAILED; } - if (::SendRequest(nullptr, svc, cmdCode, &io, nullptr, LITEIPC_FLAG_ONEWAY, nullptr) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_DEBUG, "SendRequest failed cmdCode:%d", cmdCode); + + if (::SendRequest(nullptr, svc, cmdCode, &io, nullptr, LITEIPC_FLAG_ONEWAY, nullptr) != DM_OK) { + LOGD("SendRequest failed cmdCode:%d", cmdCode); } - return DEVICEMANAGER_OK; + return DM_OK; } int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) @@ -77,17 +76,17 @@ int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr req, std::string pkgName = kv.first; req->SetPkgName(pkgName); - if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, io, data, MAX_DM_IPC_LEN) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_DEBUG, "SetRequest failed cmdCode:%d", cmdCode); + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, io, data, MAX_DM_IPC_LEN) != DM_OK) { + LOGD("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); + if (::SendRequest(nullptr, svc, cmdCode, &io, nullptr, LITEIPC_FLAG_ONEWAY, nullptr) != DM_OK) { + LOGD("SendRequest failed cmdCode:%d", cmdCode); } } - return DEVICEMANAGER_OK; + return DM_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 index 59aec4fda46252bc63c198880aee84efb89c16a7..c223a0104624c3ee158f423e7353a53562557b98 100644 --- a/services/devicemanagerservice/src/ipc/lite/ipc_server_listenermgr.cpp +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_listenermgr.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,8 +15,8 @@ #include "ipc_server_listenermgr.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" +#include "dm_constants.h" +#include "dm_log.h" namespace OHOS { namespace DistributedHardware { @@ -25,36 +25,36 @@ 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; + LOGE("invalid param"); + return DM_FAILED; } - DMLOG(DM_LOG_INFO, "new listener register:%s", pkgName.c_str()); + LOGI("new listener register:%s", pkgName.c_str()); std::lock_guard autoLock(lock_); dmListenerMap_[pkgName] = *svcId; - return DEVICEMANAGER_OK; + return DM_OK; } int32_t IpcServerListenermgr::GetListenerByPkgName(std::string &pkgName, CommonSvcId *svcId) { if (pkgName == "" || svcId == nullptr) { - DMLOG(DM_LOG_ERROR, "invalid param"); - return DEVICEMANAGER_FAILED; + LOGE("invalid param"); + return DM_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; + LOGE("listener not found for pkg:%s", pkgName.c_str()); + return DM_FAILED; } *svcId = iter->second; - return DEVICEMANAGER_OK; + return DM_OK; } int32_t IpcServerListenermgr::UnregisterListener(std::string &pkgName) { std::lock_guard autoLock(lock_); dmListenerMap_.erase(pkgName); - return DEVICEMANAGER_OK; + return DM_OK; } const std::map &IpcServerListenermgr::GetAllListeners() diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp index 565cfe637ae558a43c313235f94bf6c7b33a6b8a..e4373c2ad2fcc52596c318129d31308bab2a0bf5 100644 --- a/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_main.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -16,35 +16,10 @@ #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 = 2; - - 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(); } diff --git a/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp b/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp index 458164274ab8e5a73a3e5758fe0c086497ca79e0..b6af2d8c8e3567e4a19547543ab92f15c004d78b 100644 --- a/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp +++ b/services/devicemanagerservice/src/ipc/lite/ipc_server_stub.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,27 +15,23 @@ #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_constants.h" +#include "dm_log.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" +#include "iproxy_server.h" +#include "liteipc_adapter.h" +#include "ohos_init.h" +#include "samgr_lite.h" +#include "securec.h" namespace { - const int32_t WAIT_FOR_SERVER = 2; - const int32_t STACK_SIZE = 0x1000; - const int32_t QUEUE_SIZE = 32; -} +const int32_t WAIT_FOR_SERVER = 2; +const int32_t STACK_SIZE = 0x1000; +const int32_t QUEUE_SIZE = 32; +} // namespace using namespace OHOS::DistributedHardware; @@ -55,16 +51,16 @@ static int32_t DeathCb(const IpcContext *context, void *ipcMsg, IpcIo *data, voi (void)ipcMsg; (void)data; if (arg == NULL) { - DMLOG(DM_LOG_ERROR, "package name is NULL."); - return DEVICEMANAGER_INVALID_PARAM; + LOGE("package name is NULL."); + return DM_INVALID_VALUE; } 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."); + if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(pkgName, &svcId) != DM_OK) { + LOGE("not found client by package name."); free(arg); arg = NULL; - return DEVICEMANAGER_FAILED; + return DM_FAILED; } IpcServerListenermgr::GetInstance().UnregisterListener(pkgName); free(arg); @@ -77,18 +73,18 @@ static int32_t DeathCb(const IpcContext *context, void *ipcMsg, IpcIo *data, voi sid.token = svcId.token; sid.cookie = svcId.cookie; UnregisterDeathCallback(sid, svcId.cbId); - return DEVICEMANAGER_OK; + return DM_OK; } int32_t RegisterDeviceManagerListener(IpcIo *req, IpcIo *reply) { - DMLOG(DM_LOG_INFO, "register service listener."); + LOGI("register service listener."); size_t len = 0; uint8_t *name = IpcIoPopString(req, &len); SvcIdentity *svc = IpcIoPopSvc(req); if (name == NULL || svc == NULL || len == 0) { - DMLOG(DM_LOG_ERROR, "get para failed"); - return DEVICEMANAGER_INVALID_PARAM; + LOGE("get para failed"); + return DM_INVALID_VALUE; } CommonSvcId svcId = {0}; @@ -105,13 +101,13 @@ int32_t RegisterDeviceManagerListener(IpcIo *req, IpcIo *reply) #endif char *pkgName = (char *)malloc(len + 1); if (pkgName == NULL) { - DMLOG(DM_LOG_ERROR, "malloc failed!"); - return DEVICEMANAGER_MALLOC_ERROR; + LOGE("malloc failed!"); + return DM_MALLOC_ERROR; } - if (strcpy_s(pkgName, len + 1, (const char *)name) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "strcpy_s failed!"); + if (strcpy_s(pkgName, len + 1, (const char *)name) != DM_OK) { + LOGE("strcpy_s failed!"); free(pkgName); - return DEVICEMANAGER_COPY_FAILED; + return DM_COPY_FAILED; } uint32_t cbId = 0; RegisterDeathCallback(NULL, sid, DeathCb, pkgName, &cbId); @@ -122,20 +118,20 @@ int32_t RegisterDeviceManagerListener(IpcIo *req, IpcIo *reply) int32_t UnRegisterDeviceManagerListener(IpcIo *req, IpcIo *reply) { - DMLOG(DM_LOG_INFO, "unregister service listener."); + LOGI("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; + LOGE("get para failed"); + return DM_FAILED; } CommonSvcId svcId; - if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(pkgName, &svcId) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "not found listener by package name."); - return DEVICEMANAGER_FAILED; + if (IpcServerListenermgr::GetInstance().GetListenerByPkgName(pkgName, &svcId) != DM_OK) { + LOGE("not found listener by package name."); + return DM_FAILED; } int32_t ret = IpcServerListenermgr::GetInstance().UnregisterListener(pkgName); - if (ret == DEVICEMANAGER_OK) { + if (ret == DM_OK) { #ifdef __LINUX__ BinderRelease(svcId.ipcCtx, svcId.handle); #endif @@ -157,7 +153,7 @@ static const char *GetName(Service *service) static BOOL Initialize(Service *service, Identity identity) { if (service == NULL) { - DMLOG(DM_LOG_WARN, "invalid param"); + LOGW("invalid param"); return FALSE; } @@ -169,7 +165,7 @@ static BOOL Initialize(Service *service, Identity identity) static BOOL MessageHandle(Service *service, Request *request) { if ((service == NULL) || (request == NULL)) { - DMLOG(DM_LOG_WARN, "invalid param"); + LOGW("invalid param"); return FALSE; } return TRUE; @@ -182,10 +178,9 @@ static TaskConfig GetTaskConfig(Service *service) return config; } -static int32_t OnRemoteRequest(IServerProxy *iProxy, int32_t funcId, void *origin, - IpcIo *req, IpcIo *reply) +static int32_t OnRemoteRequest(IServerProxy *iProxy, int32_t funcId, void *origin, IpcIo *req, IpcIo *reply) { - DMLOG(DM_LOG_INFO, "Receive funcId:%d", funcId); + LOGI("Receive funcId:%d", funcId); (void)origin; return IpcCmdRegister::GetInstance().OnIpcServerCmd(funcId, *req, *reply); } @@ -199,7 +194,7 @@ static void HOS_SystemInit(void) int32_t IpcServerStubInit(void) { HOS_SystemInit(); - return DEVICEMANAGER_OK; + return DM_OK; } static void DevMgrSvcInit(void) @@ -216,13 +211,13 @@ static void DevMgrSvcInit(void) }; if (!SAMGR_GetInstance()->RegisterService((Service *)&service)) { - DMLOG(DM_LOG_ERROR, "%s, RegisterService failed", DEVICE_MANAGER_SERVICE_NAME); + LOGE("%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); + LOGE("%s, RegisterDefaultFeatureApi failed", DEVICE_MANAGER_SERVICE_NAME); return; } - DMLOG(DM_LOG_INFO, "%s, init success", DEVICE_MANAGER_SERVICE_NAME); + LOGI("%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 index 5d3292e812f630e4b2d7481b4e78c5d00e1e37aa..2a61266b53f6988a4c8f1df2a628f3bd1d931ed2 100644 --- a/services/devicemanagerservice/src/ipc/standard/ipc_cmd_parser.cpp +++ b/services/devicemanagerservice/src/ipc/standard/ipc_cmd_parser.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,20 +13,21 @@ * limitations under the License. */ -#include "constants.h" +#include + +#include "device_manager_service.h" +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" +#include "dm_subscribe_info.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_notify_verify_auth_result_req.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 { @@ -37,24 +38,24 @@ ON_IPC_SET_REQUEST(SERVER_DEVICE_STATE_NOTIFY, std::shared_ptr pBaseReq, int32_t deviceState = pReq->GetDeviceState(); DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); if (!data.WriteString(pkgName)) { - DMLOG(DM_LOG_ERROR, "write pkgName failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write pkgName failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt32(deviceState)) { - DMLOG(DM_LOG_ERROR, "write state failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write state failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteRawData(&deviceInfo, sizeof(DmDeviceInfo))) { - DMLOG(DM_LOG_ERROR, "write deviceInfo failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write deviceInfo failed"); + return DM_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr pBaseReq, MessageParcel &data) @@ -64,24 +65,24 @@ ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr pBaseReq, Messag uint16_t subscribeId = pReq->GetSubscribeId(); DmDeviceInfo deviceInfo = pReq->GetDeviceInfo(); if (!data.WriteString(pkgName)) { - DMLOG(DM_LOG_ERROR, "write pkgName failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write pkgName failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt16(subscribeId)) { - DMLOG(DM_LOG_ERROR, "write subscribeId failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write subscribeId failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteRawData(&deviceInfo, sizeof(DmDeviceInfo))) { - DMLOG(DM_LOG_ERROR, "write deviceInfo failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write deviceInfo failed"); + return DM_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_DEVICE_FOUND, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr pBaseReq, MessageParcel &data) @@ -91,24 +92,24 @@ ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr pBaseReq, Mes 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; + LOGE("write pkgName failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt16(subscribeId)) { - DMLOG(DM_LOG_ERROR, "write subscribeId failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write subscribeId failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write result failed"); + return DM_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_DISCOVER_FINISH, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_SET_REQUEST(SERVER_AUTH_RESULT, std::shared_ptr pBaseReq, MessageParcel &data) @@ -116,90 +117,123 @@ ON_IPC_SET_REQUEST(SERVER_AUTH_RESULT, std::shared_ptr pBaseReq, Message std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); std::string pkgName = pReq->GetPkgName(); std::string deviceId = pReq->GetDeviceId(); - int32_t pinToken = pReq->GetPinToken(); + std::string token = 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; + LOGE("write pkgName failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteString(deviceId)) { - DMLOG(DM_LOG_ERROR, "write deviceId failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write deviceId failed"); + return DM_FLATTEN_OBJECT; } - if (!data.WriteInt32(pinToken)) { - DMLOG(DM_LOG_ERROR, "write pinToken failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + if (!data.WriteString(token)) { + LOGE("write token failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt32(status)) { - DMLOG(DM_LOG_ERROR, "write status failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write status failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt32(reason)) { - DMLOG(DM_LOG_ERROR, "write reason failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write reason failed"); + return DM_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_READ_RESPONSE(SERVER_AUTH_RESULT, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_SET_REQUEST(SERVER_CHECK_AUTH_RESULT, std::shared_ptr pBaseReq, MessageParcel &data) +ON_IPC_SET_REQUEST(SERVER_VERIFY_AUTH_RESULT, std::shared_ptr pBaseReq, MessageParcel &data) { - std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + 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; + LOGE("write pkgName failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteString(deviceId)) { - DMLOG(DM_LOG_ERROR, "write deviceId failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write deviceId failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write result failed"); + return DM_FLATTEN_OBJECT; } if (!data.WriteInt32(flag)) { - DMLOG(DM_LOG_ERROR, "write flag failed"); - return DEVICEMANAGER_FLATTEN_OBJECT; + LOGE("write flag failed"); + return DM_FLATTEN_OBJECT; } - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_READ_RESPONSE(SERVER_CHECK_AUTH_RESULT, MessageParcel &reply, std::shared_ptr pBaseRsp) +ON_IPC_READ_RESPONSE(SERVER_VERIFY_AUTH_RESULT, MessageParcel &reply, std::shared_ptr pBaseRsp) { pBaseRsp->SetErrCode(reply.ReadInt32()); - return DEVICEMANAGER_OK; + return DM_OK; +} + +ON_IPC_SET_REQUEST(SERVER_DEVICE_FA_NOTIFY, std::shared_ptr pBaseReq, MessageParcel &data) +{ + std::shared_ptr pReq = std::static_pointer_cast(pBaseReq); + std::string packagname = pReq->GetPkgName(); + std::string paramJson = pReq->GetJsonParam(); + if (!data.WriteString(packagname)) { + LOGE("write pkgName failed"); + return DM_FLATTEN_OBJECT; + } + if (!data.WriteString(paramJson)) { + LOGE("write paramJson failed"); + return DM_FLATTEN_OBJECT; + } + return DM_OK; +} + +ON_IPC_READ_RESPONSE(SERVER_DEVICE_FA_NOTIFY, MessageParcel &reply, std::shared_ptr pBaseRsp) +{ + pBaseRsp->SetErrCode(reply.ReadInt32()); + return DM_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"); + LOGI("pkgName:%s, extra:%s", pkgName.c_str(), extra.c_str()); + std::vector deviceList; + int32_t result = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); + int32_t infoNum = deviceList.size(); + DmDeviceInfo deviceInfo; + if (!reply.WriteInt32(infoNum)) { + LOGE("write infoNum failed"); + return DM_WRITE_FAILED; + } + if (!deviceList.empty()) { + for (; !deviceList.empty();) { + deviceInfo = deviceList.back(); + deviceList.pop_back(); + + if (!reply.WriteRawData(&deviceInfo, sizeof(DmDeviceInfo))) { + LOGE("write subscribeInfo failed"); + return DM_WRITE_FAILED; + } } - free(info); } if (!reply.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_WRITE_FAILED; + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + LOGI("GET_TRUST_DEVICE_LIST ok pkgName:%s, extra:%s", pkgName.c_str(), extra.c_str()); + return DM_OK; } ON_IPC_CMD(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel &reply) @@ -208,10 +242,10 @@ ON_IPC_CMD(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel 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; + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel &reply) @@ -219,154 +253,183 @@ ON_IPC_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParce 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; + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } ON_IPC_CMD(START_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply) { std::string pkgName = data.ReadString(); + std::string extra = data.ReadString(); DmSubscribeInfo *subscribeInfo = (DmSubscribeInfo *)data.ReadRawData(sizeof(DmSubscribeInfo)); - int32_t result = DEVICEMANAGER_NULLPTR; + int32_t result = DM_POINT_NULL; if (subscribeInfo != nullptr) { - DMLOG(DM_LOG_INFO, "pkgName:%s, subscribeId: %d", pkgName.c_str(), subscribeInfo->subscribeId); - result = IpcServerAdapter::GetInstance().StartDeviceDiscovery(pkgName, *subscribeInfo); + LOGI("pkgName:%s, subscribeId: %d", pkgName.c_str(), subscribeInfo->subscribeId); + result = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, *subscribeInfo, extra); } if (!reply.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_WRITE_FAILED; + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_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); + LOGI("pkgName:%s, subscribeId: %d", pkgName.c_str(), subscribeId); + int32_t result = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); if (!reply.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_WRITE_FAILED; + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_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; + std::string deviceId = data.ReadString(); + int32_t authType = data.ReadInt32(); + int32_t result = DM_OK; + result = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); + LOGE("AuthenticateDevice"); + if (!reply.WriteInt32(result)) { + LOGE("write result failed"); + return DM_WRITE_FAILED; + } + LOGE("AuthenticateDevice %d", result); + return DM_OK; +} + +ON_IPC_CMD(UNAUTHENTICATE_DEVICE, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + std::string deviceId = data.ReadString(); + int32_t result = DM_OK; + LOGI("pkgName:%s, trustedDeviceInfo: %d", pkgName.c_str(), deviceId.c_str()); + result = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId); + if (!reply.WriteInt32(result)) { + LOGE("write result failed"); + return DM_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_CMD(VERIFY_AUTHENTICATION, MessageParcel &data, MessageParcel &reply) +{ + LOGI("ON_IPC_CMD VERIFY_AUTHENTICATION start"); + std::string authPara = data.ReadString(); + int32_t result = DeviceManagerService::GetInstance().VerifyAuthentication(authPara); + if (!reply.WriteInt32(result)) { + LOGE("write result failed"); + return DM_WRITE_FAILED; + } + return DM_OK; +} + +ON_IPC_CMD(GET_LOCAL_DEVICE_INFO, MessageParcel &data, MessageParcel &reply) +{ + DmDeviceInfo localDeviceInfo; + int32_t result = 0; + result = DeviceManagerService::GetInstance().GetLocalDeviceInfo(localDeviceInfo); - DmAppImageInfo imageInfo(appIcon, appIconLen, appThumbnail, appThumbnailLen); - int32_t result = DEVICEMANAGER_OK; + if (!reply.WriteRawData(&localDeviceInfo, sizeof(DmDeviceInfo))) { + LOGE("write subscribeInfo failed"); + } - if (deviceInfo != nullptr) { - result = IpcServerAdapter::GetInstance().AuthenticateDevice(pkgName, *deviceInfo, imageInfo, extra); + if (!reply.WriteInt32(result)) { + LOGE("write result failed"); + return DM_WRITE_FAILED; } + LOGI("localDeviceInfo: %s", localDeviceInfo.deviceId); + return DM_OK; +} + +ON_IPC_CMD(GET_UDID_BY_NETWORK, MessageParcel &data, MessageParcel &reply) +{ + std::string pkgName = data.ReadString(); + std::string netWorkId = data.ReadString(); + std::string udid; + int32_t result = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid); + if (!reply.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_WRITE_FAILED; + LOGE("write result failed"); + return DM_WRITE_FAILED; + } + if (!reply.WriteString(udid)) { + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_CMD(CHECK_AUTHENTICATION, MessageParcel &data, MessageParcel &reply) +ON_IPC_CMD(GET_UUID_BY_NETWORK, MessageParcel &data, MessageParcel &reply) { - std::string authPara = data.ReadString(); - int32_t result = IpcServerAdapter::GetInstance().CheckAuthentication(authPara); + std::string pkgName = data.ReadString(); + std::string netWorkId = data.ReadString(); + std::string uuid; + int32_t result = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid); + if (!reply.WriteInt32(result)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_WRITE_FAILED; + LOGE("write result failed"); + return DM_WRITE_FAILED; + } + if (!reply.WriteString(uuid)) { + LOGE("write result failed"); + return DM_WRITE_FAILED; } - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_CMD(SERVER_GET_AUTHENTCATION_INFO, MessageParcel &data, MessageParcel &reply) +ON_IPC_CMD(SERVER_GET_DMFA_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 ret = DM_OK; + ret = DeviceManagerService::GetInstance().GetFaParam(packName, authParam); 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; + !reply.WriteString(authParam.authToken) || !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)) { + LOGE("write reply failed"); + return DM_IPC_FLATTEN_OBJECT; } 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; + LOGE("write appIcon failed"); + return DM_IPC_FLATTEN_OBJECT; } } - 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; + LOGE("write appThumbnail failed"); + return DM_IPC_FLATTEN_OBJECT; } } - - return DEVICEMANAGER_OK; + return DM_OK; } -ON_IPC_CMD(SERVER_USER_AUTHORIZATION_OPERATION, MessageParcel &data, MessageParcel &reply) +ON_IPC_CMD(SERVER_USER_AUTH_OPERATION, MessageParcel &data, MessageParcel &reply) { std::string packageName = data.ReadString(); int32_t action = data.ReadInt32(); - int result = IpcServerAdapter::GetInstance().SetUserOperation(packageName, action); - + int result = DeviceManagerService::GetInstance().SetUserOperation(packageName, action); if (!reply.WriteInt32(action)) { - DMLOG(DM_LOG_ERROR, "write result failed"); - return DEVICEMANAGER_WRITE_FAILED; + LOGE("write result failed"); + return DM_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 index 6dc1a24c1a77d0a1799f0e00144a46f167aa756d..28dbc5a5fdfcb834f934aa586cb783d97ac4d707 100644 --- a/services/devicemanagerservice/src/ipc/standard/ipc_server_client_proxy.cpp +++ b/services/devicemanagerservice/src/ipc/standard/ipc_server_client_proxy.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,12 +15,11 @@ #include "ipc_server_client_proxy.h" -#include "ipc_types.h" - +#include "dm_constants.h" +#include "dm_log.h" #include "ipc_cmd_register.h" #include "ipc_def.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" +#include "ipc_types.h" namespace OHOS { namespace DistributedHardware { @@ -28,19 +27,18 @@ int32_t IpcServerClientProxy::SendCmd(int32_t cmdCode, std::shared_ptr r { sptr remote = Remote(); if (remote == nullptr) { - DMLOG(DM_LOG_ERROR, "remote service null"); - return DEVICEMANAGER_NULLPTR; + LOGE("remote service null"); + return DM_POINT_NULL; } - MessageParcel data; MessageParcel reply; MessageOption option; - if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data) != DEVICEMANAGER_OK) { - return DEVICEMANAGER_FAILED; + if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, data) != DM_OK) { + return DM_IPC_FAILED; } - if (remote->SendRequest(cmdCode, data, reply, option) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "SendRequest fail, cmd:%d", cmdCode); - return DEVICEMANAGER_IPC_FAILED; + if (remote->SendRequest(cmdCode, data, reply, option) != DM_OK) { + LOGE("SendRequest fail, cmd:%d", cmdCode); + return DM_IPC_FAILED; } return IpcCmdRegister::GetInstance().ReadResponse(cmdCode, reply, rsp); } diff --git a/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp b/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp index e08eaeab59977d4ef3f62d54608e448d65faa969..a77e3dbbba0891a8f8c06d08d4e21a3c3cb98eaa 100644 --- a/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp +++ b/services/devicemanagerservice/src/ipc/standard/ipc_server_listener.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -14,10 +14,10 @@ */ #include "ipc_server_listener.h" -#include "ipc_server_stub.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "ipc_server_stub.h" namespace OHOS { namespace DistributedHardware { @@ -26,8 +26,8 @@ int32_t IpcServerListener::SendRequest(int32_t cmdCode, std::shared_ptr 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; + LOGI("cannot get listener for package:%s.", pkgName.c_str()); + return DM_POINT_NULL; } return listener->SendCmd(cmdCode, req, rsp); } @@ -42,7 +42,7 @@ int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr req, sptr listener = iface_cast(remote); listener->SendCmd(cmdCode, req, rsp); } - return DEVICEMANAGER_OK; + return DM_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 index 7cf317ccdf180528d69eef3bd295c6de6ce65f22..3d32682123a0a8d2270a162f797f60fa06ca1c8b 100644 --- a/services/devicemanagerservice/src/ipc/standard/ipc_server_stub.cpp +++ b/services/devicemanagerservice/src/ipc/standard/ipc_server_stub.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -18,19 +18,18 @@ #include #include +#include "device_manager_impl.h" +#include "device_manager_service.h" +#include "dm_constants.h" +#include "dm_log.h" #include "if_system_ability_manager.h" +#include "ipc_cmd_register.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); @@ -45,13 +44,13 @@ IpcServerStub::IpcServerStub() : SystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGE void IpcServerStub::OnStart() { - DMLOG(DM_LOG_INFO, "IpcServerStub::OnStart start"); + LOGI("IpcServerStub::OnStart start"); if (state_ == ServiceRunningState::STATE_RUNNING) { - DMLOG(DM_LOG_DEBUG, "IpcServerStub has already started."); + LOGD("IpcServerStub has already started."); return; } if (!Init()) { - DMLOG(DM_LOG_ERROR, "failed to init IpcServerStub"); + LOGE("failed to init IpcServerStub"); return; } state_ = ServiceRunningState::STATE_RUNNING; @@ -59,39 +58,33 @@ void IpcServerStub::OnStart() bool IpcServerStub::Init() { - DMLOG(DM_LOG_INFO, "IpcServerStub::Init ready to init."); + LOGI("IpcServerStub::Init ready to init."); if (!registerToService_) { bool ret = Publish(this); if (!ret) { - DMLOG(DM_LOG_ERROR, "IpcServerStub::Init Publish failed!"); + LOGE("IpcServerStub::Init Publish failed!"); return false; } registerToService_ = true; } - - std::thread { - [] { - IpcServerAdapter::GetInstance().ModuleInit(); - } - }.detach(); + std::thread{[] { DeviceManagerService::GetInstance().Init(); }}.detach(); return true; } void IpcServerStub::OnStop() { - DMLOG(DM_LOG_INFO, "IpcServerStub::OnStop ready to stop service."); + LOGI("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) +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; + LOGI("code = %d, flags= %d.", code, option.GetFlags()); + int32_t ret = DM_OK; ret = IpcCmdRegister::GetInstance().OnIpcCmd(code, data, reply); - if (ret == DEVICEMANAGER_IPC_NOT_REGISTER_FUNC) { - DMLOG(DM_LOG_WARN, "unsupport code: %d", code); + if (ret == DM_IPC_NOT_REGISTER_FUNC) { + LOGW("unsupport code: %d", code); return IPCObjectStub::OnRemoteRequest(code, data, reply, option); } return ret; @@ -99,7 +92,7 @@ int32_t IpcServerStub::OnRemoteRequest(uint32_t code, int32_t IpcServerStub::SendCmd(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) { - return DEVICEMANAGER_OK; + return DM_OK; } ServiceRunningState IpcServerStub::QueryServiceState() const @@ -110,55 +103,50 @@ ServiceRunningState IpcServerStub::QueryServiceState() const int32_t IpcServerStub::RegisterDeviceManagerListener(std::string &pkgName, sptr listener) { if (pkgName.empty() || listener == nullptr) { - DMLOG(DM_LOG_ERROR, "Error: parameter invalid"); - return DEVICEMANAGER_NULLPTR; + LOGE("Error: parameter invalid"); + return DM_POINT_NULL; } - - DMLOG(DM_LOG_INFO, "In, pkgName: %s", pkgName.c_str()); + LOGI("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; + LOGI("RegisterDeviceManagerListener: listener already exists"); + return DM_OK; } - sptr appRecipient = sptr(new AppDeathRecipient()); if (!listener->AddDeathRecipient(appRecipient)) { - DMLOG(DM_LOG_ERROR, "RegisterDeviceManagerListener: AddDeathRecipient Failed"); + LOGE("RegisterDeviceManagerListener: AddDeathRecipient Failed"); } dmListener_[pkgName] = listener; appRecipient_[pkgName] = appRecipient; - return DEVICEMANAGER_OK; + return DM_OK; } int32_t IpcServerStub::UnRegisterDeviceManagerListener(std::string &pkgName) { if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "Error: parameter invalid"); - return DEVICEMANAGER_NULLPTR; + LOGE("Error: parameter invalid"); + return DM_POINT_NULL; } - - DMLOG(DM_LOG_INFO, "In, pkgName: %s", pkgName.c_str()); + LOGI("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; + LOGI("UnRegisterDeviceManagerListener: listener not exists"); + return DM_OK; } - auto recipientIter = appRecipient_.find(pkgName); if (recipientIter == appRecipient_.end()) { - DMLOG(DM_LOG_INFO, "UnRegisterDeviceManagerListener: appRecipient not exists"); + LOGI("UnRegisterDeviceManagerListener: appRecipient not exists"); dmListener_.erase(pkgName); - return DEVICEMANAGER_OK; + return DM_OK; } - auto listener = listenerIter->second; auto appRecipient = recipientIter->second; listener->RemoveDeathRecipient(appRecipient); appRecipient_.erase(pkgName); dmListener_.erase(pkgName); - return DEVICEMANAGER_OK; + return DM_OK; } const std::map> &IpcServerStub::GetDmListener() @@ -179,7 +167,7 @@ const sptr IpcServerStub::GetDmListener(std::string pkgName) co void AppDeathRecipient::OnRemoteDied(const wptr &remote) { - DMLOG(DM_LOG_WARN, "AppDeathRecipient: OnRemoteDied"); + LOGW("AppDeathRecipient: OnRemoteDied"); std::map> listeners = IpcServerStub::GetInstance().GetDmListener(); std::string pkgName; for (auto iter : listeners) { @@ -189,10 +177,10 @@ void AppDeathRecipient::OnRemoteDied(const wptr &remote) } } if (pkgName.empty()) { - DMLOG(DM_LOG_ERROR, "AppDeathRecipient: OnRemoteDied, no pkgName matched"); + LOGE("AppDeathRecipient: OnRemoteDied, no pkgName matched"); return; } - DMLOG(DM_LOG_INFO, "AppDeathRecipient: OnRemoteDied for %s", pkgName.c_str()); + LOGI("AppDeathRecipient: OnRemoteDied for %s", pkgName.c_str()); IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName); } } // namespace DistributedHardware diff --git a/services/devicemanagerservice/src/message/msg_codec.cpp b/services/devicemanagerservice/src/message/msg_codec.cpp deleted file mode 100644 index c98d5645add90caa1a750382cc8c59fb8e4bb3aa..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/message/msg_codec.cpp +++ /dev/null @@ -1,113 +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 "msg_codec.h" -#include "device_manager_log.h" -#include "msg_head.h" - -#include "constants.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" - -namespace OHOS { -namespace DistributedHardware { -int32_t MsgCodec::DecodeMsgType(std::string &jsonStr) -{ - nlohmann::json jsonObject = nlohmann::json::parse(jsonStr, nullptr, false); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "DecodeMsgType jsonStr error"); - return DmMsgType::MSG_TYPE_UNKNOWN; - } - MsgHead mMsgHead; - auto msgHeadPtr = mMsgHead.Decode(jsonObject); - if (msgHeadPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "mMsgHead decode error"); - return DEVICEMANAGER_NULLPTR; - } - return msgHeadPtr->GetMsgType(); -} - -std::string MsgCodec::EncodeSyncGroup(std::vector &groupIdList, std::string &deviceId) -{ - nlohmann::json jsonObject; - MsgSyncGroup mMsgSyncGroup(groupIdList, deviceId); - mMsgSyncGroup.Encode(jsonObject); - return jsonObject.dump(); -} - -std::vector MsgCodec::EncodeReqAppAuth(std::string &token, std::string hostPkg, std::string targetPkg, - const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, std::string &extras) -{ - MsgRequestAuth mMsgRequestAuth(token, hostPkg, targetPkg, devReqInfo, imageInfo, extras); - return mMsgRequestAuth.Encode(); -} - -std::string MsgCodec::EncodeAcceptRespAuth(int32_t reply, int64_t requestId, std::string &groupId, - std::string &groupName, std::string &reqDeviceId) -{ - nlohmann::json jsonObject; - MsgResponseAuth mMsgResponseAuth(reply, requestId, groupId, groupName, reqDeviceId); - mMsgResponseAuth.Encode(jsonObject); - return jsonObject.dump(); -} - -std::string MsgCodec::EncodeRefuseRespAuth(int32_t reply, std::string &reqDeviceId) -{ - nlohmann::json jsonObject; - MsgResponseAuth mMsgResponseAuth(reply, reqDeviceId); - mMsgResponseAuth.Encode(jsonObject); - return jsonObject.dump(); -} - -std::shared_ptr MsgCodec::DecodeRequestAuth(std::string &jsonStr, - std::shared_ptr msgRequestAuth) -{ - nlohmann::json jsonObject = nlohmann::json::parse(jsonStr, nullptr, false); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "DecodeRequestAuth jsonStr error"); - return nullptr; - } - return MsgRequestAuth::Decode(jsonObject, msgRequestAuth); -} - -std::shared_ptr MsgCodec::DecodeResponseAuth(std::string &jsonStr) -{ - nlohmann::json jsonObject = nlohmann::json::parse(jsonStr, nullptr, false); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "DecodeResponseAuth jsonStr error"); - return nullptr; - } - std::shared_ptr msgResponseAuthPtr = std::make_shared(); - if (msgResponseAuthPtr->Decode(jsonObject) == 0) { - return msgResponseAuthPtr; - } - return nullptr; -} - -std::shared_ptr MsgCodec::DecodeSyncGroup(std::string &jsonStr) -{ - nlohmann::json jsonObject = nlohmann::json::parse(jsonStr, nullptr, false); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "DecodeSyncGroup jsonStr error"); - return nullptr; - } - std::shared_ptr msgSyncGroupPtr = std::make_shared(); - if (msgSyncGroupPtr->Decode(jsonObject) == 0) { - return msgSyncGroupPtr; - } - return nullptr; -} -} -} diff --git a/services/devicemanagerservice/src/message/msg_head.cpp b/services/devicemanagerservice/src/message/msg_head.cpp deleted file mode 100644 index 77cc84416a7a62afcf911a6f551931a1ce71499b..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/message/msg_head.cpp +++ /dev/null @@ -1,52 +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 "msg_head.h" -#include "device_manager_log.h" -#include "constants.h" - -namespace OHOS { -namespace DistributedHardware { -void MsgHead::Encode(nlohmann::json &json) -{ - json[TAG_VER] = DM_ITF_VER; - json[TAG_TYPE] = mMsgType_; -} - -std::shared_ptr MsgHead::Decode(nlohmann::json &json) -{ - if (json.contains(TAG_TYPE) == false || json.contains(TAG_VER) == false) { - DMLOG(DM_LOG_ERROR, "err json string"); - return nullptr; - } - - auto msgHeadPtr = std::make_shared(); - msgHeadPtr->mItfVer_ = json[TAG_VER]; - - if (DM_ITF_VER.compare(msgHeadPtr->mItfVer_) == 0) { - msgHeadPtr->mMsgType_ = json[TAG_TYPE]; - } else { - DMLOG(DM_LOG_ERROR, "msg head version mismatch"); - msgHeadPtr->mMsgType_ = DmMsgType::MSG_TYPE_UNKNOWN; - } - return msgHeadPtr; -} - -int32_t MsgHead::GetMsgType() -{ - return mMsgType_; -} -} -} \ No newline at end of file diff --git a/services/devicemanagerservice/src/message/msg_request_auth.cpp b/services/devicemanagerservice/src/message/msg_request_auth.cpp deleted file mode 100644 index d902d86fa4eb0e836dc9e9e7e9357bf81db8f3fc..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/message/msg_request_auth.cpp +++ /dev/null @@ -1,381 +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 -#include - -#include "device_manager_log.h" -#include "constants.h" -#include "encrypt_utils.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" -#include "encrypt_utils.h" -#include "msg_request_auth.h" -#include "parameter.h" -#include "softbus_session.h" -#include "softbus_bus_center.h" -#include "msg_request_auth.h" - -namespace OHOS { -namespace DistributedHardware { -MsgRequestAuth::MsgRequestAuth(std::string &token, std::string hostPkgName, std::string targetPkgName, - const int32_t groupVisibility, const DmDeviceInfo& devReqInfo, const DmAppImageInfo &imageInfo, - std::string &extras) -{ - DMLOG(DM_LOG_INFO, "MsgRequestAuth construction started"); - nlohmann::json jsonObject = nlohmann::json::parse(extras, nullptr, false); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "MsgRequestAuth error"); - return; - } - if (!jsonObject.contains(APP_NAME_KEY) || !jsonObject.contains(APP_DESCRIPTION_KEY)) { - DMLOG(DM_LOG_ERROR, "MsgRequestAuth, err json string"); - return; - } - - mAuthType_ = jsonObject.contains(AUTH_TYPE) ? (int32_t)jsonObject[AUTH_TYPE] : AUTH_TYPE_QR; - mHead_ = std::make_shared((mAuthType_ == AUTH_TYPE_QR) ? (DmMsgType::MSG_TYPE_REQ_AUTH) : - (DmMsgType::MSG_TYPE_AUTH_BY_PIN)); - std::string deviceManagerPkgName = "ohos.distributedhardware.devicemanager"; - NodeBasicInfo localBasicInfo; - int32_t ret = GetLocalNodeDeviceInfo(deviceManagerPkgName.c_str(), &localBasicInfo); - if (ret != 0) { - DMLOG(DM_LOG_ERROR, "GetLocalNodeDeviceInfo err: %d", ret); - return; - } - mDeviceName_ = localBasicInfo.deviceName; - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - mDeviceId_ = localDeviceId; - mToken_ = token; - mHostPkg_ = hostPkgName; - mTargetPkg_ = targetPkgName; - mGroupVisibility_ = groupVisibility; - mAppName_ = jsonObject[APP_NAME_KEY]; - mAppDescription_ = jsonObject[APP_DESCRIPTION_KEY]; - mImageInfo_ = imageInfo; - mThumbnailSize_ = mImageInfo_.GetAppThumbnailLen(); - mAppIconSize_ = mImageInfo_.GetAppIconLen(); - mDeviceType_ = ToHexString(localBasicInfo.deviceTypeId); - DMLOG(DM_LOG_INFO, "MsgRequestAuth construction completed"); -} - -int32_t MsgRequestAuth::GetEncodedAppInfo(const uint8_t *dataSrc, int32_t srcLen, std::string &outString) -{ - DMLOG(DM_LOG_INFO, "MsgRequestAuth GetEncodedAppInfo started"); - if (srcLen <= 0 || dataSrc == nullptr) { - DMLOG(DM_LOG_ERROR, "data string is empty"); - return DEVICEMANAGER_OK; - } - - int32_t tempBufLen = ((srcLen / BASE64_BYTE_LEN_3) + 1) * BASE64_BYTE_LEN_4 + 1; - char *tmpBuf = (char *)calloc(sizeof(char), tempBufLen); - if (tmpBuf == nullptr) { - DMLOG(DM_LOG_ERROR, "getEncodedAppInfoString: malloc mem error, size %d", tempBufLen); - return DEVICEMANAGER_MALLOC_ERROR; - } - - size_t outLen = 0; - int32_t ret = EncryptUtils::MbedtlsBase64Encode((uint8_t *)tmpBuf, tempBufLen, &outLen, dataSrc, (size_t)srcLen); - if (ret != 0) { - DMLOG(DM_LOG_ERROR, "MbedtlsBase64Encode error"); - free(tmpBuf); - return ENCODE_DATA_ERROR; - } - outString = tmpBuf; - free(tmpBuf); - tmpBuf = nullptr; - DMLOG(DM_LOG_INFO, "MsgRequestAuth GetEncodedAppInfo completed"); - return DEVICEMANAGER_OK; -} - -void MsgRequestAuth::GetDecodeAppInfo(const std::string appString, uint8_t **outBuffer, int32_t &outBufferLen) -{ - DMLOG(DM_LOG_INFO, "MsgRequestAuth GetDecodeAppInfo started"); - int32_t tempBufLen = appString.length() + 1; - uint8_t *buffer = (uint8_t *)calloc(sizeof(char), tempBufLen); - if (buffer == nullptr) { - DMLOG(DM_LOG_ERROR, "GetDecodeAppInfo: malloc mem error, tempBufLen %d", tempBufLen); - return; - } - - size_t outLen = 0; - int32_t ret = EncryptUtils::MbedtlsBase64Decode(buffer, tempBufLen, &outLen, - (const uint8_t*)appString.c_str(), appString.length()); - if (ret != 0 || static_cast(outLen) > tempBufLen) { - DMLOG(DM_LOG_ERROR, "MbedtlsBase64Decode failed, ret %d, outLen %d, tempBufLen %d", - ret, outLen, tempBufLen); - outBufferLen = 0; - *outBuffer = nullptr; - free(buffer); - return; - } - - DMLOG(DM_LOG_INFO, "MsgRequestAuth GetDecodeAppInfo outBufferLen %d", outBufferLen); - outBufferLen = outLen; - *outBuffer = buffer; -} - -std::string MsgRequestAuth::EncodeDevInfo() -{ - DMLOG(DM_LOG_INFO, "MsgRequestAuth EncodeDevInfo started"); - nlohmann::json jsonObj; - mHead_->Encode(jsonObj); - jsonObj[TAG_SLICE_NUM] = mMsgSlice_; - jsonObj[TAG_INDEX] = 0; - jsonObj[TAG_REQUESTER] = mDeviceName_; - jsonObj[TAG_DEVICE_ID] = mDeviceId_; - jsonObj[TAG_DEVICE_TYPE] = mDeviceType_; - jsonObj[TAG_TOKEN] = mToken_; - jsonObj[TAG_VISIBILITY] = mGroupVisibility_; - if (mGroupVisibility_ == GROUP_VISIBILITY_IS_PRIVATE) { - jsonObj[TAG_TARGET] = mTargetPkg_; - jsonObj[TAG_HOST] = mHostPkg_; - } - jsonObj[TAG_APP_NAME] = mAppName_; - jsonObj[TAG_APP_DESCRIPTION] = mAppDescription_; - - std::string appIconStr = ""; - GetEncodedAppInfo(mImageInfo_.GetAppIcon(), mImageInfo_.GetAppIconLen(), appIconStr); - jsonObj[TAG_APP_ICON] = appIconStr; - jsonObj[TAG_THUMBNAIL_SIZE] = mThumbnailSize_; - jsonObj[TAG_AUTH_TYPE] = mAuthType_; - DMLOG(DM_LOG_INFO, "MsgRequestAuth EncodeDevInfo completed"); - return jsonObj.dump(); -} - -void MsgRequestAuth::DecodeDeviceInfo(nlohmann::json &json, std::shared_ptr msg) -{ - msg->mDeviceName_ = json[TAG_REQUESTER]; - msg->mDeviceId_ = json[TAG_DEVICE_ID]; - msg->mDeviceType_ = json[TAG_DEVICE_TYPE]; - msg->mToken_ = json[TAG_TOKEN]; - msg->mGroupVisibility_ = json[TAG_VISIBILITY]; - if (msg->mGroupVisibility_ == GROUP_VISIBILITY_IS_PRIVATE) { - msg->mTargetPkg_ = json[TAG_TARGET]; - msg->mHostPkg_ = json[TAG_HOST]; - } - msg->mAppName_ = json[TAG_APP_NAME]; - msg->mAppDescription_ = json[TAG_APP_DESCRIPTION]; - - const std::string iconStr = json[TAG_APP_ICON]; - uint8_t *appIcon = nullptr; - int32_t appIconLen = 0; - msg->GetDecodeAppInfo(iconStr, &appIcon, appIconLen); - if (appIcon != nullptr) { - msg->mImageInfo_.ResetIcon(appIcon, appIconLen); - free(appIcon); - } - - SetThumbnailSize(json, msg); - msg->mAuthType_ = json[TAG_AUTH_TYPE]; -} - -std::vector MsgRequestAuth::Encode() -{ - DMLOG(DM_LOG_INFO, "MsgRequestAuth encode started"); - std::vector jsonStrs; - int32_t thumbnailSlice = - ((mThumbnailSize_ / MSG_MAX_SIZE) + (mThumbnailSize_ % MSG_MAX_SIZE) == 0 ? 0 : 1); - mMsgSlice_ = thumbnailSlice + 1; - jsonStrs.push_back(EncodeDevInfo()); - for (int32_t idx = 0; idx < thumbnailSlice; idx++) { - nlohmann::json jsonObj; - mHead_->Encode(jsonObj); - jsonObj[TAG_SLICE_NUM] = mMsgSlice_; - jsonObj[TAG_INDEX] = idx + 1; - jsonObj[TAG_DEVICE_ID] = mDeviceId_; - jsonObj[TAG_THUMBNAIL_SIZE] = mThumbnailSize_; - - // frag thumbnail by 45KB - std::string thumbnailStr = ""; - int32_t leftLen = mImageInfo_.GetAppThumbnailLen() - idx * MSG_MAX_SIZE; - int32_t sliceLen = (leftLen > MSG_MAX_SIZE) ? MSG_MAX_SIZE : leftLen; - - DMLOG(DM_LOG_INFO, "TAG_APP_THUMBNAIL encode, idx %d, encodeLen %d, mThumbnailSize_ %d", - idx, sliceLen, mThumbnailSize_); - - const uint8_t *thumbnail = mImageInfo_.GetAppThumbnail(); - GetEncodedAppInfo(thumbnail + idx * MSG_MAX_SIZE, sliceLen, thumbnailStr); - jsonObj[TAG_APP_THUMBNAIL] = thumbnailStr; - - jsonStrs.push_back(jsonObj.dump()); - } - DMLOG(DM_LOG_INFO, "MsgRequestAuth encode completed"); - return jsonStrs; -} - -std::shared_ptr MsgRequestAuth::Decode(nlohmann::json &json, std::shared_ptr msgIn) -{ - if (!json.contains(TAG_INDEX) || !json.contains(TAG_DEVICE_ID) || !json.contains(TAG_SLICE_NUM)) { - DMLOG(DM_LOG_ERROR, "err json string, first time"); - return nullptr; - } - int32_t idx = json[TAG_INDEX]; - std::string deviceId = json[TAG_DEVICE_ID]; - if (!IsMsgValid(msgIn, json, deviceId, idx)) { - auto inValidMsg = std::make_shared(); - inValidMsg->mMsgSlice_ = FAIL; - return inValidMsg; - } - - std::shared_ptr msg = msgIn; - if (msgIn == nullptr || msgIn->mMsgCnt_ == msgIn->mMsgSlice_) { - msg = std::make_shared(); - } - msg->mHead_ = MsgHead::Decode(json); - msg->mMsgSlice_ = json[TAG_SLICE_NUM]; - if (idx == 0) { - DecodeDeviceInfo(json, msg); - } else { - SetThumbnailSize(json, msg); - msg->mDeviceId_ = deviceId; - if (!json.contains(TAG_APP_THUMBNAIL)) { - DMLOG(DM_LOG_ERROR, "err json string, TAG_APP_THUMBNAIL not exit"); - return nullptr; - } - - std::string thumbnailStr = json[TAG_APP_THUMBNAIL]; - uint8_t *thumbnail = nullptr; - int32_t thumbnailLen = 0; - msg->GetDecodeAppInfo(thumbnailStr, &thumbnail, thumbnailLen); - if (thumbnail == nullptr) { - DMLOG(DM_LOG_ERROR, "TAG_APP_THUMBNAIL Decode error"); - return nullptr; - } - - DMLOG(DM_LOG_INFO, "TAG_APP_THUMBNAIL decode, idx %d, decodeLen %d, mThumbnailSize_ %d", - idx, thumbnailLen, msg->mThumbnailSize_); - if (msg->mThumbnailSize_ < thumbnailLen + (idx - 1) * MSG_MAX_SIZE) { - auto inValidReqMsg = std::make_shared(); - inValidReqMsg->mMsgSlice_ = FAIL; - free(thumbnail); - return inValidReqMsg; - } - msg->mImageInfo_.SetThumbnailData(thumbnail, thumbnailLen, (idx - 1) * MSG_MAX_SIZE, thumbnailLen); - free(thumbnail); - } - msg->mMsgCnt_++; - return msg; -} - -int32_t MsgRequestAuth::GetMsgSlice() -{ - return mMsgSlice_; -} - -int32_t MsgRequestAuth::GetMsgCnt() -{ - return mMsgCnt_; -} - -std::string MsgRequestAuth::GetRequestDeviceId() -{ - return mDeviceId_; -} - -bool MsgRequestAuth::IsMsgValid(std::shared_ptr msgIn, nlohmann::json &json, - std::string &deviceId, int32_t index) -{ - if (msgIn != nullptr && msgIn->mMsgCnt_ != msgIn->mMsgSlice_ && deviceId.compare(msgIn->mDeviceId_)) { - DMLOG(DM_LOG_ERROR, "IsMsgValid, msgIn error"); - return false; - } - - if (!json.contains(TAG_THUMBNAIL_SIZE)) { - DMLOG(DM_LOG_ERROR, "IsMsgValid, err json string"); - return false; - } - - if (index < 0 || index >= DES_SLICE_MAX_NUM) { - DMLOG(DM_LOG_ERROR, "index err"); - return false; - } - - if (index == 0) { - return IsAppInfoValid(json); - } else { - int32_t thumbnailSlice = json[TAG_THUMBNAIL_SIZE]; - if (thumbnailSlice > THUMB_MAX_LEN || thumbnailSlice < 0) { - DMLOG(DM_LOG_ERROR, "IsMsgValid, thumbnailSlice error"); - return false; - } - } - return true; -} - -bool MsgRequestAuth::IsAppInfoValid(nlohmann::json &json) -{ - if (!json.contains(TAG_REQUESTER) || !json.contains(TAG_DEVICE_TYPE) || !json.contains(TAG_TOKEN) || - !json.contains(TAG_VISIBILITY) || !json.contains(TAG_APP_NAME) || !json.contains(TAG_APP_DESCRIPTION) || - !json.contains(TAG_APP_ICON) || !json.contains(TAG_AUTH_TYPE) || !json.contains(TAG_DEVICE_ID)) { - DMLOG(DM_LOG_ERROR, "IsAppInfoValid:: err json string"); - return false; - } - - int32_t groupVisibility = json[TAG_VISIBILITY]; - if (groupVisibility == GROUP_VISIBILITY_IS_PRIVATE) { - if (!json.contains(TAG_TARGET) || !json.contains(TAG_HOST)) { - DMLOG(DM_LOG_ERROR, "IsAppInfoValid:: err json string, TAG_TARGET or TAG_HOST not contain"); - return false; - } - } - - if (json[TAG_APP_ICON].size() > ICON_MAX_LEN) { - DMLOG(DM_LOG_ERROR, "IsAppInfoValid, appIcon size error"); - return false; - } - - int32_t thumbnailSize = json[TAG_THUMBNAIL_SIZE]; - if (thumbnailSize > THUMB_MAX_LEN || thumbnailSize < 0) { - DMLOG(DM_LOG_ERROR, "IsAppInfoValid, thumbnailSize error"); - return false; - } - return true; -} - -void MsgRequestAuth::SetAuthType(nlohmann::json &json, std::shared_ptr msg) -{ - int32_t authType = json.contains(TAG_AUTH_TYPE) ? (int32_t)json[TAG_AUTH_TYPE] : AUTH_TYPE_QR; - if (authType != AUTH_TYPE_QR && authType != AUTH_TYPE_PIN) { - authType = AUTH_TYPE_QR; - } - msg->mAuthType_ = authType; -} - -void MsgRequestAuth::SetThumbnailSize(nlohmann::json &json, std::shared_ptr msg) -{ - if (!json.contains(TAG_THUMBNAIL_SIZE)) { - DMLOG(DM_LOG_ERROR, "SetThumbnailSize, err json string"); - return; - } - int32_t thumbnailSlice = json[TAG_THUMBNAIL_SIZE]; - if (msg->mThumbnailSize_ == 0) { - msg->mImageInfo_.InitThumbnail(thumbnailSlice); - msg->mThumbnailSize_ = msg->mImageInfo_.GetAppThumbnailLen(); - DMLOG(DM_LOG_INFO, "thumbnailSlice %d, mThumbnailSize_ is, %d", thumbnailSlice, msg->mThumbnailSize_); - } -} - -std::string MsgRequestAuth::ToHexString(int32_t value) -{ - std::stringstream ioss; - std::string tmpStr; - ioss << std::setiosflags(std::ios::uppercase) << std::hex << value; - ioss >> tmpStr; - return tmpStr; -} -} -} diff --git a/services/devicemanagerservice/src/message/msg_response_auth.cpp b/services/devicemanagerservice/src/message/msg_response_auth.cpp deleted file mode 100644 index b1b18492b885418bd463070c82bd1a2b5df5d4b9..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/message/msg_response_auth.cpp +++ /dev/null @@ -1,160 +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 "msg_response_auth.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" -#include "constants.h" -#include "parameter.h" -#include "hichain_connector.h" -#include "anonymous_string.h" - -namespace OHOS { -namespace DistributedHardware { -MsgResponseAuth::MsgResponseAuth(int32_t reply, std::string &reqDeviceId) -{ - mHead_ = std::make_shared(MSG_TYPE_RESP_AUTH); - mReply_ = reply; - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - mDeviceId_ = localDeviceId; - std::vector groupList; - HichainConnector::GetInstance().GetRelatedGroups(reqDeviceId, groupList); - HichainConnector::GetInstance().GetSyncGroupList(groupList, mSyncGroupList_); -} - -MsgResponseAuth::MsgResponseAuth(int32_t reply, int64_t requestId, std::string &groupId, std::string &groupName, - std::string &reqDeviceId) -{ - mHead_ = std::make_shared(MSG_TYPE_RESP_AUTH); - mReply_ = reply; - mNetId_ = ""; - mGroupId_ = groupId; - mGroupName_ = groupName; - mRequestId_ = requestId; - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - mDeviceId_ = localDeviceId; - std::vector groupList; - HichainConnector::GetInstance().GetRelatedGroups(reqDeviceId, groupList); - HichainConnector::GetInstance().GetSyncGroupList(groupList, mSyncGroupList_); -} - -void MsgResponseAuth::Encode(nlohmann::json &jsonObj) -{ - DMLOG(DM_LOG_INFO, "MsgResponseAuth encode started"); - mHead_->Encode(jsonObj); - jsonObj[TAG_REPLY] = mReply_; - jsonObj[TAG_DEVICE_ID] = mDeviceId_; - jsonObj[TAG_GROUPIDS] = mSyncGroupList_; - if (mReply_ == SESSION_REPLY_ACCEPT) { - jsonObj[TAG_NET_ID] = mNetId_; - jsonObj[TAG_REQUEST_ID] = mRequestId_; - jsonObj[TAG_GROUP_ID] = mGroupId_; - jsonObj[TAG_GROUP_NAME] = mGroupName_; - DMLOG(DM_LOG_INFO, "MsgResponseAuth encode completed"); - } - DMLOG(DM_LOG_INFO, "encode mReply_ is : %d", mReply_); - DMLOG(DM_LOG_INFO, "encode deviceId is : %s", GetAnonyString(mDeviceId_).c_str()); - DMLOG(DM_LOG_INFO, "encode netId is : %s", GetAnonyString(mNetId_).c_str()); - DMLOG(DM_LOG_INFO, "encode mGroupId_ is %s", GetAnonyString(mGroupId_).c_str()); - DMLOG(DM_LOG_INFO, "encode mGroupName_ is %s", mGroupName_.c_str()); - DMLOG(DM_LOG_INFO, "encode mRequestId_ is %d", mRequestId_); -} - -int32_t MsgResponseAuth::Decode(nlohmann::json &jsonObj) -{ - DMLOG(DM_LOG_INFO, "MsgResponseAuth decode started"); - if (!jsonObj.contains(TAG_REPLY) || !jsonObj.contains(TAG_DEVICE_ID) || !jsonObj.contains(TAG_GROUPIDS)) { - DMLOG(DM_LOG_ERROR, "MsgResponseAuth::decode, err json string, first time"); - return MSG_DECODE_PARA_FAILED; - } - - MsgHead msgHead; - mHead_ = msgHead.Decode(jsonObj); - mReply_ = jsonObj[TAG_REPLY]; - mDeviceId_ = jsonObj[TAG_DEVICE_ID]; - std::vector groupList = jsonObj[TAG_GROUPIDS]; - for (auto str : groupList) { - mSyncGroupList_.push_back(str); - } - - if (mReply_ == SESSION_REPLY_ACCEPT) { - if (!jsonObj.contains(TAG_NET_ID) || !jsonObj.contains(TAG_GROUP_ID) || !jsonObj.contains(TAG_GROUP_NAME) || - !jsonObj.contains(TAG_REQUEST_ID)) { - DMLOG(DM_LOG_ERROR, "MsgResponseAuth::decode, err json string, second time"); - return MSG_DECODE_PARA_FAILED; - } - mNetId_ = jsonObj[TAG_NET_ID]; - mGroupId_ = jsonObj[TAG_GROUP_ID]; - mGroupName_ = jsonObj[TAG_GROUP_NAME]; - mRequestId_ = jsonObj[TAG_REQUEST_ID]; - } - DMLOG(DM_LOG_INFO, "decode mReply_ is : %d", mReply_); - DMLOG(DM_LOG_INFO, "decode mGroupId_ is %s", GetAnonyString(mGroupId_).c_str()); - DMLOG(DM_LOG_INFO, "decode mGroupName_ is %s", GetAnonyString(mGroupName_).c_str()); - DMLOG(DM_LOG_INFO, "decode deviceId is : %s", GetAnonyString(mDeviceId_).c_str()); - DMLOG(DM_LOG_INFO, "decode netId is : %s", GetAnonyString(mNetId_).c_str()); - DMLOG(DM_LOG_INFO, "decode mRequestId_ is %d", mRequestId_); - DMLOG(DM_LOG_INFO, "MsgResponseAuth decode completed"); - return DEVICEMANAGER_OK; -} - -int32_t MsgResponseAuth::GetReply() -{ - return mReply_; -} - -std::string MsgResponseAuth::GetNetId() -{ - return mNetId_; -} - -std::string MsgResponseAuth::GetGroupId() -{ - return mGroupId_; -} - -std::string MsgResponseAuth::GetDeviceId() -{ - return mDeviceId_; -} - -std::string MsgResponseAuth::GetGroupName() -{ - return mGroupName_; -} - -int64_t MsgResponseAuth::GetRequestId() -{ - return mRequestId_; -} - -std::vector MsgResponseAuth::GetSyncGroupList() -{ - return mSyncGroupList_; -} - -int32_t MsgResponseAuth::GetPinCode() -{ - return mPinCode_; -} - -void MsgResponseAuth::SavePinCode(int32_t pinCode) -{ - mPinCode_ = pinCode; -} -} -} diff --git a/services/devicemanagerservice/src/message/msg_sync_group.cpp b/services/devicemanagerservice/src/message/msg_sync_group.cpp deleted file mode 100644 index 5ccb56be96db262b5d93ea18b54a03fb33a0d751..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/message/msg_sync_group.cpp +++ /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. - */ - -#include "msg_sync_group.h" -#include "device_manager_log.h" -#include "constants.h" -#include "device_manager_errno.h" - -namespace OHOS { -namespace DistributedHardware { -MsgSyncGroup::MsgSyncGroup(std::vector &groupList, std::string &deviceId) -{ - DMLOG(DM_LOG_INFO, "MsgSyncGroup construction started"); - mHead_ = std::make_shared(DmMsgType::MSG_TYPE_SYNC_GROUP); - for (auto str: groupList) { - mGroupIdList_.push_back(str); - } - mDeviceId_ = deviceId; - DMLOG(DM_LOG_INFO, "MsgSyncGroup construction completed"); -} - -void MsgSyncGroup::Encode(nlohmann::json &json) -{ - mHead_->Encode(json); - json[TAG_DEVICE_ID] = mDeviceId_; - json[TAG_GROUPIDS] = mGroupIdList_; -} - -int32_t MsgSyncGroup::Decode(nlohmann::json &json) -{ - DMLOG(DM_LOG_INFO, "MsgSyncGroup decode started"); - if (!json.contains(TAG_DEVICE_ID) || !json.contains(TAG_GROUPIDS)) { - DMLOG(DM_LOG_ERROR, "MsgSyncGroup::decode err "); - return MSG_DECODE_PARA_FAILED; - } - - MsgHead msgHead; - mHead_ = msgHead.Decode(json); - mDeviceId_ = json[TAG_DEVICE_ID]; - mGroupIdList_ = json.at(TAG_GROUPIDS).get>(); - DMLOG(DM_LOG_INFO, "MsgSyncGroup decode completed"); - return DEVICEMANAGER_OK; -} - -std::string MsgSyncGroup::GetDeviceId() -{ - return mDeviceId_; -} - -std::vector MsgSyncGroup::GetGroupIdList() -{ - return mGroupIdList_; -} -} -} \ No newline at end of file diff --git a/services/devicemanagerservice/src/requestauth/auth_manager.cpp b/services/devicemanagerservice/src/requestauth/auth_manager.cpp deleted file mode 100644 index 82f7fb091f87dd1d969d20c4c6cb7cb3f3044f30..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/requestauth/auth_manager.cpp +++ /dev/null @@ -1,288 +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 "auth_manager.h" -#include "anonymous_string.h" -#include "dm_ability_manager.h" -#include "constants.h" -#include "msg_codec.h" -#include "device_manager_log.h" -#include "msg_codec.h" -#include "device_manager_errno.h" -#include "softbus_session.h" -#include "encrypt_utils.h" -#include "ipc_server_listener_adapter.h" -#include "msg_sync_group.h" - -namespace OHOS { -namespace DistributedHardware { -IMPLEMENT_SINGLE_INSTANCE(AuthManager); - -void AuthManager::AuthDeviceGroup(std::string &hostPkgName, const DmDeviceInfo &devReqInfo, - const DmAppImageInfo &imageInfo, std::string &extras) -{ - AuthAppGroup(hostPkgName, devReqInfo, imageInfo, extras); -} - -void AuthManager::OnReceiveMsg(long long channelId, std::string &message) -{ - int32_t msgType = MsgCodec::DecodeMsgType(message); - DMLOG(DM_LOG_INFO, "message type is, %d", msgType); - switch (msgType) { - case MSG_TYPE_RESP_AUTH: - case MSG_TYPE_REQ_AUTH: - case MSG_TYPE_AUTH_BY_PIN: - OnReceiveMessage(channelId, message, msgType); - break; - case MSG_TYPE_SYNC_GROUP: - SyncDmPrivateGroup(message); - break; - default: - DMLOG(DM_LOG_INFO, "msgType not support yet, msgType: %d", msgType); - break; - } -} - -void AuthManager::AuthAppGroup(std::string &hostPkgName, const DmDeviceInfo &devReqInfo, - const DmAppImageInfo &imageInfo, std::string &extrasJson) -{ - DMLOG(DM_LOG_INFO, "AuthManager::AuthAppGroup started"); - nlohmann::json jsonObject = nlohmann::json::parse(extrasJson, nullptr, false); - if (jsonObject.is_discarded()) { - DMLOG(DM_LOG_ERROR, "extrasJson error"); - return; - } - if (!jsonObject.contains(AUTH_TYPE)) { - DMLOG(DM_LOG_ERROR, "AuthAppGroup extrasJson error"); - return; - } - if (!jsonObject.contains(TARGET_PKG_NAME_KEY)) { - DMLOG(DM_LOG_ERROR, "TARGET_PKG_NAME is not in extrasJson"); - return; - } - std::string targetPkgName = jsonObject[TARGET_PKG_NAME_KEY]; - - if (!jsonObject.contains(DISPLAY_OWNER)) { - DMLOG(DM_LOG_WARN, "AuthAppGroup DISPLAY_OWNER error"); - displayOwner_ = DISPLAY_OWNER_SYSTEM; - } else { - displayOwner_ = jsonObject[DISPLAY_OWNER]; - } - - if (!CanStartNewSession()) { - DMLOG(DM_LOG_ERROR, "previous session not completed yet"); - mPendingReqSessionPtr_->NotifyHostAppAuthResult(ERROR_DUPLICATE_REQUEST); - return; - } - auto curSessionPtr = std::make_shared(hostPkgName, targetPkgName, devReqInfo, imageInfo); - mPendingReqSessionPtr_ = curSessionPtr; - std::vector msgInfo = curSessionPtr->GetRequestCommand(extrasJson); - int32_t channelId = SoftbusSession::GetInstance().SendMessages(devReqInfo.deviceId, msgInfo); - if (channelId > 0) { - DMLOG(DM_LOG_INFO, "open channel succeed, save channelId"); - mPendingReqSessionPtr_->SetChannelId(channelId); - return; - } - DMLOG(DM_LOG_ERROR, "open channel failed, close this session"); - mPendingReqSessionPtr_->Release(); - mPendingReqSessionPtr_->NotifyHostAppAuthResult(ERROR_START_REMOTE_DM); - mPendingReqSessionPtr_ = nullptr; -} - -bool AuthManager::CanStartNewSession() -{ - if (mPendingReqSessionPtr_ == nullptr || mPendingReqSessionPtr_->IsFinished()) { - return true; - } - return false; -} - -void AuthManager::OnUserOperate(int32_t action) -{ - if (action == FaAction::USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT) { - if (mPendingReqSessionPtr_ == nullptr) { - DMLOG(DM_LOG_ERROR, "mPendingReqSessionPtr_ not exist"); - return; - } - mPendingReqSessionPtr_->OnUserOperate(action); - return; - } - - if (mPendingRespSessionPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "mPendingRespSessionPtr not exist"); - return; - } - - mPendingRespSessionPtr->OnUserOperate(action); -} - -void AuthManager::OnReceiveMessage(long long channelId, std::string &message, int32_t msgType) -{ - DMLOG(DM_LOG_INFO, "AuthManager::OnReceiveMessage started"); - if (msgType == MSG_TYPE_RESP_AUTH) { - DMLOG(DM_LOG_ERROR, "message type is MSG_TYPE_RESP_AUTH"); - if (mPendingReqSessionPtr_ == nullptr || !mPendingReqSessionPtr_->IsMyChannelId(channelId)) { - DMLOG(DM_LOG_ERROR, "receive error message"); - return; - } - mPendingReqSessionPtr_->OnReceiveMsg(message); - if (mPendingReqSessionPtr_->IsWaitingForScan()) { - DMLOG(DM_LOG_ERROR, "move Session To Wait Scan Map "); - MoveSessionToWaitScanMap(); - } - } else if (msgType == MSG_TYPE_REQ_AUTH || msgType == MSG_TYPE_AUTH_BY_PIN) { - DMLOG(DM_LOG_INFO, "message type is MSG_TYPE_REQ_AUTH"); - if (mPendingRespSessionPtr == nullptr) { - mPendingRespSessionPtr = std::make_shared(); - } - - if (!mPendingRespSessionPtr->IsMyChannelId(channelId)) { - DMLOG(DM_LOG_ERROR, "mPendingRespSessionPtr IsMyChannelId false!"); - return; - } - mPendingRespSessionPtr->OnReceiveMsg(channelId, message); - } else { - DMLOG(DM_LOG_ERROR, "error message type"); - } -} - -void AuthManager::SyncDmPrivateGroup(std::string &message) -{ - std::shared_ptr msgSyncGroupPtr = MsgCodec::DecodeSyncGroup(message); - if (msgSyncGroupPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "decode syncGroup message err"); - return; - } - std::vector groupIdList = msgSyncGroupPtr->GetGroupIdList(); - HichainConnector::GetInstance().SyncGroups(msgSyncGroupPtr->GetDeviceId(), groupIdList); -} - -void AuthManager::MoveSessionToWaitScanMap() -{ - DMLOG(DM_LOG_ERROR, "AuthManager::MoveSessionToWaitScanMap"); - mWaitScanReqSessionMap_[mPendingReqSessionPtr_->GetToken()] = mPendingReqSessionPtr_; - mPendingReqSessionPtr_ = nullptr; -} - -int32_t AuthManager::CheckAuthentication(std::string &authPara) -{ - DMLOG(DM_LOG_INFO, "AuthManager::CheckAuthentication started"); - nlohmann::json authJson = nlohmann::json::parse(authPara, nullptr, false); - if (authJson.is_discarded()) { - DMLOG(DM_LOG_ERROR, "HichainAdapter::GetGroupIdByName parse group info error, json invalid."); - return AUTH_PARA_INVALID; - } - if (!authJson.contains(AUTH_TYPE) || authJson[AUTH_TYPE] != AUTH_TYPE_PIN) { - DMLOG(DM_LOG_ERROR, "error authPara msg"); - return AUTH_PARA_INVALID; - } - DMLOG(DM_LOG_INFO, "PIN Code Auth"); - authParam_ = authPara; - return CheckAuthenticationByPin(authJson); -} - -void AuthManager::NotifyHostOnCheckAuthResult(int64_t requestId, int errorCode) -{ - DMLOG(DM_LOG_INFO, "notify host checkResult, requestId: %lld, errorcode: %d", requestId, errorCode); - for (auto iter = mWaitScanReqSessionMap_.begin(); iter != mWaitScanReqSessionMap_.end(); iter++) { - auto requestSessionPtr = iter->second; - if (requestSessionPtr != nullptr && requestSessionPtr->GetRequestId() == requestId) { - std::string deviceId = requestSessionPtr->GetRequestDeviceId(); - DMLOG(DM_LOG_INFO, "notify host checkResult, deviceId: %s, requestId: %lld", - GetAnonyString(deviceId).c_str(), requestId); - IpcServerListenerAdapter::GetInstance().OnCheckAuthResult(deviceId, errorCode, 0); - return; - } - } - - DMLOG(DM_LOG_ERROR, "notify host checkResult error, requestId: %lld", requestId); -} - -int32_t AuthManager::CheckAuthenticationByPin(nlohmann::json &authJson) -{ - int32_t pinCode = authJson.contains(PIN_CODE_KEY) ? (int32_t)authJson[PIN_CODE_KEY] : DEFAULT_PIN_CODE; - int32_t pinToken = authJson.contains(PIN_TOKEN) ? (int32_t)authJson[PIN_TOKEN] : DEFAULT_PIN_TOKEN; - if (pinCode < MIN_PIN_CODE || pinCode >= (MIN_PIN_CODE + MAX_PIN_CODE)) { - DMLOG(DM_LOG_ERROR, "pinCode err, please check pinCode"); - return PIN_CODE_CHECK_FAILED; - } - - if (pinToken < MIN_PIN_TOKEN || pinToken >= (MIN_PIN_TOKEN + MAX_PIN_TOKEN)) { - DMLOG(DM_LOG_ERROR, "pinToken err, please check pinToken."); - return PIN_TOKEN_CHECK_FAILED; - } - OnPinInputResult(pinCode, pinToken); - DMLOG(DM_LOG_INFO, "CheckAuthenticationByPin authPara end"); - return DEVICEMANAGER_OK; -} - -void AuthManager::OnPinInputResult(int32_t pinCode, int32_t pinToken) -{ - DMLOG(DM_LOG_ERROR, "AuthManager::OnPinInputResult"); - for (auto iter = mWaitScanReqSessionMap_.begin(); iter != mWaitScanReqSessionMap_.end(); iter++) { - auto requestSessionPtr = iter->second; - if (requestSessionPtr != nullptr && requestSessionPtr->IsMyPinToken(pinToken)) { - DMLOG(DM_LOG_INFO, "AuthManager:: OnPinInputResult"); - requestSessionPtr->OnReceivePinCode(pinCode); - } - } -} - -int32_t AuthManager::GetAuthenticationParam(DmAuthParam &authParam) -{ - AbilityRole role = DmAbilityManager::GetInstance().GetAbilityRole(); - DMLOG(DM_LOG_INFO, "GetAuthenticationParam:: role = %d", (int32_t)role); - if (role == AbilityRole::ABILITY_ROLE_INITIATIVE) { - if (mPendingReqSessionPtr_ == nullptr) { - DMLOG(DM_LOG_ERROR, "AuthManager:: Get Auth params FAIL : mPendingReqSessionPtr_(nullptr)"); - return FAIL; - } - authParam.authType = AUTH_TYPE_PIN; // Currently, only Support PinCode, authType not save. - authParam.direction = (int32_t)DmAbilityManager::GetInstance().GetAbilityRole(); - authParam.pinToken = mPendingReqSessionPtr_->GetPinToken(); - DMLOG(DM_LOG_INFO, "GetAuthenticationParam, role is ABILITY_ROLE_INITIATIVE"); - return SUCCESS; - } - - if (mPendingRespSessionPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "AuthManager:: Get Auth params FAIL : mPendingRespSessionPtr(nullptr)"); - return FAIL; - } - - mPendingRespSessionPtr->BuildAuthenticationInfo(authParam); - return SUCCESS; -} - -int32_t AuthManager::GetPincode(int64_t requestId) -{ - if (mPendingRespSessionPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "AuthManager:: GetPincode FAIL : mPendingRespSessionPtr(nullptr)"); - return FAIL; - } - - return mPendingRespSessionPtr->GetPinCodeByReqId(requestId); -} - -std::string AuthManager::GetAuthPara() -{ - return authParam_; -} - -int32_t AuthManager::GetDisplayOwner() -{ - return displayOwner_; -} -} -} diff --git a/services/devicemanagerservice/src/requestauth/request_session.cpp b/services/devicemanagerservice/src/requestauth/request_session.cpp deleted file mode 100644 index 6b46a7fcab417dda9adf2306e34ea67539418856..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/requestauth/request_session.cpp +++ /dev/null @@ -1,258 +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 -#include "nlohmann/json.hpp" - -#include "dm_ability_manager.h" -#include "request_session.h" -#include "constants.h" -#include "device_manager_log.h" -#include "msg_codec.h" -#include "device_manager_errno.h" -#include "ipc_server_adapter.h" -#include "encrypt_utils.h" -#include "softbus_adapter.h" -#include "ipc_server_listener_adapter.h" -#include "hichain_connector.h" -#include "softbus_session.h" - -namespace OHOS { -namespace DistributedHardware { -RequestSession::RequestSession(std::string &hostPkgName, std::string &targetPkgName, const DmDeviceInfo &devReqInfo, - const DmAppImageInfo &imageInfo) -{ - DMLOG(DM_LOG_INFO, "RequestSession construction started"); - mDevInfo_ = devReqInfo; - mImageInfo_ = imageInfo; - mHostPkgName_ = hostPkgName; - mTargetPkgName = targetPkgName; - mPinToken_ = IpcServerAdapter::GenRandInt(MIN_PIN_TOKEN, MAX_PIN_TOKEN); - char randStr[TOKEN_LEN] = {0}; - bool res = EncryptUtils::MbedtlsGenRandomStr(randStr, sizeof(randStr), false); - if (res == false) { - DMLOG(DM_LOG_ERROR, "get Random string failed"); - mToken_ = ""; - return; - } - mToken_ = randStr; - DMLOG(DM_LOG_INFO, "RequestSession construction completed"); -} - -std::vector RequestSession::GetRequestCommand(std::string &extrasJson) -{ - return MsgCodec::EncodeReqAppAuth(mToken_, mHostPkgName_, mTargetPkgName, mDevInfo_, mImageInfo_, extrasJson); -} - -int32_t RequestSession::GetPinToken() -{ - return mPinToken_; -} - -bool RequestSession::IsWaitingForScan() -{ - return mStatus_ == StatusType::STATUS_WATING_SCAN_OR_INPUT; -} - -std::string RequestSession::GetToken() -{ - return mToken_; -} - -bool RequestSession::IsMyPinToken(int32_t pinToken) -{ - return pinToken == mPinToken_; -} - -void RequestSession::OnReceivePinCode(int32_t pinCode) -{ - if (mStatus_ != StatusType::STATUS_WATING_SCAN_OR_INPUT) { - DMLOG(DM_LOG_ERROR, "mStatus_ is incorrect, mStatus_: %d", mStatus_); - return; - } - - DMLOG(DM_LOG_INFO, "RequestSession::OnReceivePinCode"); - responseMsgPtr_->SavePinCode(pinCode); - HichainConnector::GetInstance().AddMemeber(mDevInfo_.deviceId, responseMsgPtr_); - mStatus_ = StatusType::STATUS_WAITING_ADD_GROUP; -} - -void RequestSession::OnUserOperate(int32_t action) -{ - if (action == FaAction::USER_OPERATION_TYPE_CANCEL_PINCODE_INPUT) { - Release(); - return; - } -} - -int64_t RequestSession::GetRequestId() -{ - return mRequestId_; -} - -std::string RequestSession::GetRequestDeviceId() -{ - return mRemoteDeviceId_; -} - -int32_t RequestSession::StartFaService() -{ - DMLOG(DM_LOG_INFO, "RequestSession::StartFaService in"); - AbilityStatus status = DmAbilityManager::GetInstance().StartAbility(AbilityRole::ABILITY_ROLE_INITIATIVE); - if (status != AbilityStatus::ABILITY_STATUS_SUCCESS) { - DMLOG(DM_LOG_ERROR, "RequestSession::StartFaService timeout"); - return FAIL; - } - return SUCCESS; -} - -bool RequestSession::IsFinished() -{ - if (mStatus_ == StatusType::STATUS_INIT || mStatus_ == StatusType::STATUS_FINISH) { - return true; - } - return false; -} - -bool RequestSession::IsMyChannelId(long long channelId) -{ - return channelId == mChannelId_; -} - -void RequestSession::OnReceiveMsg(std::string &msg) -{ - if (mStatus_ != StatusType::STATUS_WAITING_REPLY) { - DMLOG(DM_LOG_ERROR, "StatusType is not waiting reply"); - return; - } - int32_t reply = ParseRespMsg(msg); - DMLOG(DM_LOG_INFO, "reply is : %d", reply); - if (reply == SESSION_REPLY_ACCEPT) { - mStatus_ = StatusType::STATUS_WATING_SCAN_OR_INPUT; - CloseChannel(); - } else { - Release(); - } - NotifyHostAppAuthResult(reply); -} - -std::string RequestSession::GetHostPkgName() -{ - return mHostPkgName_; -} - -std::string RequestSession::GetTargetPkgName() -{ - return mTargetPkgName; -} - -int32_t RequestSession::GetSessionType() -{ - return mSessionType_; -} - -void RequestSession::Release() -{ - if (mStatus_ == StatusType::STATUS_FINISH || mStatus_ == StatusType::STATUS_INIT) { - DMLOG(DM_LOG_INFO, "session is already closed"); - return; - } - DMLOG(DM_LOG_INFO, "close this session"); - mStatus_ = StatusType::STATUS_FINISH; - CloseChannel(); -} - -void RequestSession::CloseChannel() -{ - if (mIsChannelOpened_) { - SoftbusSession::GetInstance().CloseSession(mChannelId_); - DMLOG(DM_LOG_ERROR, "RequestSession:: close the channel"); - mIsChannelOpened_ = false; - } -} - -int32_t RequestSession::ParseRespMsg(std::string &msg) -{ - DMLOG(DM_LOG_INFO, "ParseRespMsg started"); - auto msgResponseAuthPtr = MsgCodec::DecodeResponseAuth(msg); - if (msgResponseAuthPtr == nullptr) { - DMLOG(DM_LOG_ERROR, "DecodeResponseAuth error"); - return SESSION_REPLY_UNKNOWN; - } - responseMsgPtr_ = msgResponseAuthPtr; - int32_t reply = msgResponseAuthPtr->GetReply(); - mRemoteDeviceId_ = msgResponseAuthPtr->GetDeviceId(); - if (reply == SESSION_REPLY_ACCEPT) { - mRemoteNetId_ = msgResponseAuthPtr->GetNetId(); - mRemoteGroupId_ = msgResponseAuthPtr->GetGroupId(); - mRemoteGroupName_ = msgResponseAuthPtr->GetGroupName(); - mRequestId_ = msgResponseAuthPtr->GetRequestId(); - - auto remoteGroupList = msgResponseAuthPtr->GetSyncGroupList(); - SyncDmPrivateGroup(remoteGroupList); - DMLOG(DM_LOG_INFO, "user accepted the auth"); - } - DMLOG(DM_LOG_INFO, "ParseRespMsg completed"); - return reply; -} - -void RequestSession::SetChannelId(long long channelId) -{ - mChannelId_ = channelId; - mIsChannelOpened_ = true; - mStatus_ = StatusType::STATUS_WAITING_REPLY; -} - -void RequestSession::SyncDmPrivateGroup(std::vector &remoteGroupList) -{ - HichainConnector::GetInstance().SyncGroups(mRemoteDeviceId_, remoteGroupList); - DMLOG(DM_LOG_INFO, "RequestSession::syncDmPrivateGroup started"); - std::vector localGroups = {}; - std::vector groupList = {}; - - HichainConnector::GetInstance().GetRelatedGroups(mRemoteDeviceId_, groupList); - HichainConnector::GetInstance().GetSyncGroupList(groupList, localGroups); - if (mRemoteGroupId_ != "") { - localGroups.push_back(mRemoteGroupId_); - } - - std::string synGroupMsg = MsgCodec::EncodeSyncGroup(localGroups, mRemoteDeviceId_); - SoftbusSession::GetInstance().SendMsg(mChannelId_, synGroupMsg); - DMLOG(DM_LOG_INFO, "RequestSession::SyncDmPrivateGroup completed"); -} - -void RequestSession::NotifyHostAppAuthResult(int32_t errorCode) -{ - if (mSessionType_ != SESSION_TYPE_IS_APP_AUTH) { - DMLOG(DM_LOG_ERROR, "wrong session type: %d", mSessionType_); - return; - } - - std::string deviceId = mDevInfo_.deviceId; - if (errorCode != SESSION_REPLY_ACCEPT) { - IpcServerListenerAdapter::GetInstance().OnAuthResult(mHostPkgName_, deviceId, mPinToken_, FAIL, errorCode); - DMLOG(DM_LOG_INFO, "notify host result, errorcode: %d", errorCode); - return; - } - - if (StartFaService() != SUCCESS) { - DMLOG(DM_LOG_INFO, "RequestSession::StartFaService failed"); - return; - } - DMLOG(DM_LOG_INFO, "RequestSession::StartFaService success"); - IpcServerListenerAdapter::GetInstance().OnAuthResult(mHostPkgName_, deviceId, mPinToken_, SUCCESS, errorCode); -} -} -} diff --git a/services/devicemanagerservice/src/requestauth/response_session.cpp b/services/devicemanagerservice/src/requestauth/response_session.cpp deleted file mode 100644 index 54681ec86cde41438bd18936f05acb37ba353e3b..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/requestauth/response_session.cpp +++ /dev/null @@ -1,343 +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 -#include "nlohmann/json.hpp" - -#include "parameter.h" - -#include "dm_ability_manager.h" -#include "response_session.h" -#include "constants.h" -#include "msg_codec.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" -#include "encrypt_utils.h" -#include "ipc_server_adapter.h" -#include "softbus_adapter.h" -#include "softbus_session.h" -#include "hichain_connector.h" -#include "pthread.h" -#include "ipc_server_adapter.h" -#include "dm_device_info.h" -#include "ipc_server_listener_adapter.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { -const int32_t SESSION_CANCEL_TIMEOUT = 0; -const int32_t SESSION_MSG_RECEIVE_TIMEOUT = 5; -const int32_t SESSION_WAIT_MEMBER_JOIN_TIMEOUT = 120; -const int32_t CANCEL_PICODE_DISPLAY = 1; -const int32_t DEVICE_ID_HALF = 2; -} - -ResponseSession::ResponseSession() -{ - mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; - sem_init(&mSem_, 0, 0); - mRequestId_ = -1; - mGroupId_ = ""; - mGroupName_ = ""; - mReqDeviceId_ = ""; - mMsgRequestAuthPtr_ = nullptr; - mChannelId_ = -1; - mPincode_ = -1; -} - -int64_t ResponseSession::GetRequestId() -{ - return mRequestId_; -} - -int32_t ResponseSession::SendResponseMessage(int32_t reply) -{ - DMLOG(DM_LOG_INFO, "ResponseSession::SendResponseMessage in, reply:%d", reply); - std::string msg; - if (reply == SESSION_REPLY_ACCEPT) { - msg = MsgCodec::EncodeAcceptRespAuth(reply, mRequestId_, mGroupId_, mGroupName_, mReqDeviceId_); - } else { - msg = MsgCodec::EncodeRefuseRespAuth(reply, mReqDeviceId_); - } - - int32_t ret = SoftbusSession::GetInstance().SendMsg(mChannelId_, msg); - if (ret != SUCCESS) { - DMLOG(DM_LOG_INFO, "SendResponseMessage failed ret:%d, reply:%d", ret, reply); - return ret; - } - DMLOG(DM_LOG_INFO, "SendResponseMessage successed, reply:%d", reply); - return SUCCESS; -} - -void ResponseSession::OnUserOperate(int32_t action) -{ - switch (action) { - case FaAction::USER_OPERATION_TYPE_ALLOW_AUTH: { - OnUserConfirm(); - break; - } - case FaAction::USER_OPERATION_TYPE_CANCEL_AUTH: { - OnUserReject(ERROR_USER_REJECT); - break; - } - case FaAction::USER_OPERATION_TYPE_AUTH_CONFIRM_TIMEOUT: { - OnUserReject(SESSION_REPLY_AUTH_CONFIRM_TIMEOUT); - break; - } - case FaAction::USER_OPERATION_TYPE_CANCEL_PINCODE_DISPLAY: { - DMLOG(DM_LOG_ERROR, "cancle pincode display"); - Release(); - break; - } - default: { - DMLOG(DM_LOG_ERROR, "action %d not support", action); - break; - } - } -} - -int32_t ResponseSession::DecodeReqMsg(std::string &message) -{ - std::shared_ptr authMsg = MsgCodec::DecodeRequestAuth(message, mMsgRequestAuthPtr_); - if (authMsg == nullptr) { - DMLOG(DM_LOG_ERROR, "DecodeRequestAuth error, authMsg(nullptr)"); - return FAIL; - } - - if (authMsg->GetMsgSlice() == FAIL) { - DMLOG(DM_LOG_ERROR, "DecodeRequestAuth error, GetMsgSlice() FAIL"); - return FAIL; - } - - mMsgRequestAuthPtr_ = authMsg; - return SUCCESS; -} - -bool ResponseSession::IsMyChannelId(long long channelId) -{ - if (mSessionStatus_ == ResponseSessionStatus::SESSION_INIT) { - return true; - } - - return channelId == mChannelId_ && mChannelId_ > 0; -} - -void OnReceiveTimeOut(void *data) -{ - DMLOG(DM_LOG_ERROR, "OnReceiveTimeOut TimeOut called"); - ResponseSession *respSess = (ResponseSession*)data; - if (respSess == nullptr || respSess->GetStatus() == ResponseSessionStatus::SESSION_INIT) { - DMLOG(DM_LOG_ERROR, "respSess Status is INIT"); - return; - } - - respSess->Release(); -} - -void OnMemberJoinTimeOut(void *data) -{ - DMLOG(DM_LOG_ERROR, "OnMemberJoinTimeOut TimeOut caled"); - ResponseSession *respSess = (ResponseSession*)data; - if (respSess == nullptr || respSess->GetStatus() == ResponseSessionStatus::SESSION_INIT) { - DMLOG(DM_LOG_ERROR, "respSess Status is INIT"); - return; - } - - respSess->SendResponseMessage(SESSION_REPLY_TIMEOUT); - respSess->CancelDisplay(); - respSess->Release(); -} - -void ResponseSession::OnReceiveMsg(long long channelId, std::string &message) -{ - int32_t ret = DecodeReqMsg(message); - if (ret != SUCCESS) { - DMLOG(DM_LOG_ERROR, "DecodeReqMsg failed"); - return; - } - - if (!mReceiveTimerPtr_) { - std::string mReceiveTimerName = "mReceiveTimer"; - mReceiveTimerPtr_ = std::make_shared(mReceiveTimerName); - } - - mReceiveTimerPtr_->Start(SESSION_MSG_RECEIVE_TIMEOUT, OnReceiveTimeOut, this); - if (mMsgRequestAuthPtr_->GetMsgCnt() != mMsgRequestAuthPtr_->GetMsgSlice()) { - return; - } - - mReceiveTimerPtr_->Stop(SESSION_CANCEL_TIMEOUT); - mReqDeviceId_ = mMsgRequestAuthPtr_->GetRequestDeviceId(); - mChannelId_ = channelId; - mPincode_ = GeneratePincode(); - if (StartFaService() != SUCCESS) { - OnUserReject(ERROR_FA_START_FAIL); - return; - } - - mSessionStatus_ = ResponseSessionStatus::SESSION_WAITTING_USER_CONFIRM; - if (!mMemberJoinTimerPtr_) { - std::string mMemberJoinTimerName = "mMemberJoinTimer"; - mMemberJoinTimerPtr_ = std::make_shared(mMemberJoinTimerName); - } - - mMemberJoinTimerPtr_->Start(SESSION_WAIT_MEMBER_JOIN_TIMEOUT, OnMemberJoinTimeOut, this); -} - -int32_t ResponseSession::GetPinCodeByReqId(int64_t requestId) -{ - if (requestId != mRequestId_) { - DMLOG(DM_LOG_ERROR, "ResponseSession:: GetPinCodeByReqId FAIL : requestId(not match)"); - return FAIL; - } - return mPincode_; -} - -void ResponseSession::BuildAuthenticationInfo(DmAuthParam &authParam) -{ - DMLOG(DM_LOG_INFO, "ResponseSession::BuildAuthenticationInfo in"); - authParam.direction = (int32_t)DmAbilityManager::GetInstance().GetAbilityRole(); - if (mMsgRequestAuthPtr_ == nullptr) { - DMLOG(DM_LOG_ERROR, "ResponseSession::BuildAuthenticationInfo mMsgRequestAuthPtr_ is nullptr"); - return; - } - - authParam.packageName = mMsgRequestAuthPtr_->mTargetPkg_; - authParam.appName = mMsgRequestAuthPtr_->mAppName_; - authParam.appDescription = mMsgRequestAuthPtr_->mAppDescription_; - authParam.authType = mMsgRequestAuthPtr_->mAuthType_; - authParam.business = BUSINESS_FA_MIRGRATION; // currently, only support BUSINESS_FA_MIRGRATION - authParam.pincode = mPincode_; - - if (mMsgRequestAuthPtr_ != nullptr) { - authParam.imageinfo = mMsgRequestAuthPtr_->mImageInfo_; - } -} - -int32_t ResponseSession::StartFaService() -{ - DMLOG(DM_LOG_INFO, "ResponseSession::StartFaService in"); - AbilityStatus status = DmAbilityManager::GetInstance().StartAbility(AbilityRole::ABILITY_ROLE_PASSIVE); - if (status != AbilityStatus::ABILITY_STATUS_SUCCESS) { - DMLOG(DM_LOG_ERROR, "ResponseSession::StartFaService timeout"); - return FAIL; - } - return SUCCESS; -} - -void ResponseSession::OnGroupCreated(int64_t requestId, const std::string &groupId) -{ - DMLOG(DM_LOG_INFO, "ResponseSession OnGroupCreated in requestId= %lld groupId = %s ", requestId, groupId.c_str()); - - if (requestId != mRequestId_ || groupId.length() == 0) { - DMLOG(DM_LOG_ERROR, "ResponseSession::OnGroupCreated failed, requestId %lld, requestId %lld, groupId %s", - requestId, mRequestId_, groupId.c_str()); - SendResponseMessage(SESSION_REPLY_CREAT_GROUP_FAILED); - CancelDisplay(); - mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; - return; - } - - // save requestId for peer to join, need to be checked in HiChain OnRequest and OnFinish(AddMemberToGroup) callback - mRequestId_ = HichainConnector::GetInstance().GenRequestId(); - mGroupId_ = groupId; - int32_t ret = SendResponseMessage(SESSION_REPLY_ACCEPT); - if (ret != SUCCESS) { - CancelDisplay(); - mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; - return; - } - - DMLOG(DM_LOG_INFO, "Send Accept Resoponse success, wait for peer to AddMemberToGroup"); - mSessionStatus_ = ResponseSessionStatus::SESSION_WAITTING_PIN_CODE; -} - -void ResponseSession::OnMemberJoin(int64_t requestId, int32_t status) -{ - DMLOG(DM_LOG_INFO, "ResponseSession::OnMemberJoin, result: %d", status); - CancelDisplay(); - mMemberJoinTimerPtr_->Stop(SESSION_CANCEL_TIMEOUT); - Release(); -} - -std::string ResponseSession::GenerateGroupName() -{ - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - std::string sLocalDeviceID = localDeviceId; - std::string groupName = mMsgRequestAuthPtr_->mTargetPkg_ + mMsgRequestAuthPtr_->mHostPkg_ + - sLocalDeviceID.substr(0, sLocalDeviceID.size() / DEVICE_ID_HALF); - return groupName; -} - -void ResponseSession::OnUserConfirm() -{ - DMLOG(DM_LOG_INFO, "ResponseSession::OnUserConfirm in"); - mGroupName_ = GenerateGroupName(); - HichainConnector::GetInstance().RegisterConnectorCallback(shared_from_this()); - - // save requestId for CreateGroup, need to be checked in callback: OnGroupCreated - mRequestId_ = HichainConnector::GetInstance().GenRequestId(); - int32_t ret = HichainConnector::GetInstance().CreateGroup(mRequestId_, mGroupName_); - if (ret != SUCCESS) { - CancelDisplay(); - mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; - return; - } - mSessionStatus_ = ResponseSessionStatus::SESSION_WAITTING_GROUP_CREATED; -} - -void ResponseSession::OnUserReject(int32_t errorCode) -{ - DMLOG(DM_LOG_INFO, "ResponseSession::OnUserReject in, errcode %d", errorCode); - SendResponseMessage(errorCode); - Release(); -} - -void ResponseSession::Release() -{ - DMLOG(DM_LOG_INFO, "ResponseSession::Release in"); - mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; - mRequestId_ = -1; - mGroupId_ = ""; - mGroupName_ = ""; - mReqDeviceId_ = ""; - mMsgRequestAuthPtr_ = nullptr; - mChannelId_ = -1; - mPincode_ = -1; -} - -void ResponseSession::CancelDisplay() -{ - DMLOG(DM_LOG_INFO, "Cancel PinCode Display in"); - nlohmann::json jsonObj; - jsonObj[CANCEL_DISPLAY_KEY] = CANCEL_PICODE_DISPLAY; - std::string paramJson = jsonObj.dump(); - std::string pkgName = "com.ohos.devicemanagerui"; - IpcServerListenerAdapter::GetInstance().OnFaCall(pkgName, paramJson); - DMLOG(DM_LOG_INFO, "Cancel PinCode Display success"); -} - -int32_t ResponseSession::GetStatus() -{ - return mSessionStatus_; -} - -int32_t ResponseSession::GeneratePincode() -{ - return EncryptUtils::GenRandInt(MIN_PIN_CODE, MAX_PIN_CODE); -} -} // 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 f5da3a1a375d1c6a39a69256b5c4378a28455c5e..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/softbus/softbus_adapter.cpp +++ /dev/null @@ -1,522 +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 "softbus_bus_center.h" - -#include "dm_device_info.h" -#include "dm_subscribe_info.h" - -#include "anonymous_string.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" -#include "softbus_session.h" -#include "system_ability_definition.h" - -#include "ipc_server_listener_adapter.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { -const std::string DEVICE_MANAGER_PACKAGE_NAME = "ohos.distributedhardware.devicemanager"; -const char *DM_CAPABILITY_OSD = "osdCapability"; -const int32_t CHECK_INTERVAL = 100000; // 100ms -const uint32_t SUBSCRIBE_ID_PREFIX_LEN = 16; -const int32_t SUBSCRIBE_ID_MASK = 0x0000FFFF; -const int32_t DISCOVER_DEVICEINFO_MAX_SIZE = 20; -} -std::map>> - SoftbusAdapter::subscribeInfos_; -std::map> SoftbusAdapter::discoverDeviceInfoMap_; -std::vector> SoftbusAdapter::discoverDeviceInfoVector_; -uint16_t SoftbusAdapter::subscribeIdPrefix = 0; -std::mutex SoftbusAdapter::lock_; -INodeStateCb SoftbusAdapter::softbusNodeStateCb_ = { - .events = EVENT_NODE_STATE_ONLINE | EVENT_NODE_STATE_OFFLINE | EVENT_NODE_STATE_INFO_CHANGED, - .onNodeOnline = OnSoftBusDeviceOnline, - .onNodeOffline = OnSoftbusDeviceOffline, - .onNodeBasicInfoChanged = OnSoftbusDeviceInfoChanged -}; -IDiscoveryCallback SoftbusAdapter::softbusDiscoverCallback_ = { - .OnDeviceFound = OnSoftbusDeviceFound, - .OnDiscoverFailed = OnSoftbusDiscoverFailed, - .OnDiscoverySuccess = OnSoftbusDiscoverySuccess -}; -IPublishCallback SoftbusAdapter::servicePublishCallback_ = { - .OnPublishSuccess = PublishServiceCallBack::OnPublishSuccess, - .OnPublishFail = PublishServiceCallBack::OnPublishFail -}; - -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; - } - } -} - -void SoftbusAdapter::OnSoftBusDeviceOnline(NodeBasicInfo *info) -{ - if (info == nullptr) { - DMLOG(DM_LOG_ERROR, "OnSoftBusDeviceOnline NodeBasicInfo is nullptr"); - return; - } - DmDeviceInfo dmDeviceInfo; - - NodeBasicInfoCopyToDmDevice(dmDeviceInfo, *info); - IpcServerListenerAdapter::GetInstance().OnDeviceStateChange(DmDeviceState::DEVICE_STATE_ONLINE, dmDeviceInfo); - - 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 != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "GetNodeKeyInfo failed"); - return; - } - std::string deviceId = (char *)udid; - DMLOG(DM_LOG_INFO, "device online, deviceId: %s", GetAnonyString(deviceId).c_str()); - RemoveDiscoverDeviceInfo(deviceId); -} - -void SoftbusAdapter::OnSoftbusDeviceOffline(NodeBasicInfo *info) -{ - if (info == nullptr) { - DMLOG(DM_LOG_ERROR, "OnSoftbusDeviceOffline NodeBasicInfo is nullptr"); - return; - } - DmDeviceInfo dmDeviceInfo; - - NodeBasicInfoCopyToDmDevice(dmDeviceInfo, *info); - IpcServerListenerAdapter::GetInstance().OnDeviceStateChange(DmDeviceState::DEVICE_STATE_OFFLINE, dmDeviceInfo); -} - -void SoftbusAdapter::OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info) -{ - DMLOG(DM_LOG_INFO, "OnSoftbusDeviceInfoChanged."); - // currently do nothing - (void)type; - (void)info; -} - -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) { - DMLOG(DM_LOG_ERROR, "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::OnSoftbusDeviceFound(const DeviceInfo *device) -{ - if (device == nullptr) { - DMLOG(DM_LOG_ERROR, "deviceinfo is null"); - return; - } - - std::string deviceId = device->devId; - DMLOG(DM_LOG_INFO, "SoftbusAdapter::OnSoftbusDeviceFound device %s found.", GetAnonyString(deviceId).c_str()); - if (IsDeviceOnLine(deviceId)) { - return; - } - - SaveDiscoverDeviceInfo(device); - 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(); - DMLOG(DM_LOG_INFO, "subscribe info capability:%s.", info->info.capability); - if (strcmp(DM_CAPABILITY_OSD, info->info.capability) != 0) { - DMLOG(DM_LOG_ERROR, "subscribe info capability invalid."); - } - uint16_t originId = (uint16_t)(((uint32_t)info->info.subscribeId) & SUBSCRIBE_ID_MASK); - std::string strPkgName = iter->first; - DmDeviceInfo dmDeviceInfo; - - DeviceInfoCopyToDmDevice(dmDeviceInfo, *device); - IpcServerListenerAdapter::GetInstance().OnDeviceFound(strPkgName, originId, dmDeviceInfo); - } - } -} - -bool SoftbusAdapter::GetpkgNameBySubscribeId(int32_t adapterId, std::string &pkgName) -{ - 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) { - pkgName = iter->first; - return true; - } - } - } - return false; -} - -void SoftbusAdapter::OnSoftbusDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason) -{ - DMLOG(DM_LOG_INFO, "In, subscribeId %d, failReason %d", subscribeId, (int32_t)failReason); - std::string pkgName; - if (!GetpkgNameBySubscribeId(subscribeId, pkgName)) { - DMLOG(DM_LOG_ERROR, "OnSoftbusDiscoverFailed: pkgName not found"); - return; - } - - uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); - IpcServerListenerAdapter::GetInstance().OnDiscoverFailed(pkgName, originId, failReason); -} - -void SoftbusAdapter::OnSoftbusDiscoverySuccess(int32_t subscribeId) -{ - DMLOG(DM_LOG_INFO, "In, subscribeId %d", subscribeId); - std::string pkgName; - if (!GetpkgNameBySubscribeId(subscribeId, pkgName)) { - DMLOG(DM_LOG_ERROR, "OnSoftbusDiscoverySuccess: pkgName not found"); - return; - } - uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); - IpcServerListenerAdapter::GetInstance().OnDiscoverySuccess(pkgName, originId); -} - -bool SoftbusAdapter::GetsubscribeIdAdapter(std::string &pkgName, int16_t originId, int32_t &adapterId) -{ - DMLOG(DM_LOG_INFO, "GetsubscribeIdAdapter in, pkgName: %s, originId:%d", pkgName.c_str(), - (int32_t)originId); - auto iter = subscribeInfos_.find(pkgName); - if (iter == subscribeInfos_.end()) { - DMLOG(DM_LOG_ERROR, "subscribeInfo not find for pkgName: %s", pkgName.c_str()); - return false; - } - - std::vector> &subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - for (; vectorIter != subinfoVector.end(); ++vectorIter) { - if (vectorIter->get()->subscribeIdOrigin == originId) { - DMLOG(DM_LOG_ERROR, "find adapterId:%d for pkgName: %s, originId:%d", - vectorIter->get()->info.subscribeId, pkgName.c_str(), (int32_t)originId); - adapterId = vectorIter->get()->info.subscribeId; - return true; - } - } - DMLOG(DM_LOG_ERROR, "subscribe not find. pkgName: %s, originId:%d", pkgName.c_str(), (int32_t)originId); - return false; -} - -int32_t SoftbusAdapter::Init() -{ - int32_t ret; - int32_t retryTimes = 0; - do { - ret = RegNodeDeviceStateCb(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &softbusNodeStateCb_); - if (ret != DEVICEMANAGER_OK) { - ++retryTimes; - DMLOG(DM_LOG_ERROR, "RegNodeDeviceStateCb failed with ret %d, retryTimes %d", ret, retryTimes); - usleep(CHECK_INTERVAL); - } - } while (ret != DEVICEMANAGER_OK); - DMLOG(DM_LOG_INFO, "RegNodeDeviceStateCb success."); - SoftbusSession::GetInstance().Start(); - - PublishInfo dmPublishInfo; - dmPublishInfo.publishId = DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID; - dmPublishInfo.mode = DiscoverMode::DISCOVER_MODE_ACTIVE; - dmPublishInfo.medium = ExchanageMedium::AUTO; - dmPublishInfo.freq = ExchangeFreq::HIGH; - dmPublishInfo.capability = DM_CAPABILITY_OSD; - dmPublishInfo.capabilityData = nullptr; - dmPublishInfo.dataLen = 0; - ret = PublishService(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &dmPublishInfo, &servicePublishCallback_); - DMLOG(DM_LOG_INFO, "service publish result is : %d", ret); - return ret; -} - -int32_t SoftbusAdapter::GetTrustDevices(const std::string &pkgName, NodeBasicInfo **info, int32_t *infoNum) -{ - DMLOG(DM_LOG_INFO, "DM_GetSoftbusTrustDevices start, pkgName: %s", pkgName.c_str()); - int32_t ret = GetAllNodeDeviceInfo(DEVICE_MANAGER_PACKAGE_NAME.c_str(), info, infoNum); - if (ret != 0) { - DMLOG(DM_LOG_ERROR, "GetAllNodeDeviceInfo failed with ret %d", ret); - return ret; - } - DMLOG(DM_LOG_INFO, "success, pkgName: %s, deviceCount %d", pkgName.c_str(), *infoNum); - return DEVICEMANAGER_OK; -} - -int32_t SoftbusAdapter::StartDiscovery(std::string &pkgName, SubscribeInfo *info) -{ - std::shared_ptr subinfo = nullptr; - if (subscribeInfos_.find(pkgName) == subscribeInfos_.end()) { - subscribeInfos_[pkgName] = {}; - } - - auto iter = subscribeInfos_.find(pkgName); - 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) { - std::lock_guard autoLock(lock_); - subinfo = std::make_shared(); - subinfo->subscribeIdOrigin = info->subscribeId; - subinfo->subscribeIdPrefix = subscribeIdPrefix++; - subinfo->info = *info; - - uint32_t uSubscribeId = static_cast(info->subscribeId); - uSubscribeId = (subinfo->subscribeIdPrefix << SUBSCRIBE_ID_PREFIX_LEN) | uSubscribeId; - subinfo->info.subscribeId = static_cast(uSubscribeId); - } - if (vectorIter == subinfoVector.end()) { - subinfoVector.push_back(subinfo); - } - DMLOG(DM_LOG_INFO, "StartDiscovery, pkgName: %s, subscribeId %d, prefix %d, origin %d", - pkgName.c_str(), subinfo->info.subscribeId, subinfo->subscribeIdPrefix, subinfo->subscribeIdOrigin); - DMLOG(DM_LOG_INFO, "Capability: %s", subinfo->info.capability); - int32_t ret = ::StartDiscovery(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &subinfo->info, &softbusDiscoverCallback_); - if (ret != 0) { - DMLOG(DM_LOG_ERROR, "StartDiscovery failed with ret %d.", ret); - return DEVICEMANAGER_DISCOVERY_FAILED; - } - return DEVICEMANAGER_OK; -} - -int32_t SoftbusAdapter::StopDiscovery(std::string &pkgName, uint16_t subscribeId) -{ - int32_t subscribeIdAdapter = -1; - if (!GetsubscribeIdAdapter(pkgName, subscribeId, subscribeIdAdapter)) { - DMLOG(DM_LOG_ERROR, "StopDiscovery failed, subscribeId not match"); - return DEVICEMANAGER_FAILED; - } - - DMLOG(DM_LOG_INFO, "StopDiscovery begin, pkgName: %s, subscribeId:%d, subscribeIdAdapter:%d", - pkgName.c_str(), (int32_t)subscribeId, subscribeIdAdapter); - int32_t ret = ::StopDiscovery(DEVICE_MANAGER_PACKAGE_NAME.c_str(), subscribeIdAdapter); - if (ret != 0) { - DMLOG(DM_LOG_ERROR, "StopDiscovery failed with ret %d", ret); - return ret; - } - - auto iter = subscribeInfos_.find(pkgName); - 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(pkgName); - } - DMLOG(DM_LOG_INFO, "DM_StopSoftbusDiscovery completed, pkgName: %s", pkgName.c_str()); - return DEVICEMANAGER_OK; -} - -bool SoftbusAdapter::IsDeviceOnLine(std::string &deviceId) -{ - NodeBasicInfo *info = nullptr; - int32_t infoNum = 0; - - if (GetTrustDevices(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &info, &infoNum) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "DM_IsDeviceOnLine DM_GetSoftbusTrustDevices failed"); - return false; - } - - bool bDeviceOnline = false; - for (int32_t i = 0; i < infoNum; ++i) { - NodeBasicInfo *nodeBasicInfo = info + i; - if (nodeBasicInfo == nullptr) { - DMLOG(DM_LOG_ERROR, "nodeBasicInfo is empty for index %d, infoNum %d.", i, infoNum); - continue; - } - std::string networkId = nodeBasicInfo->networkId; - if (networkId == deviceId) { - DMLOG(DM_LOG_INFO, "DM_IsDeviceOnLine device %s online", GetAnonyString(deviceId).c_str()); - bDeviceOnline = true; - break; - } - 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 != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "DM_IsDeviceOnLine GetNodeKeyInfo failed"); - break; - } - - if (strcmp((char *)udid, deviceId.c_str()) == 0) { - DMLOG(DM_LOG_INFO, "DM_IsDeviceOnLine devccie %s online", GetAnonyString(deviceId).c_str()); - bDeviceOnline = true; - break; - } - } - FreeNodeInfo(info); - return bDeviceOnline; -} - -int32_t SoftbusAdapter::GetConnectionIpAddr(std::string deviceId, std::string &ipAddr) -{ - auto iter = discoverDeviceInfoMap_.find(deviceId); - if (iter == discoverDeviceInfoMap_.end()) { - DMLOG(DM_LOG_ERROR, "deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str()); - return DEVICEMANAGER_FAILED; - } - - DeviceInfo *deviceInfo = iter->second.get(); - if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { - DMLOG(DM_LOG_ERROR, "deviceInfo addrNum not valid, addrNum %d", deviceInfo->addrNum); - return DEVICEMANAGER_FAILED; - } - - for (uint32_t 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; - DMLOG(DM_LOG_INFO, "DM_GetConnectionIpAddr get ip ok."); - return DEVICEMANAGER_OK; - } - DMLOG(DM_LOG_ERROR, "failed to get ipAddr for deviceId %s", GetAnonyString(deviceId).c_str()); - return DEVICEMANAGER_FAILED; -} - -// eth >> wlan >> ble >> br -ConnectionAddr *SoftbusAdapter::GetConnectAddrByType(DeviceInfo *deviceInfo, ConnectionAddrType type) -{ - if (deviceInfo == nullptr) { - return nullptr; - } - for (uint32_t i = 0; i < deviceInfo->addrNum; ++i) { - if (deviceInfo->addr[i].type == type) { - return &deviceInfo->addr[i]; - } - } - return nullptr; -} - -ConnectionAddr *SoftbusAdapter::GetConnectAddr(std::string deviceId) -{ - auto iter = discoverDeviceInfoMap_.find(deviceId); - if (iter == discoverDeviceInfoMap_.end()) { - DMLOG(DM_LOG_ERROR, "deviceInfo not found by deviceId %s", GetAnonyString(deviceId).c_str()); - return nullptr; - } - - DeviceInfo *deviceInfo = iter->second.get(); - if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { - DMLOG(DM_LOG_ERROR, "deviceInfo addrNum not valid, addrNum %d", deviceInfo->addrNum); - return nullptr; - } - - ConnectionAddr *addr = nullptr; - addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_ETH); - if (addr != nullptr) { - DMLOG(DM_LOG_INFO, "get ETH ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); - return addr; - } - - addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_WLAN); - if (addr != nullptr) { - DMLOG(DM_LOG_INFO, "get WLAN ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); - return addr; - } - - addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_BLE); - if (addr != nullptr) { - DMLOG(DM_LOG_INFO, "get BLE ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); - return addr; - } - - addr = GetConnectAddrByType(deviceInfo, ConnectionAddrType::CONNECTION_ADDR_BR); - if (addr != nullptr) { - DMLOG(DM_LOG_INFO, "get BR ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); - return addr; - } - - DMLOG(DM_LOG_ERROR, "failed to get ConnectionAddr for deviceId %s", GetAnonyString(deviceId).c_str()); - return nullptr; -} - -void SoftbusAdapter::NodeBasicInfoCopyToDmDevice(DmDeviceInfo &dmDeviceInfo, NodeBasicInfo &nodeBasicInfo) -{ - (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); - if (memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), nodeBasicInfo.networkId, - std::min(sizeof(dmDeviceInfo.deviceId), sizeof(nodeBasicInfo.networkId))) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "memcpy failed"); - } - if (memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), nodeBasicInfo.deviceName, - std::min(sizeof(dmDeviceInfo.deviceName), sizeof(nodeBasicInfo.deviceName))) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "memcpy failed"); - } - dmDeviceInfo.deviceTypeId = (DMDeviceType)nodeBasicInfo.deviceTypeId; -} - -void SoftbusAdapter::DeviceInfoCopyToDmDevice(DmDeviceInfo &dmDeviceInfo, const DeviceInfo &deviceInfo) -{ - (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); - if (memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), deviceInfo.devId, - std::min(sizeof(dmDeviceInfo.deviceId), sizeof(deviceInfo.devId))) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "memcpy failed"); - } - if (memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), deviceInfo.devName, - std::min(sizeof(dmDeviceInfo.deviceName), sizeof(deviceInfo.devName))) != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_ERROR, "memcpy failed"); - } - dmDeviceInfo.deviceTypeId = (DMDeviceType)deviceInfo.devType; -} - -void PublishServiceCallBack::OnPublishSuccess(int32_t publishId) -{ - DMLOG(DM_LOG_INFO, "service publish succeed, publishId: %d", publishId); -} - -void PublishServiceCallBack::OnPublishFail(int32_t publishId, PublishFailReason reason) -{ - DMLOG(DM_LOG_INFO, "service publish failed, publishId: %d, reason: %d", publishId, reason); -} -} // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file diff --git a/services/devicemanagerservice/src/softbus/softbus_session.cpp b/services/devicemanagerservice/src/softbus/softbus_session.cpp deleted file mode 100644 index 84bf739a2649b5a60a3df9c816643e29a1d1d4a1..0000000000000000000000000000000000000000 --- a/services/devicemanagerservice/src/softbus/softbus_session.cpp +++ /dev/null @@ -1,230 +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_session.h" -#include "softbus_adapter.h" -#include "anonymous_string.h" -#include "device_manager_log.h" -#include "device_manager_errno.h" -#include "auth_manager.h" -#include "encrypt_utils.h" -#include "constants.h" -#include "session.h" -#include "inner_session.h" - -namespace OHOS { -namespace DistributedHardware { -static int32_t SessionOpened(int32_t sessionId, int32_t result) -{ - return SoftbusSession::GetInstance().OnSessionOpened(sessionId, result); -} - -static void SessionClosed(int32_t sessionId) -{ - SoftbusSession::GetInstance().OnSessionClosed(sessionId); -} - -static void BytesReceived(int32_t sessionId, const void *data, uint32_t dataLen) -{ - SoftbusSession::GetInstance().GetInstance().OnBytesReceived(sessionId, data, dataLen); -} - -static void MessageReceived(int32_t sessionId, const void *data, uint32_t dataLen) -{ - (void)sessionId; - (void)data; - (void)dataLen; - DMLOG(DM_LOG_INFO, "sessionId:%d, dataLen:%d", sessionId, dataLen); -} - -static void StreamReceived(int32_t sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param) -{ - (void)sessionId; - (void)data; - (void)ext; - (void)param; - DMLOG(DM_LOG_INFO, "sessionId:%d", sessionId); -} - -IMPLEMENT_SINGLE_INSTANCE(SoftbusSession); - -SoftbusSession::~SoftbusSession() -{ - (void)RemoveSessionServer(PKG_NAME, SESSION_NAME); -} - -int32_t SoftbusSession::Start() -{ - DMLOG(DM_LOG_INFO, "SoftbusSession start"); - ISessionListener iSessionListener = { - .OnSessionOpened = SessionOpened, - .OnSessionClosed = SessionClosed, - .OnBytesReceived = BytesReceived, - .OnMessageReceived = MessageReceived, - .OnStreamReceived = StreamReceived - }; - int32_t ret = CreateSessionServer(PKG_NAME, SESSION_NAME, &iSessionListener); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_DEBUG, "CreateSessionServer failed"); - return DEVICEMANAGER_CREATE_SESSION_SERVER_FAILED; - } - return DEVICEMANAGER_OK; -} - -int32_t SoftbusSession::OnSessionOpened(int32_t sessionId, int32_t result) -{ - if (result != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_INFO, "session open failed, sessionId %d", sessionId); - if (sessionIdSet_.count(sessionId) > 0) { - sessionIdSet_.erase(sessionId); - messages_.clear(); - } - return DEVICEMANAGER_OK; - } - - int32_t sessionSide = GetSessionSide(sessionId); - DMLOG(DM_LOG_INFO, "session open succeed, sessionId %d, sessionSide %d", sessionId, sessionSide); - if (sessionSide == AUTH_SESSION_SIDE_CLIENT) { - for (auto msg : messages_) { - int32_t ret = SendMsg(sessionId, msg); - if (ret != DEVICEMANAGER_OK) { - DMLOG(DM_LOG_INFO, "send message failed"); - return ret; - } - } - } else { - sessionIdSet_.insert(sessionId); - } - return DEVICEMANAGER_OK; -} - -void SoftbusSession::OnSessionClosed(int32_t sessionId) -{ - DMLOG(DM_LOG_INFO, "OnSessionClosed, sessionId:%d", sessionId); - if (sessionIdSet_.count(sessionId) > 0) { - sessionIdSet_.erase(sessionId); - } -} - -void SoftbusSession::OnBytesReceived(int32_t sessionId, const void *data, uint32_t dataLen) -{ - DMLOG(DM_LOG_INFO, "OnBytesReceived, sessionId:%d, dataLen:%d", sessionId, dataLen); - if (sessionId < 0 || data == nullptr || dataLen <= 0) { - DMLOG(DM_LOG_INFO, "OnBytesReceived param check failed"); - return; - } - - uint8_t *buf = (uint8_t *)calloc(sizeof(uint8_t), dataLen + 1); - if (buf == nullptr) { - DMLOG(DM_LOG_ERROR, "SendMsg: malloc memory failed"); - return; - } - - int32_t outLen = 0; - int32_t ret = EncryptUtils::MbedtlsDecrypt((const uint8_t*)data, dataLen, buf, dataLen, &outLen); - if (ret != DEVICEMANAGER_OK || outLen > (int32_t)dataLen) { - DMLOG(DM_LOG_ERROR, "MbedtlsDecrypt data failed"); - free(buf); - return; - } - - std::string message = (char *)buf; - AuthManager::GetInstance().OnReceiveMsg(sessionId, message); - free(buf); - DMLOG(DM_LOG_INFO, "OnBytesReceived completed"); - return; -} - -void SoftbusSession::CloseSession(int32_t sessionId) -{ - DMLOG(DM_LOG_INFO, "CloseSession in"); - ::CloseSession(sessionId); -} - -int32_t SoftbusSession::SendData(int32_t sessionId, const void *data, int32_t len) -{ - DMLOG(DM_LOG_INFO, "in, datalen:%d", len); - int32_t ret = DEVICEMANAGER_FAILED; - if (sessionIdSet_.count(sessionId) > 0) { - ret = SendBytes(sessionId, data, len); - if (ret != DEVICEMANAGER_OK) { - return DEVICEMANAGER_FAILED; - } - } else { - DMLOG(DM_LOG_INFO, "in, datalen:%d", len); - } - return ret; -} - -// send message by sessionId (channel opened) -int32_t SoftbusSession::SendMsg(int32_t sessionId, std::string &message) -{ - DMLOG(DM_LOG_ERROR, "start SendMsg"); - uint8_t *buf = (uint8_t *)calloc(sizeof(uint8_t), (MSG_MAX_SIZE + ENCRYPT_TAG_LEN)); - if (buf == nullptr) { - DMLOG(DM_LOG_ERROR, "SendMsg: malloc memory failed"); - return DEVICEMANAGER_MALLOC_ERROR; - } - int32_t outLen = 0; - int32_t ret = EncryptUtils::MbedtlsEncrypt((const uint8_t *)message.c_str(), message.size(), buf, MSG_MAX_SIZE, - &outLen); - if (ret != DEVICEMANAGER_OK || outLen > MSG_MAX_SIZE) { - DMLOG(DM_LOG_ERROR, "MbedtlsEncrypt data failed"); - free(buf); - return ENCRYPT_UTILS_AES_GCM_ENCRYPT_FAILED; - } - ret = SendData(sessionId, buf, outLen); - free(buf); - return ret; -} - -// send message while the channel is not opend -int32_t SoftbusSession::SendMessages(const char *deviceId, std::vector &message) -{ - DMLOG(DM_LOG_ERROR, "open channel and start SendMsg"); - int32_t sessionId = -1; - messages_ = message; - ConnectionAddr *addrInfo = SoftbusAdapter::GetConnectAddr(deviceId); - if (addrInfo == nullptr) { - DMLOG(DM_LOG_ERROR, "GetConnectAddr error"); - return sessionId; - } - - sessionId = ::OpenAuthSession(SESSION_NAME, addrInfo, 1, nullptr); - if (sessionId < 0) { - DMLOG(DM_LOG_ERROR, "open session error, ret:%d", sessionId); - return sessionId; - } - sessionIdSet_.insert(sessionId); - DMLOG(DM_LOG_INFO, "opened auth session is:%d", sessionId); - return sessionId; -} - -void SoftbusSession::GetPeerDeviceId(int32_t sessionId, std::string &peerDevId) -{ - char peerDeviceId[DEVICE_UUID_LENGTH] = {0}; - int32_t ret = ::GetPeerDeviceId(sessionId, &peerDeviceId[0], DEVICE_UUID_LENGTH); - if (ret == 0) { - peerDevId = peerDeviceId; - DMLOG(DM_LOG_INFO, "GetPeerDeviceId success for session:%d, peerDeviceId:%s", sessionId, - GetAnonyString(peerDevId).c_str()); - return; - } - - DMLOG(DM_LOG_ERROR, "GetPeerDeviceId failed for session:%d", sessionId); - peerDevId = ""; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/test/unittest/BUILD.gn b/test/unittest/BUILD.gn index 9c2c9dcce5ca119346df5eef8321d935763c381b..d1f6bda8acac2d2f8172841ed9628d65b2e6c199 100644 --- a/test/unittest/BUILD.gn +++ b/test/unittest/BUILD.gn @@ -18,7 +18,17 @@ module_out_path = "deviceManager_stander/inner_kits" group("unittest") { testonly = true - deps = [ ":device_manager_impl_test" ] + deps = [ + ":UTTest_device_manager_service", + ":UTTest_device_manager_service_listener", + ":UTTest_dm_device_info_manager", + ":UTTest_dm_device_state_manager", + ":UTTest_dm_discovery_manager", + ":UTTest_hichain_connector", + ":UTTest_softbus_connector", + ":UTTest_softbus_session", + ":device_manager_impl_test", + ] } ## UnitTest device_manager_impl_test {{{ @@ -32,6 +42,118 @@ ohos_unittest("device_manager_impl_test") { ## UnitTest device_manager_impl_test }}} +## UnitTest UTTest_device_manager_service {{{ +ohos_unittest("UTTest_device_manager_service") { + module_out_path = module_out_path + + sources = [ "UTTest_device_manager_service.cpp" ] + + deps = [ ":device_manager_test_common" ] +} + +## UnitTest UTTest_device_manager_service }}} + +## UnitTest UTTest_hichain_connector {{{ +ohos_unittest("UTTest_hichain_connector") { + module_out_path = module_out_path + + sources = [ "UTTest_hichain_connector.cpp" ] + + deps = [ ":device_manager_test_common" ] +} + +## UnitTest UTTest_hichain_connector }}} + +## UnitTest UTTest_dm_device_info_manager {{{ +ohos_unittest("UTTest_dm_device_info_manager") { + module_out_path = module_out_path + + sources = [ "UTTest_dm_device_info_manager.cpp" ] + + deps = [ ":device_manager_test_common" ] +} + +## UnitTest UTTest_dm_device_info_manager }}} + +## UnitTest UTTest_softbus_connector {{{ +ohos_unittest("UTTest_softbus_connector") { + module_out_path = module_out_path + + sources = [ "UTTest_softbus_connector.cpp" ] + + deps = [ ":device_manager_test_common" ] +} + +## UnitTest UTTest_softbus_connector }}} + +## UnitTest UTTest_softbus_session {{{ +ohos_unittest("UTTest_softbus_session") { + module_out_path = module_out_path + + sources = [ "UTTest_softbus_session.cpp" ] + + deps = [ ":device_manager_test_common" ] +} + +## UnitTest UTTest_softbus_session }}} + +## UnitTest UTTest_dm_device_state_manager {{{ +ohos_unittest("UTTest_dm_device_state_manager") { + module_out_path = module_out_path + + sources = [ + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/adapter/standard/dm_adapter_manager.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/config/config_manager.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/dependency/softbus/softbus_connector.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/dependency/softbus/softbus_session.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/dependency/timer/dm_timer.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/device_manager_service_listener.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/devicestate/dm_device_state_manager.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/discovery/dm_discovery_manager.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/ipc_server_listener.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/parameter.cpp", + "UTTest_dm_device_state_manager.cpp", + ] + + deps = [ ":device_manager_test" ] +} + +## UnitTest UTTest_dm_device_state_manager }}} + +## UnitTest UTTest_device_manager_service_listener {{{ +ohos_unittest("UTTest_device_manager_service_listener") { + module_out_path = module_out_path + + sources = [ + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/device_manager_service_listener.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/ipc_server_listener.cpp", + "UTTest_device_manager_service_listener.cpp", + ] + + deps = [ ":device_manager_test" ] +} + +## UnitTest UTTest_device_manager_service_listener }}} + +## UnitTest UTTest_dm_discovery_manager {{{ +ohos_unittest("UTTest_dm_discovery_manager") { + module_out_path = module_out_path + + sources = [ + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/dependency/softbus/softbus_connector.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/dependency/softbus/softbus_session.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/dependency/timer/dm_timer.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/device_manager_service_listener.cpp", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/src/discovery/dm_discovery_manager.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/ipc_server_listener.cpp", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/parameter.cpp", + "UTTest_dm_discovery_manager.cpp", + ] + + deps = [ ":device_manager_test" ] +} + +## UnitTest UTTest_dm_discovery_manager }}} ## Build device_manager_test_common.a {{{ config("device_manager_test_common_public_config") { include_dirs = [ @@ -41,12 +163,35 @@ config("device_manager_test_common_public_config") { "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include/ipc/standard", "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include/ipc", "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include/notify", - "${utils_path}/include/log", + "//third_party/json/include", + "${common_path}/include", "${common_path}/include/ipc", "${common_path}/include/ipc/model", + "${utils_path}/include", "${utils_path}/include/ipc/standard", - "${common_path}/include", - "//third_party/json/include", + "${services_path}/include", + "${services_path}/include/dependency/timer", + "${services_path}/include/discovery", + "${services_path}/include/dependency/softbus", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/dependency/softbus", + "//foundation/communication/dsoftbus/interfaces/kits/bus_center", + "//foundation/communication/softbus_lite/interfaces/kits/transport", + "//foundation/communication/ipc_lite/interfaces/kits", + "//foundation/communication/dsoftbus/interfaces/kits/common", + "//foundation/communication/dsoftbus/interfaces/kits/discovery", + "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/authentication", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/adapter", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/ipc/standard", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/discovery", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/dependency/hichain", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/deviceinfo/", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/devicestate", + "//foundation/distributedhardware/devicemanager/test/unittest/mock", + "//base/security/deviceauth/interfaces/innerkits", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/ability", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/config", ] cflags = [ @@ -56,6 +201,12 @@ config("device_manager_test_common_public_config") { "-Dprivate=public", "-Dprotected=public", ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"device_manager_UTtest\"", + "LOG_DOMAIN=0xD004190", + ] } ohos_static_library("device_manager_test_common") { @@ -69,10 +220,108 @@ ohos_static_library("device_manager_test_common") { "${utils_path}:devicemanagerutils", "//foundation/communication/ipc/interfaces/innerkits/ipc_core:ipc_core", "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", + "//foundation/distributedhardware/devicemanager/interfaces/kits/js:devicemanager", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice:devicemanagerservice", "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", "//third_party/googletest:gmock", + "//third_party/googletest:gtest", "//utils/native/base:utils", "//utils/native/base:utils", ] } + ## Build device_manager_test_common.a }}} + +## Build device_manager_test_common.a {{{ +config("device_manager_test_common_public") { + include_dirs = [ + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include", + "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include/ipc", + "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp/include/notify", + "//third_party/json/include", + "${common_path}/include", + "${common_path}/include/ipc", + "${common_path}/include/ipc/model", + "${utils_path}/include", + "${utils_path}/include/ipc/standard", + "${services_path}/include", + "${services_path}/include/dependency/timer", + "${services_path}/include/discovery", + "${services_path}/include/dependency/softbus", + "//foundation/communication/dsoftbus/interfaces/kits/bus_center", + "//foundation/communication/ipc_lite/interfaces/kits", + "//foundation/communication/dsoftbus/interfaces/kits/common", + "//foundation/communication/dsoftbus/interfaces/kits/discovery", + "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/dependency/softbus", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/authentication", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/adapter", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/discovery", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/dependency/hichain", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/deviceinfo/", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/devicestate", + "//foundation/distributedhardware/devicemanager/test/unittest/mock/", + "//base/security/deviceauth/interfaces/innerkits", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/ability", + "//foundation/distributedhardware/devicemanager/services/devicemanagerservice/include/config", + ] + + cflags = [ + "-Wall", + "-Werror", + "-g3", + "-Dprivate=public", + "-Dprotected=public", + ] + + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"device_manager_UTtest\"", + "LOG_DOMAIN=0xD004190", + ] +} + +ohos_static_library("device_manager_test") { + testonly = true + + visibility = [ ":*" ] + + public_configs = [ ":device_manager_test_common_public" ] + + public_deps = [ + "${utils_path}:devicemanagerutils", + "//foundation/communication/ipc/interfaces/innerkits/ipc_core:ipc_core", + "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", + "//foundation/distributedhardware/devicemanager/interfaces/kits/js:devicemanager", + "//foundation/distributedschedule/samgr/interfaces/innerkits/samgr_proxy:samgr_proxy", + "//third_party/googletest:gmock", + "//third_party/googletest:gtest", + "//utils/native/base:utils", + ] + + deps = [ + "${innerkits_path}/native_cpp:devicemanagersdk", + "${utils_path}:devicemanagerutils", + "//base/security/deviceauth/services:deviceauth_sdk", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + ] + + external_deps = [ + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "appexecfwk_standard:libeventhandler", + "ces_standard:cesfwk_core", + "ces_standard:cesfwk_innerkits", + "dsoftbus_standard:softbus_client", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_standard:samgr_proxy", + ] +} +## Build device_manager_test.a }}} diff --git a/test/unittest/UTTest_auth_request_state.cpp b/test/unittest/UTTest_auth_request_state.cpp new file mode 100644 index 0000000000000000000000000000000000000000..95c67b7a59d416e1a7b1b35e2036645007b93dd2 --- /dev/null +++ b/test/unittest/UTTest_auth_request_state.cpp @@ -0,0 +1,652 @@ +/* + * 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 "UTTest_auth_request_state.h" + +#include "dm_auth_manager.h" +#include "dm_constants.h" + +namespace OHOS { +namespace DistributedHardware { +void AuthRequestStateTest::SetUp() +{ +} +void AuthRequestStateTest::TearDown() +{ +} +void AuthRequestStateTest::SetUpTestCase() +{ +} +void AuthRequestStateTest::TearDownTestCase() +{ +} + +namespace { +std::string AUTHENTICATE_TIMEOUT_TASK = "authenticateTimeoutTask"; +std::string NEGOTIATE_TIMEOUT_TASK = "negotiateTimeoutTask"; +std::string CONFIRM_TIMEOUT_TASK = "confirmTimeoutTask"; +std::string INPUT_TIMEOUT_TASK = "inputTimeoutTask"; +std::string ADD_TIMEOUT_TASK = "addTimeoutTask"; + +/** + * @tc.name: AuthRequestInitState::SetAuthManager_001 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestInitState::SetAuthManager with authManager ！= null + * 3 check ret is authResponseState->authManager_.use_count() + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, SetAuthManager_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(authManager); + int32_t ret = authRequestState->authManager_.use_count(); + authRequestState->authManager_.reset(); + ASSERT_EQ(ret, 1); +} + +/** + * @tc.name: AuthRequestInitState::SetAuthManager_002 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestInitState::SetAuthManager with authManager = null + * 3 check ret is authResponseState->authManager_.use_count() + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, SetAuthManager_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->authManager_.use_count(); + authRequestState->authManager_.reset(); + ASSERT_EQ(ret, 0); +} + +/** + * @tc.name: AuthRequestNegotiateState::TransitionTo_001 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestInitState::TransitionTo with authManager = null + * 4 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, TransitionTo_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authManager = nullptr; + authRequestState->authManager_ = authManager; + int32_t ret = authRequestState->TransitionTo(std::make_shared()); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestInitState::TransitionTo_002 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestInitState::TransitionTo with authManager != null + * 4 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, TransitionTo_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr context = std::make_shared(); + std::shared_ptr authRequestState = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + context->sessionId = 123456; + authRequestState->SetAuthContext(context); + authRequestState->SetAuthManager(authManager); + int32_t ret = authRequestState->TransitionTo(std::make_shared()); + ASSERT_EQ(ret, DM_OK); + sleep(20); +} + +/** + * @tc.name: AuthRequestInitState::GetStateType_001 + * @tc.desc: 1 call AuthRequestInitState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_INIT); + sleep(15); +} + +/** + * @tc.name: AuthRequestInitState::Enter_001 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestInitState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authManager = nullptr; + authRequestState->SetAuthManager(authManager); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestInitState::Enter_002 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestInitState::Enter with authManager != null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authRequestState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->deviceId = "123456"; + authRequestState->SetAuthContext(context); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestNegotiateState::GetStateType_002 + * @tc.desc: 1 call AuthRequestNegotiateState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_NEGOTIATE + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE); + sleep(15); +} + +/** + * @tc.name: AuthRequestNegotiateState::Enter_001 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestNegotiateState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_003, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestNegotiateState::Enter_002 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestNegotiateState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_004, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authRequestContext_->deviceId = "111"; + authRequestState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->deviceId = "123456"; + context->sessionId = 22222; + authRequestState->SetAuthContext(context); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestNegotiateDoneState::GetStateType_003 + * @tc.desc: 1 call AuthRequestNegotiateDoneState::GetStateType + * 2 check ret is AuthState::AUTH_REQUEST_NEGOTIATE_DONE + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_003, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NEGOTIATE_DONE); + sleep(15); +} + +/** + * @tc.name: AuthRequestNegotiateDoneState::Enter_005 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestNegotiateDoneState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_005, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestNegotiateDoneState::Enter_006 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestNegotiateDoneState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_006, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + std::shared_ptr negotiateStartTimer = std::make_shared(NEGOTIATE_TIMEOUT_TASK); + authManager->timerMap_[NEGOTIATE_TIMEOUT_TASK] = negotiateStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_); + authRequestState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->sessionId = 333333; + authRequestState->SetAuthContext(context); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestReplyState::GetStateType_004 + * @tc.desc: 1 call AuthRequestReplyState::GetStateType + * 2 check ret is AuthState::AUTH_REQUEST_REPLY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_004, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_REPLY); + sleep(15); +} + +/** + * @tc.name: AuthRequestReplyState::Enter_007 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestReplyState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_007, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestReplyState::Enter_008 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestReplyState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_008, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + std::shared_ptr inputStartTimer = std::make_shared(CONFIRM_TIMEOUT_TASK); + authManager->timerMap_[CONFIRM_TIMEOUT_TASK] = inputStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseContext_->sessionId = 1; + authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_); + authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_); + authManager->SetAuthRequestState(authRequestState); + authRequestState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->sessionId = 333333; + authRequestState->SetAuthContext(context); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestInputState::GetStateType_005 + * @tc.desc: 1 call AuthRequestInputState::GetStateType + * 2 check ret is AuthState::AUTH_REQUEST_INPUT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_005, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_INPUT); + sleep(15); +} + +/** + * @tc.name: AuthRequestInputState::Enter_009 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestInputState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_009, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestInputState::Enter_010 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestInputState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_010, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(authManager); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestJoinState::GetStateType_006 + * @tc.desc: 1 call AuthRequestJoinState::GetStateType + * 2 check ret is AuthState::AUTH_REQUEST_JOIN + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_006, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_JOIN); + sleep(15); +} + +/** + * @tc.name: AuthRequestJoinState::Enter_011 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestJoinState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_011, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestJoinState::Enter_012 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestJoinState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_012, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + std::shared_ptr joinStartTimer = std::make_shared(ADD_TIMEOUT_TASK); + authManager->timerMap_[ADD_TIMEOUT_TASK] = joinStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObject; + authManager->authResponseContext_->groupId = "111"; + authManager->authResponseContext_->groupName = "222"; + authManager->authResponseContext_->code = 123; + authManager->authResponseContext_->requestId = 234; + authManager->authResponseContext_->deviceId = "234"; + jsonObject[TAG_GROUP_ID] = authManager->authResponseContext_->groupId; + jsonObject[TAG_GROUP_NAME] = authManager->authResponseContext_->groupName; + jsonObject[PIN_CODE_KEY] = authManager->authResponseContext_->code; + jsonObject[TAG_REQUEST_ID] = authManager->authResponseContext_->requestId; + jsonObject[TAG_DEVICE_ID] = authManager->authResponseContext_->deviceId; + authRequestState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->deviceId = "44444"; + context->sessionId = 55555; + authRequestState->SetAuthContext(context); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestNetworkState::GetStateType_007 + * @tc.desc: 1 call AuthRequestNetworkState::GetStateType + * 2 check ret is AuthState::AUTH_REQUEST_NETWORK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_007, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_NETWORK); + sleep(15); +} + +/** + * @tc.name: AuthRequestNetworkState::Enter_013 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestNetworkState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_013, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestNetworkState::Enter_014 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestNetworkState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_014, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr authenticateStartTimer = std::make_shared(AUTHENTICATE_TIMEOUT_TASK); + authManager->timerMap_[AUTHENTICATE_TIMEOUT_TASK] = authenticateStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->SetAuthRequestState(authRequestState); + authRequestState->SetAuthManager(authManager); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthRequestFinishState::GetStateType_008 + * @tc.desc: 1 call AuthRequestFinishState::GetStateType + * 2 check ret is AuthState::AUTH_REQUEST_FINISH + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, GetStateType_008, testing::ext::TestSize.Level0) +{ + std::shared_ptr authRequestState = std::make_shared(); + int32_t ret = authRequestState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_REQUEST_FINISH); + sleep(15); +} + +/** + * @tc.name: AuthRequestFinishState::Enter_015 + * @tc.desc: 1 set authManager to null + * 2 call AuthRequestFinishState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_015, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authRequestState->SetAuthManager(nullptr); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthRequestFinishState::Enter_016 + * @tc.desc: 1 set authManager not null + * 2 call AuthRequestNetworkState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthRequestStateTest, Enter_016, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + std::shared_ptr inputStartTimer = std::make_shared(CONFIRM_TIMEOUT_TASK); + authManager->timerMap_[CONFIRM_TIMEOUT_TASK] = inputStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseContext_->sessionId = 1; + authManager->authMessageProcessor_->SetResponseContext(authManager->authResponseContext_); + authManager->authMessageProcessor_->SetRequestContext(authManager->authRequestContext_); + authManager->SetAuthRequestState(authRequestState); + authRequestState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->sessionId = 333333; + authRequestState->SetAuthContext(context); + int32_t ret = authRequestState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/UTTest_auth_request_state.h b/test/unittest/UTTest_auth_request_state.h new file mode 100644 index 0000000000000000000000000000000000000000..118963122279a08193ec14aefd6cdf195ca09118 --- /dev/null +++ b/test/unittest/UTTest_auth_request_state.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_DM_AUTH_REQUEST_STATE_TEST_H +#define OHOS_DM_AUTH_REQUEST_STATE_TEST_H + +#include + +#include +#include +#include + +#include "auth_request_state.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +class AuthRequestStateTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/test/unittest/UTTest_auth_response_state.cpp b/test/unittest/UTTest_auth_response_state.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a1203f79f8c54bcd5d60bde95fd2d22d98aad379 --- /dev/null +++ b/test/unittest/UTTest_auth_response_state.cpp @@ -0,0 +1,459 @@ +/* + * 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 "UTTest_auth_response_state.h" + +#include "auth_response_state.h" +#include "dm_auth_manager.h" +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +void AuthResponseStateTest::SetUp() +{ +} +void AuthResponseStateTest::TearDown() +{ +} +void AuthResponseStateTest::SetUpTestCase() +{ +} +void AuthResponseStateTest::TearDownTestCase() +{ +} + +namespace { +/** + * @tc.name: AuthResponseInitState::SetAuthManager_001 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseInitState::SetAuthManager with authManager ！= null + * 3 check ret is authResponseState->authManager_.use_count() + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, SetAuthManager_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(authManager); + int32_t ret = authResponseState->authManager_.use_count(); + ASSERT_EQ(ret, 1); + sleep(15); +} + +/** + * @tc.name: AuthResponseInitState::SetAuthManager_002 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseInitState::SetAuthManager with authManager = null + * 3 check ret is authResponseState->authManager_.use_count() + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, SetAuthManager_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(nullptr); + int32_t ret = authResponseState->authManager_.use_count(); + ASSERT_EQ(ret, 0); + sleep(15); +} + +/** + * @tc.name: AuthResponseInitState::TransitionTo_001 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseInitState::TransitionTo with authManager = null + * 4 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, TransitionTo_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager = nullptr; + authResponseState->authManager_ = authManager; + int32_t ret = authResponseState->TransitionTo(std::make_shared();); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthResponseInitState::TransitionTo_002 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseInitState::TransitionTo with authManager != null + * 4 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, TransitionTo_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr context = std::make_shared(); + std::shared_ptr authRequestState = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + context->sessionId = 123456; + authRequestState->SetAuthContext(context); + authRequestState->SetAuthManager(authManager); + int32_t ret = authRequestState->TransitionTo(std::make_shared()); + ASSERT_EQ(ret, DM_OK); + sleep(20); +} + +/** + * @tc.name: AuthResponseInitState::GetStateType_001 + * @tc.desc: 1 call AuthResponseInitState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, GetStateType_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_INIT); + sleep(15); +} + +/** + * @tc.name: AuthResponseInitState::Enter_001 + * @tc.desc: 1 call AuthResponseInitState::GetStateType + * 2 check ret is AuthResponseInitState::Enter + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthResponseNegotiateState::GetStateType_002 + * @tc.desc: 1 call AuthResponseNegotiateState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_NEGOTIATE + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, GetStateType_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_NEGOTIATE); + sleep(15); +} + +/** + * @tc.name: AuthResponseNegotiateState::Enter_002 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseNegotiateState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager = nullptr; + authResponseState->SetAuthManager(authManager); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthResponseNegotiateState::Enter_003 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseNegotiateState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_003, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseContext_->deviceId = "111"; + authManager->authResponseContext_->localDeviceId = "222"; + authResponseState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + context->deviceId = "123456"; + context->sessionId = 22222; + authResponseState->SetAuthContext(context); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: AuthResponseConfirmState::GetStateType_003 + * @tc.desc: 1 call AuthResponseConfirmState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_CONFIRM + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, GetStateType_003, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_CONFIRM); + sleep(15); +} + +/** + * @tc.name: AuthResponseConfirmState::Enter_004 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseConfirmState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_004, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(nullptr); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthResponseConfirmState::Enter_005 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseConfirmState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_005, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(authManager); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthResponseGroupState::GetStateType_004 + * @tc.desc: 1 call AuthResponseGroupState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_GROUP + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, GetStateType_004, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_GROUP); + sleep(15); +} + +/** + * @tc.name: AuthResponseGroupState::Enter_006 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseGroupState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_006, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(nullptr); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthResponseGroupState::Enter_007 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseGroupState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_007, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authResponseState->SetAuthManager(authManager); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthResponseShowState::GetStateType_005 + * @tc.desc: 1 call AuthResponseShowState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_SHOW + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, GetStateType_005, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_SHOW); + sleep(15); +} + +/** + * @tc.name: AuthResponseShowState::Enter_008 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseShowState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_008, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(nullptr); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthResponseShowState::Enter_009 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseShowState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_009, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(authManager); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthResponseFinishState::GetStateType_006 + * @tc.desc: 1 call AuthResponseShowState::GetStateType + * 2 check ret is AuthState::AUTH_RESPONSE_SHOW + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, GetStateType_006, testing::ext::TestSize.Level0) +{ + std::shared_ptr authResponseState = std::make_shared(); + int32_t ret = authResponseState->GetStateType(); + ASSERT_EQ(ret, AuthState::AUTH_RESPONSE_FINISH); + sleep(15); +} + +/** + * @tc.name: AuthResponseFinishState::Enter_010 + * @tc.desc: 1 set authManager to null + * 2 call AuthResponseFinishState::Enter with authManager = null + * 3 check ret is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_010, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authResponseState->SetAuthManager(nullptr); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthResponseFinishState::Enter_011 + * @tc.desc: 1 set authManager not null + * 2 call AuthResponseFinishState::Enter with authManager != null + * 3 check ret is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthResponseStateTest, Enter_011, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->listener_ = std::make_shared(); + authManager->authResponseContext_->sessionId = 1; + authManager->authRequestContext_->deviceId = "2"; + authManager->authRequestContext_->hostPkgName = "3"; + authManager->authRequestContext_->token = "4"; + authManager->authResponseContext_->reply = 5; + authManager->authRequestContext_->reason = 6; + authManager->SetAuthResponseState(authResponseState); + authResponseState->SetAuthManager(authManager); + std::shared_ptr context = std::make_shared(); + authResponseState->SetAuthContext(context); + int32_t ret = authResponseState->Enter(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS diff --git a/common/include/device_manager_log.h b/test/unittest/UTTest_auth_response_state.h similarity index 65% rename from common/include/device_manager_log.h rename to test/unittest/UTTest_auth_response_state.h index fa0f776a3f3854f19842ed77b5d346af6a1fad52..270e5caffc55883f7b1f997f3dd97c2dc9e0642b 100644 --- a/common/include/device_manager_log.h +++ b/test/unittest/UTTest_auth_response_state.h @@ -13,17 +13,24 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_LOG_H -#define OHOS_DEVICE_MANAGER_LOG_H +#ifndef OHOS_AUTH_RESPONSE_STATE_TEST_H +#define OHOS_AUTH_RESPONSE_STATE_TEST_H -#include +#include -#include "dm_log.h" +#include + +#include "auth_response_state.h" namespace OHOS { namespace DistributedHardware { -#define DMLOG(level, fmt, ...) DMLog(level, \ - (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) +class AuthResponseStateTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LOG_H +#endif diff --git a/test/unittest/UTTest_device_manager_service.cpp b/test/unittest/UTTest_device_manager_service.cpp new file mode 100644 index 0000000000000000000000000000000000000000..dca38cabfe3544cf2878b358296a5c39d064d1c3 --- /dev/null +++ b/test/unittest/UTTest_device_manager_service.cpp @@ -0,0 +1,345 @@ +/* + * 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 "UTTest_device_manager_service.h" + +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService); + +void DeviceManagerServiceTest::SetUp() +{ +} + +void DeviceManagerServiceTest::TearDown() +{ +} + +void DeviceManagerServiceTest::SetUpTestCase() +{ +} + +void DeviceManagerServiceTest::TearDownTestCase() +{ +} + +namespace { +std::string INPUT_TIMEOUT_TASK = "inputTimeoutTask"; + +/** + * @tc.name: StartDeviceDiscovery_001 + * @tc.desc: Set StartDeviceDiscovery's flag bit intFlag_ to False and return DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::string pkgName = "com.ohos.test"; + DmSubscribeInfo subscribeInfo; + std::string extra = "test"; + int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name: StartDeviceDiscovery_002 + * @tc.desc: Empty pkgName of StartDeviceDiscovery and return DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0) +{ + std::string pkgName; + DmSubscribeInfo subscribeInfo; + std::string extra = "test"; + DeviceManagerService::GetInstance().Init(); + int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); + EXPECT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: StartDeviceDiscovery_003 + * @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return + * DM_DISCOVERY_REPEATED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.test"; + DmSubscribeInfo subscribeInfo; + std::string extra = "test"; + int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); + pkgName = "1com.ohos.test1"; + ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra); + EXPECT_EQ(ret, DM_DISCOVERY_FAILED); +} + +/** + * @tc.name: StopDeviceDiscovery_001 + * @tc.desc: Set StopDeviceDiscovery's flag bit intFlag_ to false and return DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::string pkgName = "com.ohos.test"; + uint16_t subscribeId = 1; + int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name:StopDeviceDiscovery_002 + * @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0) +{ + std::string pkgName; + uint16_t subscribeId = 1; + DeviceManagerService::GetInstance().Init(); + int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId); + EXPECT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: GetLocalDeviceInfo_001 + * @tc.desc: Set the flag bit of GetLocalDeviceInfo to intFlag_ to false; The return value is DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + DmDeviceInfo info; + int ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name:GetLocalDeviceInfo_002 + * @tc.desc: Initialize the GetLocalDeviceInfo function with the return value DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, GetLocalDeviceInfo_002, testing::ext::TestSize.Level0) +{ + DmDeviceInfo info; + DeviceManagerService::GetInstance().Init(); + int ret = DeviceManagerService::GetInstance().GetLocalDeviceInfo(info); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: Init_001 + * @tc.desc: The OnDeviceFound function does the worong case and return DM_INT_MULTIPLE + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, Init_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + int ret = DeviceManagerService::GetInstance().Init(); + EXPECT_EQ(ret, DM_INT_MULTIPLE); +} + +/** + * @tc.name: Init_002 + * @tc.desc: The OnDeviceFound function does the correct case and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, Init_002, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::shared_ptr softbusConnector_ = nullptr; + int ret = DeviceManagerService::GetInstance().Init(); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetTrustedDeviceList_001 + * @tc.desc: Set the intFlag of GetTrustedDeviceList to false. The return value is DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ + +HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::string pkgName = "com.ohos.test"; + std::string extra = "jdddd"; + std::vector deviceList; + int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name: GetTrustedDeviceList_002 + * @tc.desc:Set the intFlag of GetTrustedDeviceList to true and pkgName = null ; The return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, GetTrustedDeviceList_002, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + std::string pkgName; + std::string extra = "jdddd"; + std::vector deviceList; + int ret = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList); + EXPECT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: AuthenticateDevice_001 + * @tc.desc: 将GAuthenticateDevice的intFlag设置为false，设置pkgName = "com.ohos.test";其返回值为DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::string pkgName = "com.ohos.test"; + std::string extra = "jdddd"; + int32_t authType = 0; + std::string deviceId = " 2345"; + int ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name: AuthenticateDevice_002 + * @tc.desc: Set intFlag for GAuthenticateDevice to True and pkgName to null; The return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_002, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + std::string pkgName; + std::string extra = "jdddd"; + int32_t authType = 0; + std::string deviceId = " 2345"; + int ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); + EXPECT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: AuthenticateDevice_003 + * @tc.desc: Set intFlag for GAuthenticateDevice to true and pkgName to com.ohos.test; The return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, AuthenticateDevice_003, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + std::string pkgName = "com.ohos.test"; + std::string extra = "jdddd"; + int32_t authType = 0; + std::string deviceId = "123456"; + int ret = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: UnAuthenticateDevice_001 + * @tc.desc: 将UnAuthenticateDevice的intFlag设置为false，设置pkgName = "com.ohos.test";其返回值为DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::string pkgName = "com.ohos.test"; + std::string deviceId = "12345"; + int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name: UnAuthenticateDevice_002 + * @tc.desc: Set intFlag for UnAuthenticateDevice to True and pkgName to null; The return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_002, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + std::string pkgName; + std::string deviceId = "12345"; + int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId); + EXPECT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: UnAuthenticateDevice_003 + * @tc.desc: Set intFlag for UnAuthenticateDevice to true and pkgName to com.ohos.test; set deviceId null ，The return + * value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, UnAuthenticateDevice_003, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + std::string pkgName = "com.ohos.test"; + std::string deviceId; + int ret = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId); + EXPECT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: VerifyAuthentication_001 + * @tc.desc: Set intFlag for VerifyAuthentication to false and set authParam = "jdjjjj"，The return value is + * DM_NOT_INIT + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, VerifyAuthentication_001, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = false; + std::string authParam = "jdjjjj"; + int ret = DeviceManagerService::GetInstance().VerifyAuthentication(authParam); + EXPECT_EQ(ret, DM_NOT_INIT); +} + +/** + * @tc.name: VerifyAuthentication_002 + * @tc.desc:Set intFlag for VerifyAuthentication to true and set authParam = "jdjjjj"，The return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceTest, VerifyAuthentication_002, testing::ext::TestSize.Level0) +{ + DeviceManagerService::GetInstance().intFlag_ = true; + std::string authParam = "jdjjjj"; + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener_ = std::make_shared(); + DeviceManagerService::GetInstance().authMgr_ = std::make_shared(softbusConnector, listener_); + std::shared_ptr inputStartTimer = std::make_shared(INPUT_TIMEOUT_TASK); + DeviceManagerService::GetInstance().authMgr_->timerMap_[INPUT_TIMEOUT_TASK] = inputStartTimer; + int ret = DeviceManagerService::GetInstance().VerifyAuthentication(authParam); + EXPECT_EQ(ret, DM_FAILED); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/UTTest_device_manager_service.h b/test/unittest/UTTest_device_manager_service.h new file mode 100644 index 0000000000000000000000000000000000000000..66143efcdb30b348839122a49a8d0b955c74f280 --- /dev/null +++ b/test/unittest/UTTest_device_manager_service.h @@ -0,0 +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. + */ +#ifndef OHOS_UTTEST_DM_SERVICE_H +#define OHOS_UTTEST_DM_SERVICE_H + +#include +#include + +#include +#include + +#include "device_manager_service.h" +#include "device_manager_service_listener.h" +#include "dm_auth_manager.h" +#include "dm_device_info_manager.h" +#include "dm_device_state_manager.h" +#include "dm_discovery_manager.h" +#include "single_instance.h" +#include "softbus_connector.h" + +namespace OHOS { +namespace DistributedHardware { +class DeviceManagerServiceTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/test/unittest/UTTest_device_manager_service_listener.cpp b/test/unittest/UTTest_device_manager_service_listener.cpp new file mode 100644 index 0000000000000000000000000000000000000000..95e960faf98b0e0980a6be039b8938cc1964020c --- /dev/null +++ b/test/unittest/UTTest_device_manager_service_listener.cpp @@ -0,0 +1,112 @@ +/* + * 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 "UTTest_device_manager_service_listener.h" + +#include + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "ipc_notify_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_verify_auth_result_req.h" + +namespace OHOS { +namespace DistributedHardware { +void DeviceManagerServiceListenerTest::SetUp() +{ +} +void DeviceManagerServiceListenerTest::TearDown() +{ +} +void DeviceManagerServiceListenerTest::SetUpTestCase() +{ +} +void DeviceManagerServiceListenerTest::TearDownTestCase() +{ +} + +namespace { +/** + * @tc.name: OnDeviceStateChange_001 + * @tc.desc: OnDeviceStateChange, construct a dummy listener, pass in pkgName, use the constructed listener to get + * deviceTypeId + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceStateChange_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + DmDeviceState state = DEVICE_STATE_ONLINE; + DmDeviceInfo info = { + .deviceId = "asdad", + .deviceName = "asda", + .deviceTypeId = 1, + }; + listener_->OnDeviceStateChange(pkgName, state, info); + std::shared_ptr pReq = + std::static_pointer_cast(listener_->ipcServerListener_.req_); + int32_t dmState = pReq->GetDeviceState(); + EXPECT_EQ(1, dmState); +} + +/** + * @tc.name: OnAuthResult_001 + * @tc.desc:OnAuthResult, construct a dummy listener, pass in pkgName, use the constructed listener to get pkgName + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnAuthResult_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + std::string deviceId = "dkdkd"; + std::string token = "kdkddk"; + int32_t status = 3; + std::string reason = "kddk"; + listener_->OnAuthResult(pkgName, deviceId, token, status, reason); + std::shared_ptr pReq = + std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ(ret, pkgName); +} + +/** + * @tc.name: OnVerifyAuthResult_001 + * @tc.desc: OnVerifyAuthResult,construct a dummy listener, pass in pkgName, use the constructed listener to get + * deviceId + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerServiceListenerTest, OnVerifyAuthResult_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr listener_ = std::make_shared(); + std::string pkgName = "com.ohos.helloworld"; + std::string deviceId = "dkdkd"; + int32_t resultCode = 1; + std::string flag = "true"; + listener_->OnVerifyAuthResult(pkgName, deviceId, resultCode, flag); + std::shared_ptr pReq = + std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetDeviceId(); + EXPECT_EQ(ret, deviceId); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_device_manager_service_listener.h b/test/unittest/UTTest_device_manager_service_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..47049207828ef95b4a67f988391b6f3894591261 --- /dev/null +++ b/test/unittest/UTTest_device_manager_service_listener.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_UTTEST_DM_SERVICE_LISTENER_H +#define OHOS_UTTEST_DM_SERVICE_LISTENER_H + +#define private public +#define protected public + +#include +#include + +#include + +#include "device_manager_service_listener.h" +#include "dm_device_info.h" +#include "ipc_server_listener.h" + +namespace OHOS { +namespace DistributedHardware { +class DeviceManagerServiceListenerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#undef private +#undef protected +#endif \ No newline at end of file diff --git a/test/unittest/UTTest_device_message.cpp b/test/unittest/UTTest_device_message.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a6d928afd207078eecfcad381f8ea02f229bd17f --- /dev/null +++ b/test/unittest/UTTest_device_message.cpp @@ -0,0 +1,513 @@ +/* + * 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 "dm_constants.h" +#include "UTTest_device_message.h" +#include "auth_message_processor.h" +#include "softbus_connector.h" +#include "softbus_session.h" +#include "dm_auth_manager.h" + +namespace OHOS { +namespace DistributedHardware { +void AuthMessageProcessorTest::SetUp() +{ +} +void AuthMessageProcessorTest::TearDown() +{ +} +void AuthMessageProcessorTest::SetUpTestCase() +{ +} +void AuthMessageProcessorTest::TearDownTestCase() +{ +} + +namespace { +/** + * @tc.name: AuthMessageProcessor::CreateNegotiateMessage_001 + * @tc.desc: 1 set cryptoAdapter_ to null + * 2 call AuthMessageProcessor::CreateNegotiateMessage_001 with cryptoAdapter_ = nullptr + * 3 check ret is authMessageProcessor->CreateNegotiateMessage(jsonObj); + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, CreateNegotiateMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + int32_t msgType = MSG_TYPE_NEGOTIATE; + nlohmann::json jsonObj; + jsonObj[TAG_VER] = DM_ITF_VER; + jsonObj[TAG_TYPE] = msgType; + authMessageProcessor->cryptoAdapter_ = nullptr; + authMessageProcessor->CreateNegotiateMessage(jsonObj); + std::string str1 = jsonObj.dump(); + nlohmann::json jsonObject; + jsonObject[TAG_VER] = DM_ITF_VER; + jsonObject[TAG_TYPE] = msgType; + jsonObject[TAG_CRYPTO_SUPPORT] = false; + std::string str2 = jsonObject.dump(); + ASSERT_EQ(str1, str2); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::CreateSyncGroupMessage_001 + * @tc.desc: Compare JSON before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, CreateSyncGroupMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + authMessageProcessor->authRequestContext_= std::make_shared(); + nlohmann::json jsona; + nlohmann::json jsonObj; + authMessageProcessor->authRequestContext_->deviceId = "132416546"; + std::vector syncGroupList ; + syncGroupList.push_back("1111"); + authMessageProcessor->authRequestContext_->syncGroupList = syncGroupList; + jsona[TAG_DEVICE_ID] = authMessageProcessor->authRequestContext_->deviceId; + jsona[TAG_GROUPIDS] = authMessageProcessor->authRequestContext_->syncGroupList; + authMessageProcessor->CreateSyncGroupMessage(jsonObj); + std::string str1 = jsona.dump(); + std::string str2 = jsonObj.dump(); + ASSERT_EQ(str1, str2); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::CreateResponseAuthMessage_001 + * @tc.desc: Compare JSON before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, CreateResponseAuthMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsona; + nlohmann::json jsonObj; + authMessageProcessor->authResponseContext_->reply = 0; + authMessageProcessor->authResponseContext_->deviceId = "132416546"; + nlohmann::json jsonb; + jsonb[TAG_GROUP_ID] = "123456"; + authMessageProcessor->authResponseContext_->groupId = jsonb.dump(); + authMessageProcessor->authResponseContext_->code = 1; + authMessageProcessor->authResponseContext_->networkId = "11112222"; + authMessageProcessor->authResponseContext_->requestId = 222222; + authMessageProcessor->authResponseContext_->groupName = "333333"; + jsona[TAG_REPLY] = authMessageProcessor->authResponseContext_->reply; + jsona[TAG_DEVICE_ID] = authMessageProcessor->authResponseContext_->deviceId; + jsona[PIN_CODE_KEY] = authMessageProcessor->authResponseContext_->code; + jsona[TAG_NET_ID] = authMessageProcessor->authResponseContext_->networkId; + jsona[TAG_REQUEST_ID] = authMessageProcessor->authResponseContext_->requestId; + jsona[TAG_GROUP_ID] = "123456"; + jsona[TAG_GROUP_NAME] = authMessageProcessor->authResponseContext_->groupName; + authMessageProcessor->CreateResponseAuthMessage(jsonObj); + std::string str1 = jsona.dump(); + std::string str2 = jsonObj.dump(); + ASSERT_EQ(str1, str2); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::CreateResponseFinishMessage_001 + * @tc.desc: Compare JSON before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, CreateResponseFinishMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsona; + nlohmann::json jsonObj; + authMessageProcessor->authResponseContext_->reply= 1; + jsona[TAG_REPLY] = authMessageProcessor->authResponseContext_->reply; + authMessageProcessor->CreateResponseFinishMessage(jsonObj); + std::string str1 = jsona.dump(); + std::string str2 = jsonObj.dump(); + ASSERT_EQ(str1, str2); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseResponseFinishMessage_001 + * @tc.desc: Compare JSON before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseResponseFinishMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext= std::make_shared(); + authMessageProcessor->authResponseContext_= std::make_shared(); + nlohmann::json jsonObj; + authMessageProcessor->authResponseContext_->reply = 1; + jsonObj[TAG_REPLY] = authMessageProcessor->authResponseContext_->reply; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseResponseFinishMessage(jsonObj); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseAuthResponseMessage_001 + * @tc.desc: Compare JSON before and after assi gnment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseAuthResponseMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + nlohmann::json jsona; + authResponseContext->reply = 0; + authResponseContext->deviceId = "11111"; + authResponseContext->code = 1; + authResponseContext->networkId = "12345"; + authResponseContext->requestId = 2; + authResponseContext->groupId = "23456"; + authResponseContext->groupName = "34567"; + jsona[TAG_REPLY] = authResponseContext->reply; + jsona[TAG_DEVICE_ID] = authResponseContext->deviceId; + jsona[PIN_CODE_KEY] = authResponseContext->code; + jsona[TAG_NET_ID] = authResponseContext->networkId; + jsona[TAG_REQUEST_ID] = authResponseContext->requestId; + jsona[TAG_GROUP_ID] = authResponseContext->groupId; + jsona[TAG_GROUP_NAME] = authResponseContext->groupName; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseAuthResponseMessage(jsona); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseAuthRequestMessage_001 + * @tc.desc: Compare JSON before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseAuthRequestMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->SetResponseContext(authResponseContext); + nlohmann::json json; + nlohmann::json jsonThumbnail; + authResponseContext->deviceId = "123"; + authResponseContext->reply = 0; + authResponseContext->authType = 222; + authResponseContext->networkId = "234"; + authResponseContext->groupId = "345"; + authResponseContext->groupName = "456"; + authResponseContext->requestId = 2333; + jsonThumbnail[TAG_DEVICE_ID] = authResponseContext->deviceId; + jsonThumbnail[TAG_REPLY] = authResponseContext->reply; + jsonThumbnail[TAG_AUTH_TYPE] = authResponseContext->authType; + jsonThumbnail[TAG_NET_ID] = authResponseContext->networkId; + jsonThumbnail[TAG_GROUP_ID] = authResponseContext->groupId ; + jsonThumbnail[TAG_GROUP_NAME] = authResponseContext->groupName; + jsonThumbnail[TAG_REQUEST_ID] = authResponseContext->requestId; + authMessageProcessor->authSplitJsonList_.push_back(jsonThumbnail); + int32_t ret = authMessageProcessor->ParseAuthRequestMessage(); + ASSERT_EQ(ret, DM_FAILED); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseAuthRequestMessage_002 + * @tc.desc: Compare JSON before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseAuthRequestMessage_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->SetResponseContext(authResponseContext); + nlohmann::json json; + nlohmann::json jsonThumbnail; + authResponseContext->deviceId = "123"; + authResponseContext->reply = 1; + authResponseContext->authType = 222; + authResponseContext->networkId = "234"; + authResponseContext->groupId = "345"; + authResponseContext->groupName = "456"; + authResponseContext->requestId = 2333; + jsonThumbnail[TAG_DEVICE_ID] = authResponseContext->deviceId; + jsonThumbnail[TAG_REPLY] = authResponseContext->reply; + jsonThumbnail[TAG_AUTH_TYPE] = authResponseContext->authType; + jsonThumbnail[TAG_NET_ID] = authResponseContext->networkId; + jsonThumbnail[TAG_GROUP_ID] = authResponseContext->groupId ; + jsonThumbnail[TAG_GROUP_NAME] = authResponseContext->groupName; + jsonThumbnail[TAG_REQUEST_ID] = authResponseContext->requestId; + authMessageProcessor->authSplitJsonList_.push_back(jsonThumbnail); + int32_t ret = authMessageProcessor->ParseAuthRequestMessage(); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseNegotiateMessage_001 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObj; + jsonObj[TAG_CRYPTO_SUPPORT]="CRYPTOSUPPORT"; + jsonObj[TAG_CRYPTO_SUPPORT] = authMessageProcessor->authResponseContext_->cryptoSupport; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseNegotiateMessage(jsonObj); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseNegotiateMessage_002 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObj; + jsonObj[TAG_CRYPTO_NAME]="CRYPTONAME"; + jsonObj[TAG_CRYPTO_NAME] = authResponseContext->cryptoSupport; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseNegotiateMessage(jsonObj); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseNegotiateMessage_003 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_003, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObj; + jsonObj[TAG_CRYPTO_VERSION]="CRYPTOVERSION"; + jsonObj[TAG_CRYPTO_VERSION] = authResponseContext->cryptoSupport; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseNegotiateMessage(jsonObj); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseNegotiateMessage_004 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_004, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObj; + jsonObj[TAG_DEVICE_ID]="DEVICEID"; + jsonObj[TAG_DEVICE_ID] = authResponseContext->deviceId; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseNegotiateMessage(jsonObj); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::ParseNegotiateMessage_005 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, ParseNegotiateMessage_005, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor= std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObj; + jsonObj[TAG_LOCAL_DEVICE_ID]="LOCALDEVICEID"; + jsonObj[TAG_LOCAL_DEVICE_ID] = authResponseContext->localDeviceId; + authMessageProcessor->SetResponseContext(authResponseContext); + authMessageProcessor->ParseNegotiateMessage(jsonObj); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::SetRequestContext_001 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, SetRequestContext_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor = std::make_shared(data); + std::shared_ptr authRequestContext = std::make_shared(); + authMessageProcessor->SetRequestContext(authRequestContext); + ASSERT_EQ(authMessageProcessor->authRequestContext_, authRequestContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::SetRequestContext_002 + * @tc.desc: Judge whether authrequestcontext is empty + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, SetRequestContext_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor = std::make_shared(data); + std::shared_ptr authRequestContext = std::make_shared(); + authMessageProcessor->SetRequestContext(nullptr); + ASSERT_EQ(authMessageProcessor->authRequestContext_, nullptr); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::SetResponseContext_001 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, SetResponseContext_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor = std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->SetResponseContext(authResponseContext); + ASSERT_EQ(authMessageProcessor->authResponseContext_, authResponseContext); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::SetResponseContext_002 + * @tc.desc: Judge whether authrequestcontext is empty + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, SetResponseContext_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor = std::make_shared(data); + std::shared_ptr authResponseContext = std::make_shared(); + authMessageProcessor->SetResponseContext(nullptr); + ASSERT_EQ(authMessageProcessor->authResponseContext_, nullptr); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::GetResponseContext_001 + * @tc.desc: Compare authResponseContext before and after assignment + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, GetResponseContext_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor = std::make_shared(data); + authMessageProcessor->authResponseContext_ = std::make_shared(); + std::shared_ptr authResponseContext = authMessageProcessor->GetResponseContext(); + ASSERT_EQ(authResponseContext, authMessageProcessor->authResponseContext_); + sleep(15); +} + +/** + * @tc.name: AuthMessageProcessor::GetResponseContext_002 + * @tc.desc: Judge whether authrequestcontext is empty + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(AuthMessageProcessorTest, GetResponseContext_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr data = std::make_shared(softbusConnector, listener); + std::shared_ptr authMessageProcessor = std::make_shared(data); + authMessageProcessor->authResponseContext_ = std::make_shared(); + std::shared_ptr authResponseContext = authMessageProcessor->GetResponseContext(); + ASSERT_NE(authResponseContext, nullptr); + sleep(15); +} +} +} +} diff --git a/services/devicemanagerservice/include/message/msg_sync_group.h b/test/unittest/UTTest_device_message.h similarity index 57% rename from services/devicemanagerservice/include/message/msg_sync_group.h rename to test/unittest/UTTest_device_message.h index a19d8ff5431d6ce9f610fbfdd36f9b42c206f29f..1e6e647f12c83eb07058e271a3c4d5c67868063b 100644 --- a/services/devicemanagerservice/include/message/msg_sync_group.h +++ b/test/unittest/UTTest_device_message.h @@ -13,33 +13,24 @@ * limitations under the License. */ -#ifndef OHOS_MSG_SYNC_GROUP_H -#define OHOS_MSG_SYNC_GROUP_H +#ifndef OHOS_DEVICE_MESSAGE_TEST_H +#define OHOS_DEVICE_MESSAGE_TEST_H +#include #include -#include - +#include #include "nlohmann/json.hpp" - -#include "msg_head.h" +#include "auth_message_processor.h" namespace OHOS { namespace DistributedHardware { -class MsgSyncGroup { +class AuthMessageProcessorTest : public testing::Test { public: - MsgSyncGroup() {}; - MsgSyncGroup(std::vector &groupList, std::string &deviceId); - ~MsgSyncGroup() = default; - void Encode(nlohmann::json &json); - int32_t Decode(nlohmann::json &json); - std::string GetDeviceId(); - std::vector GetGroupIdList(); - -private: - std::shared_ptr mHead_; - std::string mDeviceId_; - std::vector mGroupIdList_; + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; }; } } -#endif \ No newline at end of file +#endif // OHOS_DEVICE_MESSAGE_TEST_H \ No newline at end of file diff --git a/test/unittest/UTTest_dm_auth_manager.cpp b/test/unittest/UTTest_dm_auth_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..037917585648b0ff63fe342866fe8b438c6e86c0 --- /dev/null +++ b/test/unittest/UTTest_dm_auth_manager.cpp @@ -0,0 +1,565 @@ +/* + * 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_auth_manager.h" + +#include "nlohmann/json.hpp" + +#include "dm_log.h" +#include "dm_constants.h" +#include "auth_message_processor.h" +#include "UTTest_dm_auth_manager.h" + +namespace OHOS { +namespace DistributedHardware { +void DmAuthManagerTest::SetUp() +{ +} +void DmAuthManagerTest::TearDown() +{ +} +void DmAuthManagerTest::SetUpTestCase() +{ +} +void DmAuthManagerTest::TearDownTestCase() +{ +} + +namespace { + std::string AUTHENTICATE_TIMEOUT_TASK = "authenticateTimeoutTask"; + std::string NEGOTIATE_TIMEOUT_TASK = "negotiateTimeoutTask"; + std::string CONFIRM_TIMEOUT_TASK = "confirmTimeoutTask"; + std::string INPUT_TIMEOUT_TASK = "inputTimeoutTask"; + std::string ADD_TIMEOUT_TASK = "addTimeoutTask"; + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_001 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_AUTH_BUSINESS_BUSY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr context = std::make_shared(); + std::string pkgName = "111"; + int32_t authType = 1; + std::string deviceId = "222"; + std::string extra = "333"; + authRequestState->SetAuthContext(context); + authManager->SetAuthRequestState(authRequestState); + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_AUTH_BUSINESS_BUSY); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_002 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_AUTH_BUSINESS_BUSY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + std::shared_ptr context = std::make_shared(); + const std::string pkgName = "111"; + int32_t authType = 1; + const std::string deviceId = "222"; + const std::string extra = "333"; + authResponseState->SetAuthContext(context); + authManager->SetAuthResponseState(authResponseState); + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_AUTH_BUSINESS_BUSY); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_003 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_003, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + std::string pkgName = "111"; + int32_t authType = 1; + std::string deviceId = "222"; + std::string extra = ""; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_004 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_004, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + nlohmann::json json; + const std::string pkgName = "111"; + int32_t authType = 4; + const std::string deviceId = "222"; + const std::string extra = "targetPkgName"; + authRequestContext->targetPkgName = "targetPkgName"; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_INPUT_PARA_EMPTY); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_005 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_005, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + nlohmann::json json; + const std::string pkgName = "111"; + int32_t authType = 1; + const std::string deviceId = "222"; + const std::string extra = "targetPkgName"; + authRequestContext->targetPkgName = "targetPkgName"; + json[TARGET_PKG_NAME_KEY] = authRequestContext->targetPkgName; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_006 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_006, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + nlohmann::json json; + const std::string pkgName = "111"; + int32_t authType = 1; + const std::string deviceId = "222"; + const std::string extra = "appName"; + authRequestContext->targetPkgName = "appName"; + json[APP_NAME_KEY] = authRequestContext->targetPkgName; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_007 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_007, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + nlohmann::json json; + const std::string pkgName = "111"; + int32_t authType = 1; + const std::string deviceId = "222"; + const std::string extra = "appDescription"; + authRequestContext->targetPkgName = "appDescription"; + json[APP_DESCRIPTION_KEY] = authRequestContext->targetPkgName; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_008 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_008, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + nlohmann::json json; + const std::string pkgName = "111"; + int32_t authType = 1; + const std::string deviceId = "222"; + const std::string extra = "appThumbnail"; + authRequestContext->targetPkgName = "appThumbnail"; + json[APP_THUMBNAIL] = authRequestContext->targetPkgName; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::AuthenticateDevice_009 + * @tc.desc: Call authenticatedevice to check whether the return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AuthenticateDevice_009, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + nlohmann::json json; + const std::string pkgName = "111"; + int32_t authType = 1; + const std::string deviceId = "222"; + const std::string extra = "appIcon"; + authRequestContext->targetPkgName = "appIcon"; + json[APP_ICON_KEY] = authRequestContext->targetPkgName; + int32_t ret = authManager->AuthenticateDevice(pkgName, authType, deviceId, extra); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::UnAuthenticateDevice_001 + * @tc.desc: Call unauthenticateddevice to check whether the return value is DM_ FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, UnAuthenticateDevice_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + std::string pkgName = ""; + std::string deviceId = "222"; + int32_t ret = authManager->UnAuthenticateDevice(pkgName, deviceId); + ASSERT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: DmAuthManager::VerifyAuthentication_001 + * @tc.desc: Call verifyauthentication to check whether the return value is DM_ FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, VerifyAuthentication_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr negotiateStartTimer = std::make_shared(INPUT_TIMEOUT_TASK); + authManager->timerMap_[INPUT_TIMEOUT_TASK] = negotiateStartTimer; + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseContext_=nullptr; + authManager->SetAuthRequestState(authRequestState); + int32_t ret = authManager->HandleAuthenticateTimeout(); + ASSERT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: DmAuthManager::HandleAuthenticateTimeout_001 + * @tc.desc: authResponseContext_= nullptr; Call handleauthenticatemeout to check whether the return value is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseContext_=nullptr; + authManager->SetAuthRequestState(authRequestState); + int32_t ret = authManager->HandleAuthenticateTimeout(); + ASSERT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: DmAuthManager::HandleAuthenticateTimeout_002 + * @tc.desc: authResponseContext_= nullptr; Call handleauthenticatemeout to check whether the return value is DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, HandleAuthenticateTimeout_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->SetAuthRequestState(authRequestState); + int32_t ret = authManager->HandleAuthenticateTimeout(); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::EstablishAuthChannel_001 + * @tc.desc: Call establishauthchannel to check whether the return value is DM_ FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, EstablishAuthChannel_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr sessionSession = std::shared_ptr(); + std::shared_ptr authRequestContext = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + std::string deviceId1; + int32_t ret = authManager->EstablishAuthChannel(deviceId1); + ASSERT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: DmAuthManager::SendAuthRequest_001 + * @tc.desc: Cryptosupport = true call sendauthrequest to check whether the return value is DM_ FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, SendAuthRequest_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr negotiateStartTimer = std::make_shared(NEGOTIATE_TIMEOUT_TASK); + authManager->timerMap_[NEGOTIATE_TIMEOUT_TASK] = negotiateStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared();; + authManager->authRequestState_ = std::make_shared(); + authManager->authResponseContext_->cryptoSupport = true; + authManager->SetAuthRequestState(authRequestState); + int32_t sessionId=1; + int32_t ret = authManager->SendAuthRequest(sessionId); + ASSERT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: DmAuthManager::StartAuthProcess_001 + * @tc.desc: Whether the return value of calling startauthprocess is DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, StartAuthProcess_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->SetAuthResponseState(authResponseState); + int32_t action = 0; + int32_t ret = authManager->StartAuthProcess(action); + ASSERT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: DmAuthManager::StartAuthProcess_002 + * @tc.desc: Whether the return value of calling startauthprocess is DM_ OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, StartAuthProcess_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->SetAuthResponseState(authResponseState); + authManager->authResponseContext_->sessionId=111; + int32_t action = 1; + int32_t ret = authManager->StartAuthProcess(action); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::CreateGroup_001 + * @tc.desc: Whether the return value of calling creategroup is DM_ OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, CreateGroup_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->SetAuthResponseState(authResponseState); + authManager->authResponseContext_->requestId=111; + authManager->authResponseContext_->groupName="111"; + int32_t action = 1; + int32_t ret = authManager->StartAuthProcess(action); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::AddMember_001 + * @tc.desc: Whether the return value of calling addmember is DM_ OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, AddMember_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + std::shared_ptr hiChainConnector = std::make_shared(); + std::shared_ptr joinStartTimer = std::make_shared(ADD_TIMEOUT_TASK); + authManager->timerMap_[ADD_TIMEOUT_TASK] = joinStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + nlohmann::json jsonObject; + authManager->authResponseContext_->groupId="111"; + authManager->authResponseContext_->groupName="222"; + authManager->authResponseContext_->code=123; + authManager->authResponseContext_->requestId=234; + authManager->authResponseContext_->deviceId="234"; + jsonObject[TAG_GROUP_ID] = authManager->authResponseContext_->groupId; + jsonObject[TAG_GROUP_NAME] = authManager->authResponseContext_->groupName; + jsonObject[PIN_CODE_KEY] = authManager->authResponseContext_->code; + jsonObject[TAG_REQUEST_ID] = authManager->authResponseContext_->requestId; + jsonObject[TAG_DEVICE_ID] = authManager->authResponseContext_->deviceId; + std::string deviceId = "44444"; + authManager->SetAuthResponseState(authResponseState); + int32_t ret = authManager->AddMember(deviceId); + ASSERT_EQ(ret, DM_OK); + sleep(15); +} + +/** + * @tc.name: DmAuthManager::JoinNetwork_001 + * @tc.desc: Whether the return value of calling joinnetwork is DM_ OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, JoinNetwork_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authRequestState = std::make_shared(); + std::shared_ptr authenticateStartTimer = std::make_shared(AUTHENTICATE_TIMEOUT_TASK); + authManager->timerMap_[AUTHENTICATE_TIMEOUT_TASK] = authenticateStartTimer; + authManager->authMessageProcessor_ = std::make_shared(authManager); + authManager->authResponseContext_ = std::make_shared(); + authManager->authRequestContext_ = std::make_shared(); + authManager->authRequestState_ = std::make_shared(); + authManager->SetAuthRequestState(authRequestState); + int32_t ret = authManager->JoinNetwork(); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::GetIsCryptoSupport_001 + * @tc.desc: authResponseState_ Equal to nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, GetIsCryptoSupport_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + authManager->authResponseState_ = std::make_shared(); + bool isCryptoSupport = false; + int32_t ret = authManager->GetIsCryptoSupport(isCryptoSupport); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::SetAuthResponseState_001 + * @tc.desc: Is the authresponsestate assignment successful + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, SetAuthResponseState_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + std::shared_ptr authResponseState = std::make_shared(); + authManager->authResponseState_ = std::make_shared(); + authManager->SetAuthResponseState(authResponseState); + int32_t ret = authManager->SetAuthResponseState(authResponseState); + ASSERT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DmAuthManager::GetPinCode_001 + * @tc.desc: Return authresponsecontext - > code + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmAuthManagerTest, GetPinCode_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr listener = std::make_shared(); + std::shared_ptr authManager = std::make_shared(softbusConnector, listener); + authManager->authResponseContext_ = std::make_shared();; + int32_t ret = authManager->GetPinCode(); + ASSERT_EQ(ret, authManager->authResponseContext_->code); +} +} +} +} diff --git a/test/unittest/UTTest_dm_auth_manager.h b/test/unittest/UTTest_dm_auth_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..19952e4f1f487f9ba39ab465a1d83208b6141902 --- /dev/null +++ b/test/unittest/UTTest_dm_auth_manager.h @@ -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. + */ + +#ifndef OHOS_DM_AUTH_MANAGER_TEST_H +#define OHOS_DM_AUTH_MANAGER_TEST_H + +#include +#include +#include + +#include "authentication.h" +#include "softbus_session.h" +#include "device_manager_service_listener.h" +#include "dm_adapter_manager.h" +#include "dm_constants.h" +#include "softbus_connector.h" +#include "hichain_connector.h" +#include "auth_request_state.h" +#include "auth_response_state.h" +#include "auth_message_processor.h" +#include "dm_timer.h" +#include "dm_auth_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class DmAuthManagerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/test/unittest/UTTest_dm_device_info_manager.cpp b/test/unittest/UTTest_dm_device_info_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..78eb44e895c53c947dcaf0f26a113a58569595e6 --- /dev/null +++ b/test/unittest/UTTest_dm_device_info_manager.cpp @@ -0,0 +1,59 @@ +/* + * 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 "UTTest_dm_device_info_manager.h" + +#include "dm_constants.h" +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +void DeviceManagerImplTest::SetUp() +{ +} + +void DeviceManagerImplTest::TearDown() +{ +} + +void DeviceManagerImplTest::SetUpTestCase() +{ +} + +void DeviceManagerImplTest::TearDownTestCase() +{ +} + +namespace { +std::shared_ptr softbusConnector = std::make_shared(); +std::shared_ptr listener_ = std::make_shared(); +std::shared_ptr dmDeviceStateManager = std::make_shared(softbusConnector); + +/** + * @tc.name: DmDeviceInfoManager_001 + * @tc.desc: Returns a new pointer to the constructor DmDeviceInfoManager new + * to construct an environment where the device has been discovered, and stop discovering + * the device. Its return value is DM_INPUT_PARA_EMPTY + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DeviceManagerImplTest, DmDeviceInfoManager_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr p = std::make_shared(softbusConnector); + ASSERT_NE(p, nullptr); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_dm_device_info_manager.h b/test/unittest/UTTest_dm_device_info_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..ea6f69e22c8b69f0f49a5f4c5b449489b42c2d44 --- /dev/null +++ b/test/unittest/UTTest_dm_device_info_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_UTTEST_DM_DEVICEINFO_MANAGER_H +#define OHOS_UTTEST_DM_DEVICEINFO_MANAGER_H + +#include +#include + +#include +#include + +#include "device_manager_service_listener.h" +#include "dm_adapter_manager.h" +#include "dm_device_info.h" +#include "dm_device_info_manager.h" +#include "softbus_connector.h" +#include "softbus_session_callback.h" + +namespace OHOS { +namespace DistributedHardware { +class DeviceManagerImplTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/test/unittest/UTTest_dm_device_state_manager.cpp b/test/unittest/UTTest_dm_device_state_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d2e15740210bd02a5a67b137e3ee77489467338b --- /dev/null +++ b/test/unittest/UTTest_dm_device_state_manager.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 + +#include "dm_log.h" +#include "dm_constants.h" +#include "dm_adapter_manager.h" +#include "ipc_notify_device_state_req.h" +#include "ipc_notify_auth_result_req.h" +#include "ipc_notify_verify_auth_result_req.h" +#include "dm_device_state_manager.h" +#include "ipc_notify_device_found_req.h" +#include "ipc_notify_discover_result_req.h" +#include "UTTest_dm_device_state_manager.h" + +namespace OHOS { +namespace DistributedHardware { +void DmDeviceStateManagerTest::SetUp() +{ +} + +void DmDeviceStateManagerTest::TearDown() +{ +} + +void DmDeviceStateManagerTest::SetUpTestCase() +{ +} + +void DmDeviceStateManagerTest::TearDownTestCase() +{ +} +namespace { +std::shared_ptr softbusConnector = std::make_shared(); +std::shared_ptr listener_ = std::make_shared(); +std::shared_ptr dmDeviceStateManager = std::make_shared(softbusConnector, listener_); + +/** + * @tc.name: DmDeviceStateManager_001 + * @tc.desc: set DmDeviceStateManager to tne new pointer,and it's not nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, DmDeviceStateManager_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr p = std::make_shared(softbusConnector, listener_); + ASSERT_NE(p, nullptr); +} + +/** + * @tc.name: DmDeviceStateManager_002 + * @tc.desc: set DmDeviceStateManager to tne new pointer,it's not nullptr and delete it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, DmDeviceStateManager_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr p = std::make_shared(softbusConnector, listener_); + p.reset(); + EXPECT_EQ(p, nullptr); +} + +/** + * @tc.name: OnDeviceOnline_001 + * @tc.desc: set info.deviceId to some para, and return it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, OnDeviceOnline_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "123"; + DmDeviceInfo info ; + strncpy (info.deviceId, "123", sizeof(info.deviceId)); + dmDeviceStateManager->OnDeviceOnline(pkgName, info); + std::shared_ptr pReq = std::static_pointer_cast (listener_->ipcServerListener_.req_); + DmDeviceInfo ret = pReq->GetDeviceInfo(); + int result = strcmp(info.deviceId, ret.deviceId); + EXPECT_EQ(result, 0); +} + +/** + * @tc.name: OnDeviceOffline_001 + * @tc.desc: set info.deviceId to some para, and return it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, OnDeviceOffline_001, testing::ext::TestSize.Level0) +{ + std::string pkgName; + DmDeviceInfo info; + strncpy(info.deviceId, "123", sizeof(info.deviceId)); + dmDeviceStateManager->OnDeviceOffline(pkgName, info); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + DmDeviceInfo ret = pReq->GetDeviceInfo(); + int result = strcmp(info.deviceId, ret.deviceId); + EXPECT_EQ(result, 0); +} + +/** + * @tc.name: OnDeviceChanged_001 + * @tc.desc: set info.deviceId to some para, and return it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, OnDeviceChanged_001, testing::ext::TestSize.Level0) +{ + std::string pkgName; + DmDeviceInfo info ; + strncpy (info.deviceId, "123", sizeof(info.deviceId)); + dmDeviceStateManager->OnDeviceChanged(pkgName, info); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + DmDeviceInfo ret = pReq->GetDeviceInfo(); + int result = strcmp(info.deviceId, ret.deviceId); + EXPECT_EQ(result, 0); +} + +/** + * @tc.name: OnDeviceReady_001 + * @tc.desc: set info.deviceId to some para, and return it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, OnProfileReady_001, testing::ext::TestSize.Level0) +{ + std::string pkgName; + std::string deviceId; + DmDeviceInfo info ; + strncpy (info.deviceId, "123", sizeof(info.deviceId)); + dmDeviceStateManager->OnProfileReady(pkgName, deviceId); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + DmDeviceInfo ret = pReq->GetDeviceInfo(); + int result = strcmp(info.deviceId, ret.deviceId); + ASSERT_GE(result, 0); +} + +/** + * @tc.name: OnDeviceReady_001 + * @tc.desc: set info.deviceId to 123,and call OnDeviceReady ，change info.deviceId to 4 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, OnDeviceReady_001, testing::ext::TestSize.Level0) +{ + std::string pkgName; + DmDeviceInfo info ; + strncpy (info.deviceId, "123", sizeof(info.deviceId)); + dmDeviceStateManager->OnDeviceReady(pkgName, info); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + DmDeviceInfo ret = pReq->GetDeviceInfo(); + int result = strcmp(info.deviceId, ret.deviceId); + ASSERT_GE(result, 0); +} + +/** + * @tc.name: OnDeviceChanged_001 + * @tc.desc: set info.deviceId to 123,and call OnDeviceChanged ，change info.deviceId to 4 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, OnDeviceChanged_002, testing::ext::TestSize.Level0) +{ + std::string pkgName; + DmDeviceInfo info ; + strncpy(info.deviceId, "123", sizeof(info.deviceId)); + dmDeviceStateManager->OnDeviceChanged(pkgName, info); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + DmDeviceInfo ret = pReq->GetDeviceInfo(); + int result = strcmp(info.deviceId, ret.deviceId); + ASSERT_GE(result, 0); +} + +/** + * @tc.name: RegisterSoftbusStateCallback_001 + * @tc.desc: call RegisterSoftbusStateCallback and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDeviceStateManagerTest, RegisterSoftbusStateCallback_001, testing::ext::TestSize.Level0) +{ + int ret = dmDeviceStateManager->RegisterSoftbusStateCallback(); + EXPECT_EQ(ret, DM_OK); +} +} +} +} \ No newline at end of file diff --git a/test/unittest/UTTest_dm_device_state_manager.h b/test/unittest/UTTest_dm_device_state_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..47821faba4dd084b956493ca6475983097668cce --- /dev/null +++ b/test/unittest/UTTest_dm_device_state_manager.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_UTTEST_DM_DEVICE_STATE_MANAGER_H +#define OHOS_UTTEST_DM_DEVICE_STATE_MANAGER_H + +#include +#include + +#include "softbus_connector.h" +#include "dm_adapter_manager.h" +#include "device_manager_service_listener.h" +#include "softbus_session_callback.h" +#include "dm_discovery_manager.h" + +namespace OHOS { +namespace DistributedHardware { +class DmDeviceStateManagerTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} +} +#endif \ No newline at end of file diff --git a/test/unittest/UTTest_dm_discovery_manager.cpp b/test/unittest/UTTest_dm_discovery_manager.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ff58930fbb1c4a36f8da708edcbbc72c71354797 --- /dev/null +++ b/test/unittest/UTTest_dm_discovery_manager.cpp @@ -0,0 +1,250 @@ +/* + * 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 + +#include "dm_log.h" +#include "dm_constants.h" +#include "dm_anonymous.h" +#include "ipc_server_listener.h" +#include "device_manager_service_listener.h" +#include "discovery_service.h" +#include "UTTest_dm_discovery_manager.h" + +namespace OHOS { +namespace DistributedHardware { +void DmDiscoveryManagerTest::SetUp() { +} + +void DmDiscoveryManagerTest::TearDown() { +} + +void DmDiscoveryManagerTest::SetUpTestCase() { +} + +void DmDiscoveryManagerTest::TearDownTestCase() { +} + +namespace { +std::shared_ptr softbusConnector_ = std::make_shared(); +std::shared_ptr listener_ = std::make_shared(); +std::shared_ptr discoveryMgr_ = std::make_shared(softbusConnector_, listener_); + +/** + * @tc.name: DmDiscoveryManager_001 + * @tc.desc: Test whether the DmDiscoveryManager function can generate a new pointer + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, DmDiscoveryManager_001, testing::ext::TestSize.Level0) { + std::shared_ptr Test = std::make_shared(softbusConnector_, listener_); + ASSERT_NE(Test, nullptr); +} + +/** + * @tc.name: DmDiscoveryManager_002 + * @tc.desc: Test whether the DmDiscoveryManager function can delete a new pointer + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, DmDiscoveryManager_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr Test = std::make_shared(softbusConnector_, listener_); + Test.reset(); + EXPECT_EQ(Test, nullptr); +} + +/** + * @tc.name:StartDeviceDiscovery_001 + * @tc.desc: keeping pkgame unchanged, call StartDeviceDiscovery twice + * so that its discoveryQueue is not empty and return DM_DISCOVERY_REPEATED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + DmSubscribeInfo subscribeInfo; + const std::string extra; + discoveryMgr_->StartDeviceDiscovery(pkgName, subscribeInfo, extra); + int32_t ret = discoveryMgr_->StartDeviceDiscovery(pkgName, subscribeInfo, extra); + EXPECT_EQ (ret, DM_DISCOVERY_REPEATED); +} + +/** + * @tc.name:StartDeviceDiscovery_002 + * @tc.desc: pkgame changed, call StartDeviceDiscovery twice + * so that its discoveryQueue is not empty and return DM_DISCOVERY_REPEATED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + std::string extra; + DmSubscribeInfo subscribeInfo; + discoveryMgr_->StartDeviceDiscovery(pkgName, subscribeInfo, extra); + pkgName = "com.ohos.helloworld.new"; + int32_t ret = discoveryMgr_->StartDeviceDiscovery(pkgName, subscribeInfo, extra); + ASSERT_EQ(ret, DM_DISCOVERY_FAILED); +} + +/** + * @tc.name:StopDeviceDiscovery_001 + * @tc.desc: Assign the correct value + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +// doing +HWTEST_F(DmDiscoveryManagerTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + const std::string extra; + DmSubscribeInfo subscribeInfo; + uint16_t subscribeId = 1; + discoveryMgr_->StartDeviceDiscovery(pkgName, subscribeInfo, extra); + int ret = discoveryMgr_->StopDeviceDiscovery(pkgName, subscribeId); + ASSERT_NE(ret, DM_OK); +} + +/** + * @tc.name: OnDeviceFound_001 + * @tc.desc: The OnDeviceFound function does the correct case and assigns pkgName + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, OnDeviceFound_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + uint16_t aaa = 11; + DmDiscoveryContext context{ pkgName, "121110", aaa }; + discoveryMgr_->discoveryContextMap_[pkgName] = context; + sleep(1); + DmDeviceInfo info; + info.deviceId[0] = '\0'; + info.deviceName[0] = '\0'; + discoveryMgr_->OnDeviceFound(pkgName, info); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + int ret1 = discoveryMgr_->discoveryContextMap_.count(pkgName); + EXPECT_EQ(ret1, 1); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ(ret, pkgName); +} + +/** + * @tc.name: OnDeviceFound_002 + * @tc.desc: set pkgName not null and discoveryContextMap_ null and return + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, OnDeviceFound_002, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + DmDeviceInfo info; + discoveryMgr_->OnDeviceFound(pkgName, info); + int ret1 = discoveryMgr_->discoveryContextMap_.count(pkgName); + EXPECT_EQ (ret1, 1); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ (ret, pkgName); +} + +/** + * @tc.name: OnDiscoveryFailed_001 + * @tc.desc: The OnDeviceFound function takes the wrong case and emptying pkgName + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, OnDiscoveryFailed_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + int32_t subscribeId = 1; + int32_t failedReason = 3; + discoveryMgr_->OnDiscoveryFailed(pkgName, subscribeId, failedReason); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ (ret, pkgName); +} + +/** + * @tc.name: OnDiscoveryFailed_002 + * @tc.desc: The OnDeviceFound function takes the wrong case and emptying pkgName + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, OnDiscoveryFailed_002, testing::ext::TestSize.Level0) { + std::string pkgName; + int32_t subscribeId = 1; + int32_t failedReason = 3; + discoveryMgr_->OnDiscoveryFailed(pkgName, subscribeId, failedReason); + int ret1 = discoveryMgr_->discoveryContextMap_.count(pkgName); + EXPECT_EQ (ret1, 0); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ (ret, pkgName); +} + +/** + * @tc.name: OnDiscoverySuccess_001 + * @tc.desc: The OnDeviceFound function takes the wrong case and return pkgName + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, OnDiscoverySuccess_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + int32_t subscribeId = 1; + discoveryMgr_->OnDiscoverySuccess(pkgName, subscribeId); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ (ret, pkgName); +} + +/** + * @tc.name: OnDiscoverySuccess_002 + * @tc.desc: set pkgName null and return discoveryContextMap_ null and return pkgName(null) + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, OnDiscoverySuccess_002, testing::ext::TestSize.Level0) +{ + std::string pkgName ; + int32_t subscribeId = 1; + discoveryMgr_->OnDiscoverySuccess(pkgName, subscribeId); + int ret1 = discoveryMgr_->discoveryContextMap_.count(pkgName); + EXPECT_EQ (ret1, 1); + std::shared_ptr pReq = std::static_pointer_cast(listener_->ipcServerListener_.req_); + std ::string ret = pReq->GetPkgName(); + EXPECT_EQ (ret, pkgName); +} + +/** + * @tc.name: HandleDiscoveryTimeout_001 + * @tc.desc: set pkgName not null and return 1(true) + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(DmDiscoveryManagerTest, HandleDiscoveryTimeout_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + discoveryMgr_->HandleDiscoveryTimeout() ; + int ret = discoveryMgr_->discoveryContextMap_.count(pkgName); + EXPECT_EQ (ret, 1); +} +} +} +} diff --git a/test/unittest/UTTest_dm_discovery_manager.h b/test/unittest/UTTest_dm_discovery_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..358594c9de98b9acd276b11f04f52a68ee73d1c2 --- /dev/null +++ b/test/unittest/UTTest_dm_discovery_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_UTTEST_DM_DISCOVERY_MANAGER_H +#define OHOS_UTTEST_DM_DISCOVERY_MANAGER_H + +#include +#include +#include + +#include "softbus_connector.h" +#include "device_manager_service_listener.h" +#include "dm_discovery_manager.h" +#include "ipc_notify_device_found_req.h" +#include "ipc_notify_discover_result_req.h" + +#define private public +namespace OHOS { +namespace DistributedHardware { +class DmDiscoveryManagerTest : public testing::Test +{ +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} +} +#endif // OHOS_UTTEST_DM_DISCOVERY_MANAGER_H \ No newline at end of file diff --git a/test/unittest/UTTest_hichain_connector.cpp b/test/unittest/UTTest_hichain_connector.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8aa859310e5f276a8378469432814aa74be7eb3b --- /dev/null +++ b/test/unittest/UTTest_hichain_connector.cpp @@ -0,0 +1,488 @@ +/* + * 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 +#include + +#include "parameter.h" +#include "dm_anonymous.h" +#include "dm_log.h" +#include "dm_constants.h" +#include "dm_random.h" +#include "hichain_connector.h" +#include "UTTest_hichain_connector.h" + +namespace OHOS { +namespace DistributedHardware { +void HichainConnectorTest::SetUp() +{ +} +void HichainConnectorTest::TearDown() +{ +} +void HichainConnectorTest::SetUpTestCase() +{ +} +void HichainConnectorTest::TearDownTestCase() +{ +} +namespace { +/** + * @tc.name: CreateGroup_001 + * @tc.desc: Set the deviceGroupManager_ pointer to CreateGroup to NULlptr and return DM_INVALID_VALUE + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, CreateGroup_001, testing::ext::TestSize.Level0) +{ + int64_t requestId = 123456; + std::string groupName = "dfggg"; + std::shared_ptr hichainConnector = std::make_shared(); + hichainConnector-> deviceGroupManager_ = nullptr; + int ret = hichainConnector->CreateGroup(requestId, groupName); + EXPECT_EQ(ret, DM_INVALID_VALUE); +} + +/** + * @tc.name: CreateGroup_002 + * @tc.desc: Set CreateGroup to the correct process and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, CreateGroup_002, testing::ext::TestSize.Level0) +{ + int64_t requestId = 123456; + std::string groupName = "uuiioo"; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->CreateGroup(requestId, groupName); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetGroupInfo_001 + * @tc.desc: set groupName not null and return false + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetGroupInfo_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr hichainConnector = std::make_shared(); + std::string groupName = "dcdkdkd1"; + nlohmann::json jsonObj; + jsonObj[FIELD_GROUP_NAME] = groupName.c_str(); + std::string queryParams = jsonObj.dump(); + std::vector groupList; + int ret = hichainConnector->GetGroupInfo(queryParams, groupList); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name: GetGroupInfo_003 + * @tc.desc: set groupName nou null groupListot null and return 0 + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetGroupInfo_003, testing::ext::TestSize.Level0) +{ + std::string groupName = "lcdkddkd1 "; + nlohmann::json jsonObj; + jsonObj[FIELD_GROUP_NAME] = groupName.c_str(); + std::string queryParams = jsonObj.dump(); + GroupInfo aa; + aa.groupName = "afa"; + std::vector groupList; + groupList.push_back(aa); + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->GetGroupInfo(queryParams, groupList); + EXPECT_EQ(ret, 0); +} + +/** + * @tc.name: IsGroupInfoInvalid_001 + * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is not GROUP_VISIBILITY_PUBLIC. + Group.return true + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ + +HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_001, testing::ext::TestSize.Level0) +{ + GroupInfo group; + group.groupName = "dkdkkdkdk"; + group.groupId = 1; + group.groupOwner = "ohos.distributedhardware.devicemanager"; + group.groupType = 7; + group.groupVisibility = 1; + std::shared_ptr hichainConnector = std::make_shared(); + bool ret = hichainConnector->IsGroupInfoInvalid(group); + EXPECT_EQ(ret, false); +} + +/** + * @tc.name: IsGroupInfoInvalid_002 + * @tc.desc: GroupType is GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP, group.groupVisibility is GROUP_VISIBILITY_PUBLIC, + Grou. groupOwner is not equal to DM_PKG_NAME. The value is true + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, IsGroupInfoInvalid_002, testing::ext::TestSize.Level0) +{ + GroupInfo group; + group.groupName = "test"; + group.groupId = 1; + group.groupOwner = "ohos.disware"; + group.groupType = 1; + group.groupVisibility = -1; + std::shared_ptr hichainConnector = std::make_shared(); + bool ret = hichainConnector->IsGroupInfoInvalid(group); + EXPECT_EQ(ret, true); +} + +/** + * @tc.name: DelMemberFromGroup_001 + * @tc.desc:set groupId, deviceId null and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, DelMemberFromGroup_001, testing::ext::TestSize.Level0) +{ + std::string groupId ; + std::string deviceId; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->DelMemberFromGroup(groupId, deviceId); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: DelMemberFromGroup_002 + * @tc.desc: The groupId "34451"; The deviceId = "123"; Can be deleted correctly + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, DelMemberFromGroup_002, testing::ext::TestSize.Level0) +{ + std::string groupId = "34451"; + std::string deviceId = "123"; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->DelMemberFromGroup(groupId, deviceId); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GenRequestId_001 + * @tc.desc:Call the GenRequestId function + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GenRequestId_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->GenRequestId(); + ASSERT_NE(ret, 0); +} + +/** + * @tc.name: from_json_001 + * @tc.desc: Pass in arguments to the from_JSON function and convert it to the correct value + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, from_json_001, testing::ext::TestSize.Level0) +{ + GroupInfo groupInfo; + groupInfo.groupName = "aaaa"; + groupInfo.groupId = "345678"; + groupInfo.groupOwner = "lllll"; + groupInfo.groupType = 5; + groupInfo.groupVisibility = 5; + nlohmann::json jsonObject; + jsonObject[FIELD_GROUP_NAME] = groupInfo.groupName; + jsonObject[FIELD_GROUP_ID] = groupInfo.groupId ; + jsonObject[ FIELD_GROUP_OWNER] = groupInfo.groupOwner; + jsonObject[ FIELD_GROUP_TYPE] = groupInfo.groupType; + jsonObject[FIELD_GROUP_VISIBILITY] = groupInfo.groupVisibility; + from_json(jsonObject, groupInfo); + EXPECT_EQ(groupInfo.groupName, "aaaa"); + EXPECT_EQ(groupInfo.groupId, "345678"); + EXPECT_EQ(groupInfo.groupOwner, "lllll"); + EXPECT_EQ(groupInfo.groupType, 5); + EXPECT_EQ(groupInfo.groupVisibility, 5); +} + +/** + * @tc.name: HiChainConnector_001 + * @tc.desc: Returns a new pointer to the HiChainConnector constructor new + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, HiChainConnector_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr m_HiChainConnector = std::make_shared(); + ASSERT_NE(m_HiChainConnector, nullptr); +} + +/** + * @tc.name: HiChainConnector_002 + * @tc.desc: Give the HiChainConnector constructor new a new pointer and delete it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, HiChainConnector_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr m_HiChainConnector = std::make_shared(); + m_HiChainConnector.reset(); + EXPECT_EQ(m_HiChainConnector, nullptr); +} + +/** + * @tc.name:RegisterHiChainCallback_001 + * @tc.desc: Call the RegisterHiChainCallback function with a return value of DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, RegisterHiChainCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.softbus.test"; + std::shared_ptr listener_ = std::make_shared(); + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr discoveryMgr_ = std::make_shared(softbusConnector, listener_); + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->RegisterHiChainCallback(pkgName, std::shared_ptr(discoveryMgr_)); + int ret1 = HiChainConnector::hiChainConnectorCallbackMap_.count(pkgName); + EXPECT_EQ(ret1, 1); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: IsGroupCreated_001 + * @tc.desc: Call the RegisterHiChainCallback function with a return value of DM_OK + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, IsGroupCreated_001, testing::ext::TestSize.Level0) +{ + std::string groupName = "dcdkdkd1"; + nlohmann::json jsonObj; + jsonObj[FIELD_GROUP_NAME] = groupName.c_str(); + std::string queryParams = jsonObj.dump(); + std::vector groupList ; + GroupInfo groupInfo; + std::shared_ptr hichainConnector = std::make_shared(); + bool ret = hichainConnector->IsGroupCreated(groupName, groupInfo); + EXPECT_EQ(ret, false); +} + +/** + * @tc.name: AddMember_001 + * @tc.desc: set deviceGroupManager_ = nullptr; + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, AddMember_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr hichainConnector = std::make_shared(); + hichainConnector->deviceGroupManager_ = nullptr; + std::string deviceId ; + std::string connectInfo; + int ret = hichainConnector->AddMember(deviceId, connectInfo); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name: AddMember_002 + * @tc.desc: set deviceId and connectInfo = null; + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, AddMember_002, testing::ext::TestSize.Level0) +{ + std::string deviceId; + std::string connectInfo; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->AddMember(deviceId, connectInfo); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: AddMember_002 + * @tc.desc: set deviceId and connectInfo = null; + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, AddMember3, testing::ext::TestSize.Level0) +{ + std::string deviceId = "123456"; + std::string connectInfo = "dkdkk"; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->AddMember(deviceId, connectInfo); + ASSERT_GE(ret, 1); +} + +/** + * @tc.name: onRequest_001 + * @tc.desc:set operationCode != GroupOperationCode::MEMBER_JOIN(3); return nullptr ; + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, onRequest_001, testing::ext::TestSize.Level0) +{ + int64_t requestId = 2; + int32_t operationCode = 2; + char *reqParams; + std::shared_ptr hichainConnector = std::make_shared(); + char *ret = hichainConnector->onRequest(requestId, operationCode, reqParams); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: GetConnectPara_001 + * @tc.desc: set para not null and go to the second master + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetConnectPara_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "softbus"; + std::shared_ptr listener_ = std::make_shared(); + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr discoveryMgr_ = std::make_shared(softbusConnector, listener_); + std::shared_ptr hichainConnector = std::make_shared(); + hichainConnector->RegisterHiChainCallback(pkgName, std::shared_ptr(discoveryMgr_)); + std::string deviceId = "23445"; + std::string reqDeviceId = "234566"; + std::string p; + std::string ret = hichainConnector->GetConnectPara(deviceId, reqDeviceId); + EXPECT_EQ(ret, p); +} + +/** + * @tc.name: GetConnectPara_002 + * @tc.desc:Empty deviceId so that jsonObject.is_discarded is null and the value of connectAddr is returned + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetConnectPara_002, testing::ext::TestSize.Level0) +{ + std::string deviceId; + std::string reqDeviceId = "234566"; + std::string pkgName = "softbus"; + std::shared_ptr listener_ = std::make_shared(); + std::shared_ptr softbusConnector = std::make_shared(); + std::shared_ptr discoveryMgr_ = std::make_shared(softbusConnector, listener_); + std::shared_ptr hichainConnector = std::make_shared(); + hichainConnector->RegisterHiChainCallback(pkgName, std::shared_ptr(discoveryMgr_)); + std::string ret = hichainConnector->GetConnectPara(deviceId, reqDeviceId); + EXPECT_EQ(ret, ""); +} + +/** + * @tc.name: DeleteGroup_001 + * @tc.desc: set groupId = "34567",and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, DeleteGroup_001, testing::ext::TestSize.Level0) +{ + std::string groupId = "34567"; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->DeleteGroup(groupId); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetRelatedGroups_001 + * @tc.desc: set DeviceId 123 groupList null and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetRelatedGroups_001, testing::ext::TestSize.Level0) +{ + std::string DeviceId = "123"; + std::vector groupList; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->GetRelatedGroups(DeviceId, groupList); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: GetRelatedGroups_003 + * @tc.desc: set DeviceId = 12345,groupList null and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetRelatedGroups_003, testing::ext::TestSize.Level0) +{ + std::string DeviceId = "12345"; + std::vector groupList; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->GetRelatedGroups(DeviceId, groupList); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: SyncGroups_001 + * @tc.desc: set deviceId = "34567",and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, SyncGroups_001, testing::ext::TestSize.Level0) +{ + std::string deviceId = "34567"; + std::vector remoteGroupIdList; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->SyncGroups(deviceId, remoteGroupIdList); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetSyncGroupList_001 + * @tc.desc: set groupList null,and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetSyncGroupList_001, testing::ext::TestSize.Level0) +{ + std::vector groupList; + std::vector syncGroupList; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->GetSyncGroupList(groupList, syncGroupList); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: GetSyncGroupList_002 + * @tc.desc: set groupList not null,and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(HichainConnectorTest, GetSyncGroupList_002, testing::ext::TestSize.Level0) +{ + std::vector groupList; + GroupInfo groupList1; + groupList1.groupName = "hichainconnector"; + groupList1.groupId = "123456"; + groupList1.groupOwner ="doftbus"; + groupList1.groupType = 1; + groupList1.groupVisibility = 2; + groupList.push_back(groupList1); + std::vector syncGroupList; + std::shared_ptr hichainConnector = std::make_shared(); + int ret = hichainConnector->GetSyncGroupList(groupList, syncGroupList); + EXPECT_EQ(ret, DM_OK); +} +} +} +} + diff --git a/test/unittest/UTTest_hichain_connector.h b/test/unittest/UTTest_hichain_connector.h new file mode 100644 index 0000000000000000000000000000000000000000..f691d34381dd4e9cf1a3eb14af0d3e06c03596f9 --- /dev/null +++ b/test/unittest/UTTest_hichain_connector.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_UTTEST_HICHAIN_CONNECTOR_H +#define OHOS_UTTEST_HICHAIN_CONNECTOR_H + +#include +#include +#include +#include +#include +#include +#include + +#include "nlohmann/json.hpp" +#include "device_auth.h" +#include "single_instance.h" +#include "hichain_connector_callback.h" +#include "device_manager_service_listener.h" +#include "dm_auth_manager.h" +#include "dm_device_state_manager.h" +#include "hichain_connector.h" + +namespace OHOS { +namespace DistributedHardware { +class HichainConnectorTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_HICHAIN_CONNECTOR_H diff --git a/test/unittest/UTTest_softbus_connector.cpp b/test/unittest/UTTest_softbus_connector.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6ba6588235f6e738a72bd5446fdc52bfe808e4f2 --- /dev/null +++ b/test/unittest/UTTest_softbus_connector.cpp @@ -0,0 +1,333 @@ +/* + * 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 "UTTest_softbus_connector.h" + +#include +#include + +#include +#include + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" +#include "parameter.h" +#include "softbus_connector.h" +#include "system_ability_definition.h" + +namespace OHOS { +namespace DistributedHardware { +void SoftbusConnectorTest::SetUp() +{ +} +void SoftbusConnectorTest::TearDown() +{ +} +void SoftbusConnectorTest::SetUpTestCase() +{ +} +void SoftbusConnectorTest::TearDownTestCase() +{ +} + +namespace { +static std::shared_ptr softbusConnector = std::make_shared(); +/** + * @tc.name: Init_001 + * @tc.desc: go tothe corrort case and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, Init_001, testing::ext::TestSize.Level0) +{ + int ret = softbusConnector->Init(); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: RegisterSoftbusDiscoveryCallback_001 + * @tc.desc: set pkgName = "com.ohos.helloworld";call RegisterSoftbusDiscoveryCallback function to corrort ,return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, RegisterSoftbusDiscoveryCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + std::shared_ptr listener_ = std::make_shared(); + std::shared_ptr discoveryMgr_ = + std::make_shared(softbusConnector, listener_); + int ret = softbusConnector->RegisterSoftbusDiscoveryCallback( + pkgName, std::shared_ptr(discoveryMgr_)); + int ret1 = SoftbusConnector::discoveryCallbackMap_.count(pkgName); + EXPECT_EQ(ret1, 1); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: UnRegisterSoftbusDiscoveryCallback_001 + * @tc.desc: set pkgName = "com.ohos.helloworld";call UnRegisterSoftbusDiscoveryCallback function to corrort ,return + * DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, UnRegisterSoftbusDiscoveryCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + int ret = softbusConnector->UnRegisterSoftbusDiscoveryCallback(pkgName); + int ret1 = SoftbusConnector::discoveryCallbackMap_.count(pkgName); + EXPECT_EQ(ret1, 0); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: UnRegisterSoftbusStateCallback_001 + * @tc.desc: set pkgName = "com.ohos.helloworld";call UnRegisterSoftbusStateCallback function to corrort ,return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, UnRegisterSoftbusStateCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.ohos.helloworld"; + int ret = softbusConnector->UnRegisterSoftbusStateCallback(pkgName); + int ret1 = SoftbusConnector::stateCallbackMap_.count(pkgName); + EXPECT_EQ(ret1, 0); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetTrustedDeviceList_001 + * @tc.desc: create GetAllNodeDeviceInfo not equal 0, and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetTrustedDeviceList_001, testing::ext::TestSize.Level0) +{ + std::vector deviceInfoList; + int ret = softbusConnector->GetTrustedDeviceList(deviceInfoList); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetLocalDeviceInfo_001 + * @tc.desc: set pkgName to com.softbus.test,define deviceInfo,and return DM_OK. + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetLocalDeviceInfo_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "com.softbus.test"; + DmDeviceInfo deviceInfo; + int ret = softbusConnector->GetLocalDeviceInfo(deviceInfo); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: StartDiscovery_001 + * @tc.desc: get StartDiscovery to wroing master and return DM_DISCOVERY_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, StartDiscovery_001, testing::ext::TestSize.Level0) +{ + DmSubscribeInfo dmSubscribeInfo; + int ret = softbusConnector->StartDiscovery(dmSubscribeInfo); + EXPECT_EQ(ret, DM_DISCOVERY_FAILED); +} + +/** + * @tc.name: IsDeviceOnLine_001 + * @tc.desc: set deviceId = "12333";,and return false + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, IsDeviceOnLine_001, testing::ext::TestSize.Level0) +{ + std::string deviceId = "12333"; + bool ret = softbusConnector->IsDeviceOnLine(deviceId); + EXPECT_EQ(ret, false); +} + +/** + * @tc.name: IsDeviceOnLine_002 + * @tc.desc: + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, IsDeviceOnLine_002, testing::ext::TestSize.Level0) +{ + std::string deviceId = "145677"; + NodeBasicInfo Info; + strncpy(Info.networkId, "145677", sizeof(Info.networkId)); + bool ret = softbusConnector->IsDeviceOnLine(deviceId); + EXPECT_EQ(ret, false); +} + +/** + * @tc.name: SoftbusConnector_001 + * @tc.desc: set SoftbusConnector to new a pointer ,and the pointer nou equal nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, SoftbusConnector_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr m_SoftbusConnector = std::make_shared(); + ASSERT_NE(m_SoftbusConnector, nullptr); +} + +/** + * @tc.name: SoftbusConnector_002 + * @tc.desc: set SoftbusConnector to new a pointer ,and the pointer nou equal nullptr,and delete it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, SoftbusConnector_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr m_SoftbusConnector = std::make_shared(); + m_SoftbusConnector.reset(); + EXPECT_EQ(m_SoftbusConnector, nullptr); +} + +/** + * @tc.name: GetConnectionIpAddress_001 + * @tc.desc: set deviceId null,adb return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectionIpAddress_001, testing::ext::TestSize.Level0) +{ + std::string deviceId; + std::string ipAddress = "123456"; + int ret = softbusConnector->GetConnectionIpAddress(deviceId, ipAddress); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: GetConnectionIpAddress_002 + * @tc.desc: set some corrort para,and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectionIpAddress_002, testing::ext::TestSize.Level0) +{ + std::string deviceId = "213456"; + std::string ipAddress = "123456"; + int ret = softbusConnector->GetConnectionIpAddress(deviceId, ipAddress); + EXPECT_EQ(ret, DM_FAILED); +} +/** + * @tc.name: GetConnectionIpAddress_003 + * @tc.desc: set deviceInfo.addrNum = -1;go to second master and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectionIpAddress_003, testing::ext::TestSize.Level0) +{ + DeviceInfo deviceInfo; + deviceInfo.addrNum = -1; + std::string ipAddress; + std::string deviceId = "3338848"; + int ret = softbusConnector->GetConnectionIpAddress(deviceId, ipAddress); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: GetConnectAddrByType_001 + * @tc.desc: set deviceInfo'pointer null, go to first master,and return nullptr + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectAddrByType_001, testing::ext::TestSize.Level0) +{ + ConnectionAddrType type; + type = CONNECTION_ADDR_MAX; + ConnectionAddr *p = nullptr; + ConnectionAddr *ret = softbusConnector->GetConnectAddrByType(nullptr, type); + EXPECT_EQ(p, ret); +} + +/** + * @tc.name: GetConnectAddrByType_002 + * @tc.desc:set deviceInfo to some corrort para,and return nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectAddrByType_002, testing::ext::TestSize.Level0) +{ + DeviceInfo deviceInfo; + deviceInfo.addrNum = 1; + ConnectionAddrType type; + type = CONNECTION_ADDR_BR; + ConnectionAddr *p = nullptr; + ConnectionAddr *ret = softbusConnector->GetConnectAddrByType(&deviceInfo, type); + EXPECT_EQ(ret, p); +} + +/** + * @tc.name: GetConnectAddr_001 + * @tc.desc: set deviceId to null,and return nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectAddr_001, testing::ext::TestSize.Level0) +{ + std::string deviceId; + std::string connectAddr; + ConnectionAddr *ret = softbusConnector->GetConnectAddr(deviceId, connectAddr); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: GetConnectAddr_002 + * @tc.desc:set deviceId nit null set deviceInfo.addrNum = -1; and return nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, GetConnectAddr_002, testing::ext::TestSize.Level0) +{ + std::string deviceId = "123345"; + std::string connectAddr; + DeviceInfo deviceInfo; + deviceInfo.addrNum = -1; + ConnectionAddr *ret = softbusConnector->GetConnectAddr(deviceId, connectAddr); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: CovertNodeBasicInfoToDmDevice_001 + * @tc.desc: go to the corrort case and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, CovertNodeBasicInfoToDmDevice_001, testing::ext::TestSize.Level0) +{ + NodeBasicInfo nodeBasicInfo; + DmDeviceInfo dmDeviceInfo; + int ret = softbusConnector->CovertNodeBasicInfoToDmDevice(nodeBasicInfo, dmDeviceInfo); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: OnParameterChgCallback_001 + * @tc.desc: set some corrort para and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusConnectorTest, OnParameterChgCallback_001, testing::ext::TestSize.Level0) +{ + EXPECT_EQ(DM_OK, DM_OK); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/UTTest_softbus_connector.h b/test/unittest/UTTest_softbus_connector.h new file mode 100644 index 0000000000000000000000000000000000000000..b32d13b2792ba17829b09faf92ef168853c531b3 --- /dev/null +++ b/test/unittest/UTTest_softbus_connector.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_UTTest_DM_SOFTBUS_CONNECTOR_H +#define OHOS_UTTest_DM_SOFTBUS_CONNECTOR_H + +#include +#include + +#include +#include +#include +#include +#include + +#include "device_manager_service_listener.h" +#include "discovery_service.h" +#include "dm_device_info.h" +#include "dm_device_state_manager.h" +#include "dm_discovery_manager.h" +#include "dm_subscribe_info.h" +#include "softbus_bus_center.h" +#include "softbus_connector.h" +#include "softbus_discovery_callback.h" +#include "softbus_session.h" +#include "softbus_state_callback.h" + +namespace OHOS { +namespace DistributedHardware { +class SoftbusConnectorTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/test/unittest/UTTest_softbus_session.cpp b/test/unittest/UTTest_softbus_session.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c81b47b06df4bc6f4c8b18caa4254ca12bcf2d56 --- /dev/null +++ b/test/unittest/UTTest_softbus_session.cpp @@ -0,0 +1,208 @@ +/* + * 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 "UTTest_softbus_session.h" + +#include "dm_anonymous.h" +#include "dm_constants.h" +#include "dm_log.h" +#include "nlohmann/json.hpp" +#include "softbus_connector.h" +#include "softbus_session.h" + +namespace OHOS { +namespace DistributedHardware { +void SoftbusSessionTest::SetUp() +{ +} +void SoftbusSessionTest::TearDown() +{ +} +void SoftbusSessionTest::SetUpTestCase() +{ +} +void SoftbusSessionTest::TearDownTestCase() +{ +} + +namespace { +std::shared_ptr softbusSession = std::make_shared(); + +/** + * @tc.name: OpenAuthSession_001 + * @tc.desc: set deviceId =null, return sessionId(1) + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, OpenAuthSession_001, testing::ext::TestSize.Level0) +{ + std::string deviceId = ""; + int ret = softbusSession->OpenAuthSession(deviceId); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name: OpenAuthSession_002 + * @tc.desc: set deviceId = "123456";and return sessionId + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, OpenAuthSession_002, testing::ext::TestSize.Level0) +{ + std::string deviceId = "123456"; + int ret = softbusSession->OpenAuthSession(deviceId); + EXPECT_EQ(ret, -1); +} + +/** + * @tc.name: SendData_001 + * @tc.desc: set message null and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, SendData_001, testing::ext::TestSize.Level0) +{ + std::string message = ""; + int32_t sessionId = -1; + int ret = softbusSession->SendData(sessionId, message); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: SendData_002 + * @tc.desc: set sessionId = 0 ,go to the SendBytes'smaster and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, SendData_002, testing::ext::TestSize.Level0) +{ + int32_t msgType = 2; + nlohmann::json jsonObj; + jsonObj[TAG_VER] = DM_ITF_VER; + jsonObj[TAG_TYPE] = msgType; + std::string message = jsonObj.dump(); + int32_t sessionId = 0; + int ret = softbusSession->SendData(sessionId, message); + EXPECT_EQ(ret, DM_FAILED); +} + +/** + * @tc.name: OnSessionOpened_001 + * @tc.desc: set result = 0,sessionId = -1;and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, OnSessionOpened_001, testing::ext::TestSize.Level0) +{ + int result = 0; + int32_t sessionId = -1; + int ret = softbusSession->OnSessionOpened(sessionId, result); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: SoftbusSession_001 + * @tc.desc: set SoftbusSession to make a new pointer ,and it not nullptr + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, SoftbusSession_001, testing::ext::TestSize.Level0) +{ + std::shared_ptr m_SoftbusSession = std::make_shared(); + ASSERT_NE(m_SoftbusSession, nullptr); +} + +/** + * @tc.name: SoftbusSession_002 + * @tc.desc: set SoftbusSession to make a new pointer , it not nullptr and delete it + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, SoftbusSession_002, testing::ext::TestSize.Level0) +{ + std::shared_ptr m_SoftbusSession = std::make_shared(); + m_SoftbusSession.reset(); + EXPECT_EQ(m_SoftbusSession, nullptr); +} + +/** + * @tc.name: OnSessionClosed_001 + * @tc.desc: set some corrort para,and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +// HWTEST_F(SoftbusSessionTest, OnSessionClosed_001, testing::ext::TestSize.Level0) +// { +// int32_t sessionId = 3; +// int ret = softbusSession->OnSessionClosed(sessionId); +// EXPECT_EQ(ret, DM_OK); +// } + +/** + * @tc.name: OnBytesReceived_002 + * @tc.desc: set sessionId = 3 and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +// HWTEST_F(SoftbusSessionTest, OnBytesReceived_002, testing::ext::TestSize.Level0) +// { +// int32_t sessionId = 3; +// void *data; +// uint32_t dataLen = 1; +// int ret = softbusSession->OnBytesReceived(sessionId, data, dataLen); +// EXPECT_EQ(ret, DM_OK); +// } + +/** + * @tc.name: CloseAuthSession_001 + * @tc.desc: set sessionId = 3, and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, CloseAuthSession_001, testing::ext::TestSize.Level0) +{ + int32_t sessionId = 3; + int ret = softbusSession->CloseAuthSession(sessionId); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: GetPeerDeviceId_001 + * @tc.desc: set sessionId = 3 and return DM_OK + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, GetPeerDeviceId_001, testing::ext::TestSize.Level0) +{ + int32_t sessionId = 3; + std::string peerDevId; + int ret = softbusSession->GetPeerDeviceId(sessionId, peerDevId); + EXPECT_EQ(ret, DM_OK); +} + +/** + * @tc.name: UnRegisterSessionCallback_001 + * @tc.desc: set info to null and return DM_FAILED + * @tc.type: FUNC + * @tc.require: AR000GHSJK + */ +HWTEST_F(SoftbusSessionTest, UnRegisterSessionCallback_001, testing::ext::TestSize.Level0) +{ + std::string pkgName = "softbus"; + int ret = softbusSession->UnRegisterSessionCallback(pkgName); + EXPECT_EQ(ret, DM_OK); +} +} // namespace +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/UTTest_softbus_session.h b/test/unittest/UTTest_softbus_session.h new file mode 100644 index 0000000000000000000000000000000000000000..e8eee61d25ee3f495cb53f4a89101cf06a34745a --- /dev/null +++ b/test/unittest/UTTest_softbus_session.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_UTTest_DM_SOFTBUS_SESSION_H +#define OHOS_UTTest_DM_SOFTBUS_SESSION_H + +#include +#include + +#include +#include +#include +#include +#include + +#include "device_manager_service_listener.h" +#include "dm_device_state_manager.h" +#include "dm_discovery_manager.h" +#include "inner_session.h" +#include "session.h" +#include "softbus_session.h" +#include "softbus_session_callback.h" + +namespace OHOS { +namespace DistributedHardware { +class SoftbusSessionTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + virtual void SetUp() override; + virtual void TearDown() override; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif \ No newline at end of file diff --git a/test/unittest/auth_request_state.cpp b/test/unittest/auth_request_state.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bab92c0b179553740a38a3762cf53393d9150d55 --- /dev/null +++ b/test/unittest/auth_request_state.cpp @@ -0,0 +1,192 @@ +/* + * 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 "auth_request_state.h" + +#include "dm_auth_manager.h" +#include "dm_constants.h" + +namespace OHOS { +namespace DistributedHardware { + +int32_t AuthRequestState::Leave() +{ + return DM_OK; +} + +int32_t AuthRequestState::SetAuthManager(std::shared_ptr authManager) +{ + authManager_ = std::move(authManager); + return DM_OK; +} + +int32_t AuthRequestState::SetAuthContext(std::shared_ptr context) +{ + context_ = std::move(context); + return DM_OK; +} + +std::shared_ptr AuthRequestState::GetAuthContext() +{ + return context_; +} + +int32_t AuthRequestState::TransitionTo(std::shared_ptr state) +{ + LOGE("AuthRequestState::TransitionTo"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + state->SetAuthManager(stateAuthManager); + stateAuthManager->SetAuthRequestState(state); + state->SetAuthContext(context_); + this->Leave(); + state->Enter(); + return DM_OK; +} + +int32_t AuthRequestInitState::GetStateType() +{ + return AuthState::AUTH_REQUEST_INIT; +} + +int32_t AuthRequestInitState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->EstablishAuthChannel(context_->deviceId); + return DM_OK; +} + +int32_t AuthRequestNegotiateState::GetStateType() +{ + return AuthState::AUTH_REQUEST_NEGOTIATE; +} + +int32_t AuthRequestNegotiateState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->StartNegotiate(context_->sessionId); + return DM_OK; +} + +int32_t AuthRequestNegotiateDoneState::GetStateType() +{ + return AuthState::AUTH_REQUEST_NEGOTIATE_DONE; +} + +int32_t AuthRequestNegotiateDoneState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->SendAuthRequest(context_->sessionId); + return DM_OK; +} + +int32_t AuthRequestReplyState::GetStateType() +{ + return AuthState::AUTH_REQUEST_REPLY; +} + +int32_t AuthRequestReplyState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->StartRespAuthProcess(); + return DM_OK; +} + +int32_t AuthRequestInputState::GetStateType() +{ + return AuthState::AUTH_REQUEST_INPUT; +} + +int32_t AuthRequestInputState::Enter() +{ + LOGE("DmAuthManager::AuthRequestInputState"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->ShowStartAuthDialog(); + return DM_OK; +} + +int32_t AuthRequestJoinState::GetStateType() +{ + return AuthState::AUTH_REQUEST_JOIN; +} + +int32_t AuthRequestJoinState::Enter() +{ + LOGE("DmAuthManager::AuthRequestJoinState"); + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->AddMember(context_->deviceId); + return DM_OK; +} + +int32_t AuthRequestNetworkState::GetStateType() +{ + return AuthState::AUTH_REQUEST_NETWORK; +} + +int32_t AuthRequestNetworkState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->JoinNetwork(); + return DM_OK; +} + +int32_t AuthRequestFinishState::GetStateType() +{ + return AuthState::AUTH_REQUEST_FINISH; +} + +int32_t AuthRequestFinishState::Enter() +{ + std::shared_ptr stateAuthManager = authManager_.lock(); + if (stateAuthManager == nullptr) { + LOGE("AuthRequestState::authManager_ null"); + return DM_FAILED; + } + stateAuthManager->AuthenticateFinish(); + return DM_OK; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/test/unittest/device_manager_impl_test.cpp b/test/unittest/device_manager_impl_test.cpp index a6070729ffbf759182472fdbc004f5d40dda0ad8..8402ec4d45ce38be0b1601a20940b10ccc486864 100644 --- a/test/unittest/device_manager_impl_test.cpp +++ b/test/unittest/device_manager_impl_test.cpp @@ -14,11 +14,12 @@ */ #include "device_manager_impl_test.h" -#include "device_manager_errno.h" -#include "dm_device_info.h" #include +#include "dm_constants.h" +#include "dm_device_info.h" + namespace OHOS { namespace DistributedHardware { void DeviceManagerImplTest::SetUp() @@ -41,90 +42,94 @@ namespace { HWTEST_F(DeviceManagerImplTest, InitDeviceManager, testing::ext::TestSize.Level0) { std::string packName = ""; - int32_t ret= DeviceManager::GetInstance().InitDeviceManager(packName, nullptr); - ASSERT_EQ(ret, DEVICEMANAGER_INVALID_VALUE); + int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, nullptr); + ASSERT_EQ(ret, DM_INVALID_VALUE); } HWTEST_F(DeviceManagerImplTest, AuthenticateDevice1, testing::ext::TestSize.Level0) { std::string packName = ""; + int32_t authType = 0; DmDeviceInfo dmDeviceInfo; - DmAppImageInfo dmAppImageInfo; - std::string extra= ""; + std::string extra = ""; std::shared_ptr callback = nullptr; - int32_t ret= DeviceManager::GetInstance().AuthenticateDevice(packName, dmDeviceInfo, - dmAppImageInfo, extra, callback); - ASSERT_EQ(ret, DEVICEMANAGER_INVALID_VALUE); + int32_t ret = + DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); + ASSERT_EQ(ret, DM_INVALID_VALUE); } HWTEST_F(DeviceManagerImplTest, AuthenticateDevice2, testing::ext::TestSize.Level0) { std::string packName = "com.ohos.helloworld"; + int32_t authType = 0; DmDeviceInfo dmDeviceInfo; - DmAppImageInfo dmAppImageInfo; std::string extra = ""; std::shared_ptr callback = nullptr; std::shared_ptr mockInstance = std::make_shared(); DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) - .Times(1).WillOnce(testing::Return(DEVICEMANAGER_FAILED)); - int32_t ret= DeviceManager::GetInstance().AuthenticateDevice(packName, dmDeviceInfo, - dmAppImageInfo, extra, callback); - ASSERT_EQ(ret, DEVICEMANAGER_IPC_FAILED); + .Times(1) + .WillOnce(testing::Return(DM_FAILED)); + int32_t ret = + DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); + ASSERT_EQ(ret, DM_IPC_FAILED); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } HWTEST_F(DeviceManagerImplTest, AuthenticateDevice3, testing::ext::TestSize.Level0) { std::string packName = "com.ohos.helloworld"; + int32_t authType = 0; DmDeviceInfo dmDeviceInfo; - DmAppImageInfo dmAppImageInfo; std::string extra = ""; std::shared_ptr callback = nullptr; std::shared_ptr mockInstance = std::make_shared(); DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) - .Times(1).WillOnce(testing::Return(DEVICEMANAGER_OK)); - int32_t ret= DeviceManager::GetInstance().AuthenticateDevice(packName, dmDeviceInfo, - dmAppImageInfo, extra, callback); - ASSERT_EQ(ret, DEVICEMANAGER_OK); + .Times(1) + .WillOnce(testing::Return(DM_OK)); + int32_t ret = + DeviceManager::GetInstance().AuthenticateDevice(packName, authType, dmDeviceInfo, extra, callback); + ASSERT_EQ(ret, DM_OK); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } -HWTEST_F(DeviceManagerImplTest, CheckAuthentication1, testing::ext::TestSize.Level0) +HWTEST_F(DeviceManagerImplTest, VerifyAuthentication1, testing::ext::TestSize.Level0) { std::string packName = ""; std::string authPara = ""; - std::shared_ptr callback = nullptr; - int32_t ret = DeviceManager::GetInstance().CheckAuthentication(packName, authPara, callback); - ASSERT_EQ(ret, DEVICEMANAGER_INVALID_VALUE); + std::shared_ptr callback = nullptr; + int32_t ret = DeviceManager::GetInstance().VerifyAuthentication(packName, authPara, callback); + ASSERT_EQ(ret, DM_INVALID_VALUE); } -HWTEST_F(DeviceManagerImplTest, CheckAuthentication2, testing::ext::TestSize.Level0) +HWTEST_F(DeviceManagerImplTest, VerifyAuthentication2, testing::ext::TestSize.Level0) { std::string packName = "com.ohos.helloworld"; std::string authPara = ""; - std::shared_ptr callback = nullptr; + std::shared_ptr callback = nullptr; std::shared_ptr mockInstance = std::make_shared(); DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) - .Times(1).WillOnce(testing::Return(DEVICEMANAGER_FAILED)); - int32_t ret= DeviceManager::GetInstance().CheckAuthentication(packName, authPara, callback); - ASSERT_EQ(ret, DEVICEMANAGER_IPC_FAILED); + .Times(1) + .WillOnce(testing::Return(DM_FAILED)); + int32_t ret = DeviceManager::GetInstance().VerifyAuthentication(packName, authPara, callback); + ASSERT_EQ(ret, DM_IPC_FAILED); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } -HWTEST_F(DeviceManagerImplTest, CheckAuthentication3, testing::ext::TestSize.Level0) +HWTEST_F(DeviceManagerImplTest, VerifyAuthentication3, testing::ext::TestSize.Level0) { std::string packName = "com.ohos.helloworld"; std::string authPara = ""; - std::shared_ptr callback = nullptr; + std::shared_ptr callback = nullptr; std::shared_ptr mockInstance = std::make_shared(); DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) - .Times(1).WillOnce(testing::Return(DEVICEMANAGER_OK)); - int32_t ret= DeviceManager::GetInstance().CheckAuthentication(packName, authPara, callback); - ASSERT_EQ(ret, DEVICEMANAGER_OK); + .Times(1) + .WillOnce(testing::Return(DM_OK)); + int32_t ret = DeviceManager::GetInstance().VerifyAuthentication(packName, authPara, callback); + ASSERT_EQ(ret, DM_OK); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } @@ -132,22 +137,25 @@ HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery1, testing::ext::TestSize.Le { std::string packName = ""; DmSubscribeInfo subscribeInfo; - std::shared_ptr callback = nullptr; - int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, callback); - ASSERT_EQ(ret, DEVICEMANAGER_INVALID_VALUE); + std::string extra = ""; + std::shared_ptr callback = nullptr; + int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, callback); + ASSERT_EQ(ret, DM_INVALID_VALUE); } HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery2, testing::ext::TestSize.Level0) { std::string packName = "com.ohos.helloworld"; DmSubscribeInfo subscribeInfo; - test_callback_ = std::make_shared(); + std::string extra = ""; + test_callback_ = std::make_shared(); std::shared_ptr mockInstance = std::make_shared(); DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) - .Times(1).WillOnce(testing::Return(DEVICEMANAGER_OK)); - int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, test_callback_); - ASSERT_EQ(ret, DEVICEMANAGER_OK); + .Times(1) + .WillOnce(testing::Return(DM_OK)); + int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, test_callback_); + ASSERT_EQ(ret, DM_OK); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } @@ -155,31 +163,33 @@ HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery3, testing::ext::TestSize.Le { std::string packName = "com.ohos.helloworld"; DmSubscribeInfo subscribeInfo; - test_callback_ = std::make_shared(); + std::string extra = ""; + test_callback_ = std::make_shared(); std::shared_ptr mockInstance = std::make_shared(); DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance; EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_)) - .Times(1).WillOnce(testing::Return(DEVICEMANAGER_FAILED)); - int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, test_callback_); - ASSERT_EQ(ret, DEVICEMANAGER_IPC_FAILED); + .Times(1) + .WillOnce(testing::Return(DM_FAILED)); + int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeInfo, extra, test_callback_); + ASSERT_EQ(ret, DM_IPC_FAILED); DeviceManagerImpl::GetInstance().ipcClientProxy_ = nullptr; } } // namespace -void DeviceDiscoverCallback::OnDiscoverySuccess(uint16_t subscribeId) +void DeviceDiscoveryCallback::OnDiscoverySuccess(uint16_t subscribeId) { (void)subscribeId; } -void DeviceDiscoverCallback::OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) +void DeviceDiscoveryCallback::OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) { (void)subscribeId; (void)failedReason; } -void DeviceDiscoverCallback::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) +void DeviceDiscoveryCallback::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) { (void)subscribeId; } -} // namespace Vsync +} // namespace DistributedHardware } // namespace OHOS diff --git a/test/unittest/device_manager_impl_test.h b/test/unittest/device_manager_impl_test.h index 9efa3619b2ce0d80a715b6e82702ee5eb26df811..ffcb70e32d1a595b4c26760bf01cc76c38e66025 100644 --- a/test/unittest/device_manager_impl_test.h +++ b/test/unittest/device_manager_impl_test.h @@ -13,16 +13,16 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IMPL_TEST_H -#define OHOS_DEVICE_MANAGER_IMPL_TEST_H +#ifndef OHOS_DM_IMPL_TEST_H +#define OHOS_DM_IMPL_TEST_H #include #include -#include "mock/mock_ipc_client_proxy.h" -#include "device_manager_impl.h" -#include "device_manager_callback.h" #include "device_manager.h" +#include "device_manager_callback.h" +#include "device_manager_impl.h" +#include "mock/mock_ipc_client_proxy.h" namespace OHOS { namespace DistributedHardware { @@ -32,19 +32,24 @@ public: static void TearDownTestCase(); virtual void SetUp() override; virtual void TearDown() override; + private: - std::shared_ptr test_callback_ = nullptr; + std::shared_ptr test_callback_ = nullptr; }; -class DeviceDiscoverCallback : public DiscoverCallback { +class DeviceDiscoveryCallback : public DiscoveryCallback { public: - DeviceDiscoverCallback() : DiscoverCallback() {} - virtual ~DeviceDiscoverCallback() override {} + DeviceDiscoveryCallback() : DiscoveryCallback() + { + } + virtual ~DeviceDiscoveryCallback() override + { + } virtual void OnDiscoverySuccess(uint16_t subscribeId) override; - virtual void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) override; + virtual void OnDiscoveryFailed(uint16_t subscribeId, int32_t failedReason) override; virtual void OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) override; }; -} // namespace Vsync +} // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IMPL_TEST_H +#endif // OHOS_DM_IMPL_TEST_H diff --git a/test/unittest/mock/device_auth.cpp b/test/unittest/mock/device_auth.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4782f055d5c683b00f5425f1cecf63be67c5bb38 --- /dev/null +++ b/test/unittest/mock/device_auth.cpp @@ -0,0 +1,42 @@ +#include "device_auth.h" +#include "dm_constants.h" + +int32_t (*deleteGroup)(int64_t requestId, const char *appId, const char *disbandParams) +{ + if (disbandParams == 0) { + return DM_FAILED; + } + + return DM_OK; +} + +int32_t (*getRelatedGroups)(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum) +{ + return 0; +} + + +int32_t (*createGroup)(int64_t requestId, const char *appId, const char *createParams) +{ + if (requestId == 0) { + return DM_FAILED; + } + return 0; +} + + +int32_t (*getRelatedGroups)(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum) +{ + if (peerDeviceId == "123") { + returnGroupVec = nullptr; + } + + if (peerDeviceId == "12345") { + groupNum = 0; + } + + if (peerDeviceId == "34567") { + groupNum = 1; + returnGroupVec = "123"; + } +} \ No newline at end of file diff --git a/test/unittest/mock/device_auth.h b/test/unittest/mock/device_auth.h new file mode 100644 index 0000000000000000000000000000000000000000..0fd7ad083fb52d3d46ca8e0f004c78e7812ff06d --- /dev/null +++ b/test/unittest/mock/device_auth.h @@ -0,0 +1,191 @@ +/* + * 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 DEVICE_AUTH_H +#define DEVICE_AUTH_H + +#include +#include + +#if defined(__LINUX__) || defined(_UNIX) +#define DEVICE_AUTH_API_PUBLIC __attribute__ ((visibility("default"))) +#else +#define DEVICE_AUTH_API_PUBLIC +#endif + +#define FIELD_GROUP_ID "groupId" +#define FIELD_GROUP_TYPE "groupType" +#define FIELD_GROUP_NAME "groupName" +#define FIELD_PEER_DEVICE_ID "peerDeviceId" +#define FIELD_IS_ADMIN "isAdmin" +#define FIELD_CREDENTIAL_TYPE "credentialType" +#define FIELD_IS_FORCE_DELETE "isForceDelete" +#define FIELD_IS_IGNORE_CHANNEL "isIgnoreChannel" +#define FIELD_CONNECT_PARAMS "connectParams" +#define FIELD_ADD_ID "addId" +#define FIELD_DELETE_ID "deleteId" +#define FIELD_APP_ID "appId" +#define FIELD_SERVICE_TYPE "serviceType" +#define FIELD_PEER_AUTH_STATE "peerAuthState" +#define FIELD_IS_DEVICE_LEVEL "isDeviceLevel" +#define FIELD_ALTERNATIVE "alternative" +#define FIELD_PEER_UDID "peerUdid" +#define FIELD_PEER_CONN_DEVICE_ID "peerConnDeviceId" +#define FIELD_KEY_LENGTH "keyLength" +#define FIELD_IS_CLIENT "isClient" +#define FIELD_SESSION_KEY "sessionKey" +#define FIELD_AUTH_FORM "authForm" +#define FIELD_CONFIRMATION "confirmation" +#define FIELD_GROUP_OWNER "groupOwner" +#define FIELD_PEER_AUTH_ID "peerAuthId" +#define FIELD_PEER_USER_TYPE "peerUserType" +#define FIELD_PEER_USER_ID "peerUserId" +#define FIELD_SERVICE_PKG_NAME "servicePkgName" +#define FIELD_USER_TYPE "userType" +#define FIELD_USER_ID "userId" +#define FIELD_SHARED_USER_ID "sharedUserId" +#define FIELD_OWNER_USER_ID "ownerUserId" +#define FIELD_DEVICE_ID "deviceId" +#define FIELD_UID_HASH "uidHash" +#define FIELD_PIN_CODE "pinCode" +#define FIELD_AUTH_ID "authId" +#define FIELD_UDID "udid" +#define FIELD_IS_SELF_PK "isSelfPk" +#define FIELD_GROUP_VISIBILITY "groupVisibility" +#define FIELD_EXPIRE_TIME "expireTime" +#define FIELD_IS_DELETE_ALL "isDeleteAll" + +typedef enum { + ALL_GROUP = 0, + IDENTICAL_ACCOUNT_GROUP = 1, + PEER_TO_PEER_GROUP = 256, + COMPATIBLE_GROUP = 512, + ACROSS_ACCOUNT_AUTHORIZE_GROUP = 1282 +} GroupType; + +typedef enum { + GROUP_CREATE = 0, + GROUP_DISBAND = 1, + MEMBER_INVITE = 2, + MEMBER_JOIN = 3, + MEMBER_DELETE = 4, + ACCOUNT_BIND = 5 +} GroupOperationCode; + +typedef enum { + AUTH_FORM_INVALID_TYPE = -1, + AUTH_FORM_ACCOUNT_UNRELATED = 0, + AUTH_FORM_IDENTICAL_ACCOUNT = 1, + AUTH_FORM_ACROSS_ACCOUNT = 2, +} GroupAuthForm; + +typedef enum { + CREDENTIAL_SAVE = 0, + CREDENTIAL_CLEAR = 1, + CREDENTIAL_UPDATE = 2, + CREDENTIAL_QUERY = 3, +} CredentialCode; + +typedef enum { + DEVICE_TYPE_ACCESSORY = 0, + DEVICE_TYPE_CONTROLLER = 1, + DEVICE_TYPE_PROXY = 2 +} UserType; + +typedef enum { + REQUEST_REJECTED = 0x80000005, + REQUEST_ACCEPTED = 0x80000006, + REQUEST_WAITING = 0x80000007 +} RequestResponse; + +typedef struct { + void (*onGroupCreated)(const char *groupInfo); + void (*onGroupDeleted)(const char *groupInfo); + void (*onDeviceBound)(const char *peerUdid, const char *groupInfo); + void (*onDeviceUnBound)(const char *peerUdid, const char *groupInfo); + void (*onDeviceNotTrusted)(const char *peerUdid); + void (*onLastGroupDeleted)(const char *peerUdid, int groupType); + void (*onTrustedDeviceNumChanged)(int curTrustedDeviceNum); +} DataChangeListener; + +typedef struct { + bool (*onTransmit)(int64_t requestId, const uint8_t *data, uint32_t dataLen); + void (*onSessionKeyReturned)(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen); + void (*onFinish)(int64_t requestId, int operationCode, const char *returnData); + void (*onError)(int64_t requestId, int operationCode, int errorCode, const char *errorReturn); + char *(*onRequest)(int64_t requestId, int operationCode, const char *reqParams); +} DeviceAuthCallback; + +typedef struct { + int32_t (*processData)(int64_t authReqId, const uint8_t *data, uint32_t dataLen, + const DeviceAuthCallback *gaCallback); + int32_t (*queryTrustedDeviceNum)(void); + bool (*isTrustedDevice)(const char *udid); + int32_t (*getAuthState)(int64_t authReqId, const char *groupId, const char *peerUdid, + uint8_t *out, uint32_t *outLen); + int32_t (*authDevice)(int64_t authReqId, const char *authParams, const DeviceAuthCallback *gaCallback); + void (*informDeviceDisconnection)(const char *udid); +} GroupAuthManager; + +typedef struct { + int32_t (*regCallback)(const char *appId, const DeviceAuthCallback *callback); + int32_t (*unRegCallback)(const char *appId); + int32_t (*regDataChangeListener)(const char *appId, const DataChangeListener *listener); + int32_t (*unRegDataChangeListener)(const char *appId); + int32_t (*createGroup)(int64_t requestId, const char *appId, const char *createParams); + int32_t (*deleteGroup)(int64_t requestId, const char *appId, const char *disbandParams); + int32_t (*addMemberToGroup)(int64_t requestId, const char *appId, const char *addParams); + int32_t (*deleteMemberFromGroup)(int64_t requestId, const char *appId, const char *deleteParams); + int32_t (*processData)(int64_t requestId, const uint8_t *data, uint32_t dataLen); + int32_t (*confirmRequest)(int64_t requestId, const char *appId, const char *confirmParams); + int32_t (*bindPeer)(int64_t requestId, const char *appId, const char *bindParams); + int32_t (*unbindPeer)(int64_t requestId, const char *appId, const char *unbindParams); + int32_t (*processLiteData)(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen); + int32_t (*authKeyAgree)(int64_t requestId, const char *appId, const char *buildParams); + int32_t (*processKeyAgreeData)(int64_t requestId, const char *appId, const uint8_t *data, uint32_t dataLen); + int32_t (*processCredential)(int operationCode, const char *reqJsonStr, char **returnJsonStr); + int32_t (*getRegisterInfo)(char **returnRegisterInfo); + int32_t (*getLocalConnectInfo)(char *returnInfo, int32_t bufLen); + int32_t (*checkAccessToGroup)(const char *appId, const char *groupId); + int32_t (*getPkInfoList)(const char *appId, const char *queryParams, char **returnInfoList, + uint32_t *returnInfoNum); + int32_t (*addGroupManager)(const char *appId, const char *groupId, const char *managerAppId); + int32_t (*addGroupFriend)(const char *appId, const char *groupId, const char *friendAppId); + int32_t (*deleteGroupManager)(const char *appId, const char *groupId, const char *managerAppId); + int32_t (*deleteGroupFriend)(const char *appId, const char *groupId, const char *friendAppId); + int32_t (*getGroupManagers)(const char *appId, const char *groupId, char **returnManagers, uint32_t *returnSize); + int32_t (*getGroupFriends)(const char *appId, const char *groupId, char **returnFriends, uint32_t *returnSize); + int32_t (*getGroupInfoById)(const char *appId, const char *groupId, char **returnGroupInfo); + int32_t (*getGroupInfo)(const char *appId, const char *queryParams, char **returnGroupVec, uint32_t *groupNum); + int32_t (*getJoinedGroups)(const char *appId, int groupType, char **returnGroupVec, uint32_t *groupNum); + int32_t (*getRelatedGroups)(const char *appId, const char *peerDeviceId, char **returnGroupVec, uint32_t *groupNum); + int32_t (*getDeviceInfoById)(const char *appId, const char *deviceId, const char *groupId, + char **returnDeviceInfo); + int32_t (*getTrustedDevices)(const char *appId, const char *groupId, char **returnDevInfoVec, uint32_t *deviceNum); + bool (*isDeviceInGroup)(const char *appId, const char *groupId, const char *deviceId); + void (*destroyInfo)(char **returnInfo); +} DeviceGroupManager; + +#ifdef __cplusplus +extern "C" { +#endif +DEVICE_AUTH_API_PUBLIC int InitDeviceAuthService(void); +DEVICE_AUTH_API_PUBLIC void DestroyDeviceAuthService(void); +DEVICE_AUTH_API_PUBLIC const GroupAuthManager *GetGaInstance(void); +DEVICE_AUTH_API_PUBLIC const DeviceGroupManager *GetGmInstance(void); +#ifdef __cplusplus +} +#endif +#endif diff --git a/test/unittest/mock/ipc_server_listener.cpp b/test/unittest/mock/ipc_server_listener.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4928b3b70718d6c919c03a751becb892870c8484 --- /dev/null +++ b/test/unittest/mock/ipc_server_listener.cpp @@ -0,0 +1,32 @@ +/* + * 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" + +namespace OHOS { +namespace DistributedHardware { +int32_t IpcServerListener::SendRequest(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + req_ = req; + return 0; +} + +int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr req, std::shared_ptr rsp) +{ + req_ = req; + std::cout<GetPkgName()<<"\n"; + return 0; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/test/unittest/mock/ipc_server_listener.h b/test/unittest/mock/ipc_server_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..20462face186ec8da83508b629367a5d141844c1 --- /dev/null +++ b/test/unittest/mock/ipc_server_listener.h @@ -0,0 +1,37 @@ +/* + * 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_IPC_SERVER_LISTENER_H +#define OHOS_DM_IPC_SERVER_LISTENER_H + +#include +#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); + std::shared_ptr req_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_SERVER_LISTENER_H \ No newline at end of file diff --git a/test/unittest/mock/parameter.cpp b/test/unittest/mock/parameter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c3b8136f366a70519fb8a9176dca87ecf57031c8 --- /dev/null +++ b/test/unittest/mock/parameter.cpp @@ -0,0 +1,16 @@ +#include "parameter.h" + +int GetParameter(const char *key, const char *def, char *value, unsigned int len) +{ + return 0; +} + +int SetParameter(const char *key, const char *value) +{ + return 0; +} + +int WatchParameter(const char *keyprefix, ParameterChgPtr callback, void *context) +{ + return 0; +} diff --git a/test/unittest/mock/parameter.h b/test/unittest/mock/parameter.h new file mode 100644 index 0000000000000000000000000000000000000000..68f0b5d816e0e5792a3ad0a6f9b1a5a5ffed0760 --- /dev/null +++ b/test/unittest/mock/parameter.h @@ -0,0 +1,24 @@ +#ifndef PARAMETER__H +#define PARAMETER__H + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + + +int GetParameter(const char *key, const char *def, char *value, unsigned int len); + +int SetParameter(const char *key, const char *value); + +typedef void (*ParameterChgPtr)(const char *key, const char *value, void *context); +int WatchParameter(const char *keyprefix, ParameterChgPtr callback, void *context); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif \ No newline at end of file diff --git a/test/unittest/mock/session.h b/test/unittest/mock/session.h new file mode 100644 index 0000000000000000000000000000000000000000..d9934401f5875e1d11a45dd6c2e54edd372260c3 --- /dev/null +++ b/test/unittest/mock/session.h @@ -0,0 +1,185 @@ +/* + * 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. + */ + +/** + * @addtogroup Softbus + * @{ + * + * @brief Provides high-speed, secure communication between devices. + * + * This module implements unified distributed communication capability management between + * nearby devices, and provides link-independent device discovery and transmission interfaces + * to support service publishing and data transmission. + * + * @since 1.0 + * @version 1.0 +*/ + +/** + * @file session.h + * + * @brief Declares unified data transmission interfaces. + * + * This file provides data transmission capabilities, including creating and removing a session server, + * opening and closing sessions, receiving data, and querying basic session information. \n + * After multiple nearby devices are discovered and networked, these interfaces can be used to + * transmit data across devices. \n + * + * @since 1.0 + * @version 1.0 + */ +#ifndef SESSION_H +#define SESSION_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif +/** + * @brief bussiness type of session + * + * @since 1.0 + * @version 1.0 + */ +typedef enum { + TYPE_MESSAGE = 1, + TYPE_BYTES, + TYPE_FILE, + TYPE_STREAM, + TYPE_BUTT, +} SessionType; + +typedef enum { + INVALID = -1, + /* + * Send any segment of a frame each time. + */ + RAW_STREAM, + /* + * Send a whole video frame each time. + */ + COMMON_VIDEO_STREAM, + /* + * Send a whole audio frame each time. + */ + COMMON_AUDIO_STREAM, + /* + * Slice frame mode. + */ + VIDEO_SLICE_STREAM, +} StreamType; + +typedef enum { + LINK_TYPE_WIFI_WLAN_5G = 1, + LINK_TYPE_WIFI_WLAN_2G = 2, + LINK_TYPE_WIFI_P2P = 3, + LINK_TYPE_BR = 4, + LINK_TYPE_MAX = 4, +} LinkType; + +typedef struct { + /** @brief dataType{@link SessionType} */ + int dataType; + int linkTypeNum; + LinkType linkType[LINK_TYPE_MAX]; + union { + struct StreamAttr { + int streamType; + } streamAttr; + } attr; +} SessionAttribute; + +typedef struct { + char *buf; + int bufLen; +} StreamData; + +typedef struct { + int type; + int64_t value; +} TV; + +typedef struct { + int frameType; + int64_t timeStamp; + int seqNum; + int seqSubNum; + int level; + int bitMap; + int tvCount; + TV *tvList; +} FrameInfo; + +typedef struct { + + int (*OnSessionOpened)(int sessionId, int result); + + void (*OnSessionClosed)(int sessionId); + + void (*OnBytesReceived)(int sessionId, const void *data, unsigned int dataLen); + + void (*OnMessageReceived)(int sessionId, const void *data, unsigned int dataLen); + + void (*OnStreamReceived)(int sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param); +} ISessionListener; + +typedef struct { + int (*OnReceiveFileStarted)(int sessionId, const char *files, int fileCnt); + int (*OnReceiveFileProcess)(int sessionId, const char *firstFile, uint64_t bytesUpload, uint64_t bytesTotal); + void (*OnReceiveFileFinished)(int sessionId, const char *files, int fileCnt); + void (*OnFileTransError)(int sessionId); +} IFileReceiveListener; + +typedef struct { + int (*OnSendFileProcess)(int sessionId, uint64_t bytesUpload, uint64_t bytesTotal); + int (*OnSendFileFinished)(int sessionId, const char *firstFile); + void (*OnFileTransError)(int sessionId); +} IFileSendListener; + +int CreateSessionServer(const char *pkgName, const char *sessionName, const ISessionListener *listener); + +int RemoveSessionServer(const char *pkgName, const char *sessionName); + +int OpenSession(const char *mySessionName, const char *peerSessionName, const char *peerDeviceId, + const char *groupId, const SessionAttribute* attr); + +void CloseSession(int sessionId); + +int SendBytes(int sessionId, const void *data, unsigned int len); + +int SendMessage(int sessionId, const void *data, unsigned int len); + +int SendStream(int sessionId, const StreamData *data, const StreamData *ext, const FrameInfo *param); + +int GetMySessionName(int sessionId, char *sessionName, unsigned int len); + +int GetPeerSessionName(int sessionId, char *sessionName, unsigned int len); + + +int GetPeerDeviceId(int sessionId, char *devId, unsigned int len); + +int GetSessionSide(int sessionId); + +int SetFileReceiveListener(const char *pkgName, const char *sessionName, + const IFileReceiveListener *recvListener, const char *rootDir); + +int SetFileSendListener(const char *pkgName, const char *sessionName, const IFileSendListener *sendListener); + +int SendFile(int sessionId, const char *sFileList[], const char *dFileList[], uint32_t fileCnt); +#ifdef __cplusplus +} +#endif +#endif // SESSION_H diff --git a/test/unittest/mock/softbus_bus_center.cpp b/test/unittest/mock/softbus_bus_center.cpp new file mode 100644 index 0000000000000000000000000000000000000000..59170bf99cfc4e0cc940d5ce22f3507fd6a19a68 --- /dev/null +++ b/test/unittest/mock/softbus_bus_center.cpp @@ -0,0 +1,18 @@ +#include "softbus_connector.h" + + + +int32_t GetNodeKeyInfo(const char *pkgName, const char *networkId, NodeDeivceInfoKey key, uint8_t *info, int32_t infoLen) +{ + return 0; +} + + +int32_t RegNodeDeviceStateCb(const char *pkgName, INodeStateCb *callback){ + return 0; +}; + +int32_t GetAllNodeDeviceInfo(const char *pkgName, NodeBasicInfo **info, int32_t *infoNum) +{ + return 0; +} \ No newline at end of file diff --git a/utils/BUILD.gn b/utils/BUILD.gn index b84acfffa135180d16874af390034caebf4363a3..6fb1469ccb7768533cd4a7f7ce9a3d46727be4d7 100644 --- a/utils/BUILD.gn +++ b/utils/BUILD.gn @@ -21,79 +21,27 @@ import("//foundation/distributedhardware/devicemanager/devicemanager.gni") if (defined(ohos_lite)) { shared_library("devicemanagerutils") { - include_dirs = [ - "${common_path}/include", - "${common_path}/include/ipc", - "${common_path}/include/ipc/model", - "include", - "include/log", - "include/cipher", - "include/ipc/lite", - ] - - include_dirs += [ - "//base/security/deviceauth/interfaces/innerkits", - "//base/startup/syspara_lite/interfaces/innerkits/native/syspara/include", - "//utils/native/lite/include", - "//utils/system/safwk/native/include", - "//third_party/json/include", - "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits/hilog", - "//third_party/bounds_checking_function/include", - "//foundation/communication/ipc_lite/interfaces/kits", - "//foundation/communication/dsoftbus/interfaces/kits/bus_center", - "//foundation/communication/dsoftbus/interfaces/kits/common", - "//foundation/communication/dsoftbus/interfaces/kits/discovery", - "//foundation/communication/dsoftbus/interfaces/kits/transport", - "//foundation/communication/dsoftbus/interfaces/inner_kits/transport", - "//foundation/distributedschedule/samgr_lite/interfaces/kits/samgr", - ] - - sources = [ - "src/anonymous_string.cpp", - "src/cipher/encrypt_utils.cpp", - "src/ipc/lite/ipc_cmd_register.cpp", - "src/log/dm_log.cpp", - ] - - defines = [ - "HI_LOG_ENABLE", - "DH_LOG_TAG=\"devicemanagerutils\"", - "LOG_DOMAIN=0xD004100", - ] - - deps = [ - "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", - "//base/startup/syspara_lite/frameworks/parameter/src:sysparam", - "//foundation/communication/dsoftbus/sdk:softbus_client", - "//foundation/communication/ipc_lite:liteipc_adapter", - "//foundation/distributedschedule/samgr_lite/samgr:samgr", - "//third_party/bounds_checking_function:libsec_shared", - "//third_party/mbedtls:mbedtls_shared", - "//utils/native/lite:utils", - ] } } else { ohos_shared_library("devicemanagerutils") { include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", "${common_path}/include", "${common_path}/include/ipc", "${common_path}/include/ipc/model", "include", - "include/cipher", - "include/log", "include/ipc/standard", + "//utils/native/base/include", + "//utils/system/safwk/native/include", "//base/security/deviceauth/interfaces/innerkits", "//base/startup/syspara_lite/adapter/native/syspara/include", "//third_party/json/include", ] sources = [ - "src/anonymous_string.cpp", - "src/cipher/encrypt_utils.cpp", + "src/dm_anonymous.cpp", + "src/dm_log.cpp", + "src/dm_random.cpp", "src/ipc/standard/ipc_cmd_register.cpp", - "src/log/dm_log.cpp", ] deps = [ @@ -108,15 +56,8 @@ if (defined(ohos_lite)) { ] external_deps = [ - "appexecfwk_standard:appexecfwk_base", - "appexecfwk_standard:appexecfwk_core", - "appexecfwk_standard:libeventhandler", - "dsoftbus_standard:softbus_client", "hiviewdfx_hilog_native:libhilog", "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_standard:samgr_proxy", - "startup_l2:syspara", ] subsystem_name = "distributedhardware" diff --git a/utils/include/cipher/encrypt_utils.h b/utils/include/cipher/encrypt_utils.h deleted file mode 100644 index db19b2364713391934bd468802c90c03659bdd11..0000000000000000000000000000000000000000 --- a/utils/include/cipher/encrypt_utils.h +++ /dev/null @@ -1,46 +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_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/anonymous_string.h b/utils/include/dm_anonymous.h similarity index 79% rename from utils/include/anonymous_string.h rename to utils/include/dm_anonymous.h index 4144e517c2700242a3f6168ac1eb807a98208563..d8059e0b139cfd9b88feb891962f1b9f9bf894e7 100644 --- a/utils/include/anonymous_string.h +++ b/utils/include/dm_anonymous.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,14 +13,16 @@ * limitations under the License. */ -#ifndef ANONYMOUS_STRING_H -#define ANONYMOUS_STRING_H +#ifndef OHOS_DM_ANONYMOUS_H +#define OHOS_DM_ANONYMOUS_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 +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_ANONYMOUS_H \ No newline at end of file diff --git a/utils/include/dm_log.h b/utils/include/dm_log.h new file mode 100644 index 0000000000000000000000000000000000000000..cd0415926359b1b9f417abff0ab87031624c8b27 --- /dev/null +++ b/utils/include/dm_log.h @@ -0,0 +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. + */ + +#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, ...); + +#define LOGD(fmt, ...) \ + DMLog(DM_LOG_DEBUG, (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) + +#define LOGI(fmt, ...) \ + DMLog(DM_LOG_INFO, (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) + +#define LOGW(fmt, ...) \ + DMLog(DM_LOG_WARN, (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) + +#define LOGE(fmt, ...) \ + DMLog(DM_LOG_ERROR, (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_LOG_H diff --git a/utils/include/dm_random.h b/utils/include/dm_random.h new file mode 100644 index 0000000000000000000000000000000000000000..dcbe1ef1e87b080e77c7ed65ea89f56691a4190d --- /dev/null +++ b/utils/include/dm_random.h @@ -0,0 +1,30 @@ +/* + * 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_RANDOM_H +#define OHOS_DM_RANDOM_H + +#include + +namespace OHOS { +namespace DistributedHardware { +int32_t GenRandInt(int32_t randMin, int32_t randMax); +int64_t GenRandLongLong(int64_t randMin, int64_t randMax); +int32_t GetRandomData(uint8_t *randStr, uint32_t len); +bool MbedtlsGenRandomStr(char *szOut, int32_t szOutLen, bool numberOnly); +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_RANDOM_H diff --git a/utils/include/ipc/lite/ipc_cmd_register.h b/utils/include/ipc/lite/ipc_cmd_register.h index 0144df0d69811a46de57970afcb556928ee9d717..f3d6ac3d7b40b0ea26a9626bb03c433dfec66559 100644 --- a/utils/include/ipc/lite/ipc_cmd_register.h +++ b/utils/include/ipc/lite/ipc_cmd_register.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,74 +13,74 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H -#define OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H +#ifndef OHOS_DM_IPC_CMD_PARSER_H +#define OHOS_DM_IPC_CMD_PARSER_H #include -#include #include - -#include "liteipc_adapter.h" -#include "single_instance.h" +#include #include "ipc_req.h" #include "ipc_rsp.h" +#include "liteipc_adapter.h" +#include "single_instance.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() \ - { \ +#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) \ + } \ + }; \ + 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() \ - { \ +#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) \ + } \ + }; \ + IpcRegisterReadResponseFunc##cmdCode g_IpcRegisterReadResponseFunc##cmdCode; \ + static int32_t IpcReadResponse##cmdCode(paraA, paraB) -#define ON_IPC_CMD(cmdCode, paraA) \ - static void IpcCmdProcess##cmdCode(paraA); \ - struct IpcRegisterCmdProcessFunc##cmdCode { \ - IpcRegisterCmdProcessFunc##cmdCode() \ - { \ +#define ON_IPC_CMD(cmdCode, paraA) \ + static void IpcCmdProcess##cmdCode(paraA); \ + struct IpcRegisterCmdProcessFunc##cmdCode { \ + IpcRegisterCmdProcessFunc##cmdCode() \ + { \ IpcCmdRegister::GetInstance().RegisterCmdProcessFunc(cmdCode, IpcCmdProcess##cmdCode); \ - } \ - }; \ - IpcRegisterCmdProcessFunc##cmdCode g_IpcRegisterCmdProcessFunc##cmdCode; \ - static void IpcCmdProcess##cmdCode(paraA) \ + } \ + }; \ + IpcRegisterCmdProcessFunc##cmdCode g_IpcRegisterCmdProcessFunc##cmdCode; \ + static void IpcCmdProcess##cmdCode(paraA) -#define ON_IPC_SERVER_CMD(cmdCode, paraA, paraB) \ - static void IpcServerCmdProcess##cmdCode(paraA, paraB); \ - class IpcRegisterServerCmdProcessFunc##cmdCode { \ - public: \ - IpcRegisterServerCmdProcessFunc##cmdCode() \ - { \ +#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; \ + } \ + }; \ + 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 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); using OnIpcServerCmdFunc = void (*)(IpcIo &req, IpcIo &reply); class IpcCmdRegister { -DECLARE_SINGLE_INSTANCE(IpcCmdRegister); + DECLARE_SINGLE_INSTANCE(IpcCmdRegister); + public: void RegisterSetRequestFunc(int32_t cmdCode, SetIpcRequestFunc setIpcRequestFunc) { @@ -98,11 +98,12 @@ public: { onIpcServerCmdFuncMap_.emplace(cmdCode, onIpcServerCmdFunc); }; - int32_t SetRequest(int32_t cmdCode, std::shared_ptr pBaseReq, IpcIo &request, - uint8_t *buffer, size_t buffLen); + 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); int32_t OnIpcServerCmd(int32_t cmdCode, IpcIo &req, IpcIo &reply); + private: std::unordered_map setIpcRequestFuncMap_; std::unordered_map readResponseFuncMap_; @@ -111,4 +112,4 @@ private: }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H \ No newline at end of file +#endif // OHOS_DM_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 index c2c5d585d375918c35152369d2a8974aa5e5654a..167f4ec501a4a30a00c5b17ce8f3c369d714dbcd 100644 --- a/utils/include/ipc/standard/ipc_cmd_register.h +++ b/utils/include/ipc/standard/ipc_cmd_register.h @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,53 +13,52 @@ * limitations under the License. */ -#ifndef OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H -#define OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H +#ifndef OHOS_DM_IPC_CMD_PARSER_H +#define OHOS_DM_IPC_CMD_PARSER_H #include -#include #include +#include -#include "iremote_broker.h" -#include "single_instance.h" - -#include "ipc_types.h" #include "ipc_req.h" #include "ipc_rsp.h" +#include "ipc_types.h" +#include "iremote_broker.h" +#include "single_instance.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() \ - { \ +#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) \ + } \ + }; \ + 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() \ - { \ +#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) \ + } \ + }; \ + 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() \ - { \ +#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; \ + } \ + }; \ + IpcRegisterCmdProcessFunc##cmdCode g_IpcRegisterCmdProcessFunc##cmdCode; \ static int32_t IpcCmdProcess##cmdCode(paraA, paraB) using SetIpcRequestFunc = int32_t (*)(std::shared_ptr pBaseReq, MessageParcel &data); @@ -67,7 +66,8 @@ using ReadResponseFunc = int32_t (*)(MessageParcel &reply, 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_; @@ -91,4 +92,4 @@ private: }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_IPC_CMD_PARSER_H \ No newline at end of file +#endif // OHOS_DM_IPC_CMD_PARSER_H \ No newline at end of file diff --git a/utils/src/anonymous_string.cpp b/utils/src/dm_anonymous.cpp similarity index 73% rename from utils/src/anonymous_string.cpp rename to utils/src/dm_anonymous.cpp index f5834ee376f6e736788d092d424c4f9cbe571ef5..8d9a7be38150da21a5f2b8a01a9d383e4542d484 100644 --- a/utils/src/anonymous_string.cpp +++ b/utils/src/dm_anonymous.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,9 +13,7 @@ * limitations under the License. */ -#include "anonymous_string.h" - -#include "securec.h" +#include "dm_anonymous.h" namespace OHOS { namespace DistributedHardware { @@ -24,13 +22,14 @@ std::string GetAnonyString(const std::string &value) const int32_t INT32_SHORT_ID_LENGTH = 20; const int32_t INT32_PLAINTEXT_LENGTH = 4; const int32_t INT32_MIN_ID_LENGTH = 3; - std::string res; + std::string tmpStr("******"); int32_t strLen = value.length(); if (strLen < INT32_MIN_ID_LENGTH) { return tmpStr; } + std::string res; if (strLen <= INT32_SHORT_ID_LENGTH) { res += value[0]; res += tmpStr; @@ -46,23 +45,17 @@ std::string GetAnonyString(const std::string &value) std::string GetAnonyInt32(const int32_t value) { - const int32_t 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] = '*'; - } + std::string tempString = std::to_string(value); + int32_t length = tempString.length(); if (length == 0x01) { - tempBuffer[0] = '*'; + tempString[0] = '*'; + return tempString; } - std::string tempSting(tempBuffer); - return tempSting; -} + for (int32_t i = 1; i < length - 1; i++) { + tempString[i] = '*'; + } + return tempString; } -} \ No newline at end of file +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file diff --git a/utils/src/log/dm_log.cpp b/utils/src/dm_log.cpp similarity index 96% rename from utils/src/log/dm_log.cpp rename to utils/src/dm_log.cpp index 538594b1564ab13ca0afc2e82cc10013465aabf6..2284eabda2e434456a5b4a348d5cbb025d3e0c5c 100644 --- a/utils/src/log/dm_log.cpp +++ b/utils/src/dm_log.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,15 +15,13 @@ #include "dm_log.h" +#include "dm_constants.h" #include "securec.h" -#include "constants.h" - #ifdef HI_LOG_ENABLE #include "hilog/log.h" #else #include - #endif namespace OHOS { diff --git a/utils/src/cipher/encrypt_utils.cpp b/utils/src/dm_random.cpp similarity index 61% rename from utils/src/cipher/encrypt_utils.cpp rename to utils/src/dm_random.cpp index 67a39b9c44b1c26513c7f0d3a79b102c8688c784..129b0792ec850875961731e36d0373e1044d4e1a 100644 --- a/utils/src/cipher/encrypt_utils.cpp +++ b/utils/src/dm_random.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -13,37 +13,20 @@ * limitations under the License. */ -#include "encrypt_utils.h" +#include "dm_random.h" -#include "mbedtls/base64.h" -#include "mbedtls/gcm.h" -#include "mbedtls/md.h" +#include +#include "dm_constants.h" +#include "mbedtls/base64.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" +#include "mbedtls/gcm.h" +#include "mbedtls/md.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) +int32_t GenRandInt(int32_t randMin, int32_t randMax) { std::random_device randDevice; std::mt19937 genRand(randDevice()); @@ -51,7 +34,7 @@ int32_t EncryptUtils::GenRandInt(int32_t randMin, int32_t randMax) return disRand(genRand); } -int64_t EncryptUtils::GenRandLongLong(int64_t randMin, int64_t randMax) +int64_t GenRandLongLong(int64_t randMin, int64_t randMax) { std::random_device randDevice; std::mt19937 genRand(randDevice()); @@ -59,11 +42,11 @@ int64_t EncryptUtils::GenRandLongLong(int64_t randMin, int64_t randMax) return disRand(genRand); } -int32_t EncryptUtils::GetRandomData(uint8_t *randStr, uint32_t len) +int32_t GetRandomData(uint8_t *randStr, uint32_t len) { mbedtls_entropy_context *entropy = nullptr; mbedtls_ctr_drbg_context *ctrDrbg = nullptr; - int32_t ret = DEVICEMANAGER_FAILED; + int32_t ret = DM_FAILED; do { if (randStr == nullptr || len == 0) { break; @@ -86,7 +69,7 @@ int32_t EncryptUtils::GetRandomData(uint8_t *randStr, uint32_t len) if (ret != 0) { break; } - ret = DEVICEMANAGER_OK; + ret = DM_OK; } while (0); if (entropy != nullptr) { free(entropy); @@ -97,36 +80,14 @@ int32_t EncryptUtils::GetRandomData(uint8_t *randStr, uint32_t len) return ret; } -int32_t EncryptUtils::MbedtlsEncrypt(const uint8_t *plainText, int32_t plainTextLen, uint8_t *cipherText, - int32_t cipherTextLen, int32_t *outLen) -{ - // Security algorithms do not support open source. Customize if required - 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) -{ - // Security algorithms do not support open source. Customize if required - (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) +bool MbedtlsGenRandomStr(char *szOut, int32_t szOutLen, bool numberOnly) { const int32_t MIN_OUT_LENGTH = 2; if (szOut == nullptr || szOutLen <= MIN_OUT_LENGTH) { return false; } szOut[--szOutLen] = 0; - GetRandomData((uint8_t*)szOut, szOutLen); + GetRandomData((uint8_t *)szOut, szOutLen); const int32_t NUMBER_COUNT = 10; const int32_t ALPHA_COUNT = 26; const int32_t ALPHA_BYTE_COUNT = 2; diff --git a/utils/src/ipc/lite/ipc_cmd_register.cpp b/utils/src/ipc/lite/ipc_cmd_register.cpp index 4fbab5a16f3cca12e26327734274f41df837f76d..2a3e76d2b0c665a85dbd2b573765812380e94446 100644 --- a/utils/src/ipc/lite/ipc_cmd_register.cpp +++ b/utils/src/ipc/lite/ipc_cmd_register.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,20 +15,20 @@ #include "ipc_cmd_register.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" +#include "dm_constants.h" +#include "dm_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) +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; + LOGE("cmdCode:%d not register SetRequestFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } return (setRequestMapIter->second)(pBaseReq, request, buffer, buffLen); } @@ -37,8 +37,8 @@ int32_t IpcCmdRegister::ReadResponse(int32_t cmdCode, IpcIo &reply, std::shared_ { 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; + LOGE("cmdCode:%d not register ReadResponseFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } return (readResponseMapIter->second)(reply, pBaseRsp); } @@ -47,22 +47,22 @@ int32_t IpcCmdRegister::OnIpcCmd(int32_t cmdCode, IpcIo &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; + LOGE("cmdCode:%d not register OnIpcCmdFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } (onIpcCmdMapIter->second)(reply); - return DEVICEMANAGER_OK; + return DM_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; + LOGE("cmdCode:%d not register OnIpcCmdFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } (onIpcServerCmdMapIter->second)(req, reply); - return DEVICEMANAGER_OK; + return DM_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 index e958dfd0498f15838b8cb7c6b7afaad37e841d25..2d3f3fd2c4723db8228e6a06a5b894b74b70b345 100644 --- a/utils/src/ipc/standard/ipc_cmd_register.cpp +++ b/utils/src/ipc/standard/ipc_cmd_register.cpp @@ -4,7 +4,7 @@ * 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 + * 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, @@ -15,8 +15,8 @@ #include "ipc_cmd_register.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" +#include "dm_constants.h" +#include "dm_log.h" namespace OHOS { namespace DistributedHardware { @@ -26,8 +26,8 @@ int32_t IpcCmdRegister::SetRequest(int32_t cmdCode, std::shared_ptr pBas { 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; + LOGE("cmdCode:%d not register SetRequestFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } return (setRequestMapIter->second)(pBaseReq, data); } @@ -36,8 +36,8 @@ int32_t IpcCmdRegister::ReadResponse(int32_t cmdCode, MessageParcel &reply, std: { 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; + LOGE("cmdCode:%d not register ReadResponseFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } return (readResponseMapIter->second)(reply, pBaseRsp); } @@ -46,8 +46,8 @@ int32_t IpcCmdRegister::OnIpcCmd(int32_t cmdCode, MessageParcel &data, MessagePa { 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; + LOGE("cmdCode:%d not register OnIpcCmdFunc", cmdCode); + return DM_IPC_NOT_REGISTER_FUNC; } return (onIpcCmdMapIter->second)(data, reply); }