From d02afc1ad2ca088f2b8458feb527aee26d95e001 Mon Sep 17 00:00:00 2001 From: yuqianyuan Date: Sat, 11 Sep 2021 14:25:35 +0800 Subject: [PATCH 1/2] add files Signed-off-by: yuqianyuan --- common/include/constants.h | 159 +++++ .../include/device_manager_errno.h | 112 +-- .../include/device_manager_log.h | 55 +- common/{utils => }/include/single_instance.h | 0 interfaces/inner_kits/native_cpp/BUILD.gn | 80 --- .../native_cpp/include/device_manager.h | 67 -- .../include/device_manager_listener_stub.h | 64 -- .../native_cpp/include/device_manager_proxy.h | 49 -- .../native_cpp/include/dm_subscribe_info.h | 82 --- .../native_cpp/include/idevice_manager.h | 55 -- .../native_cpp/src/device_manager.cpp | 314 -------- .../src/device_manager_listener_stub.cpp | 303 -------- .../native_cpp/src/device_manager_proxy.cpp | 316 --------- .../native_cpp/src/dm_subscribe_info.cpp | 58 -- ...hos.distributedHardware.deviceManager.d.ts | 311 ++++++++ interfaces/kits/js/BUILD.gn | 34 +- interfaces/kits/js/include/dm_native_event.h | 2 +- .../kits/js/include/native_devicemanager_js.h | 64 +- interfaces/kits/js/src/dm_native_event.cpp | 22 +- .../kits/js/src/native_devicemanager_js.cpp | 669 ++++++++++++++---- services/devicemanagerservice/BUILD.gn | 234 ++++-- .../include/ability/dm_ability_manager.h | 119 ++-- .../hichain_connector.h} | 213 +++--- .../include/device_manager_listener_proxy.h | 44 -- .../include/device_manager_service.h | 98 --- .../include/device_manager_stub.h | 48 -- .../msg_codec.h} | 98 ++- .../include/message/msg_head.h | 48 ++ .../include/message/msg_request_auth.h | 83 +++ .../msg_response_auth.h} | 113 +-- .../include/message/msg_sync_group.h | 77 +- .../include/requestauth/auth_manager.h | 112 +-- .../include/requestauth/request_session.h | 77 ++ .../include/requestauth/response_session.h | 86 +++ .../include/softbus/softbus_adapter.h | 78 +- .../include/softbus/softbus_session.h | 105 +-- .../src/ability/dm_ability_manager.cpp | 94 +++ .../src/auth/hichain_connector.cpp | 424 +++++++++++ .../src/authdemo/device_client_channel.cpp | 166 ----- .../src/authdemo/device_server_channel.cpp | 205 ------ .../src/authdemo/hichain_adapter.cpp | 384 ---------- .../src/device_manager_listener_proxy.cpp | 294 -------- .../src/device_manager_service.cpp | 291 -------- .../src/device_manager_stub.cpp | 205 ------ .../src/message/msg_codec.cpp | 98 +++ .../src/message/msg_head.cpp | 102 +-- .../src/message/msg_request_auth.cpp | 375 ++++++++++ .../src/message/msg_response_auth.cpp | 160 +++++ .../src/message/msg_sync_group.cpp | 40 ++ .../src/requestauth/auth_manager.cpp | 238 +++++++ .../src/requestauth/request_session.cpp | 256 +++++++ .../src/requestauth/response_session.cpp | 294 ++++++++ .../src/softbus/softbus_adapter.cpp | 623 ++++++++-------- .../src/softbus/softbus_session.cpp | 230 ++++++ .../src/util/anonymous_string.cpp | 71 -- 55 files changed, 4676 insertions(+), 4323 deletions(-) create mode 100644 common/include/constants.h rename interfaces/inner_kits/native_cpp/include/dm_device_info.h => common/include/device_manager_errno.h (34%) rename services/devicemanagerservice/include/util/anonymous_string.h => common/include/device_manager_log.h (67%) rename common/{utils => }/include/single_instance.h (100%) delete mode 100644 interfaces/inner_kits/native_cpp/BUILD.gn delete mode 100644 interfaces/inner_kits/native_cpp/include/device_manager.h delete mode 100644 interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h delete mode 100644 interfaces/inner_kits/native_cpp/include/device_manager_proxy.h delete mode 100644 interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h delete mode 100644 interfaces/inner_kits/native_cpp/include/idevice_manager.h delete mode 100644 interfaces/inner_kits/native_cpp/src/device_manager.cpp delete mode 100644 interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp delete mode 100644 interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp delete mode 100644 interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp create mode 100644 interfaces/kits/js/@ohos.distributedHardware.deviceManager.d.ts rename common/log/include/device_manager_log.h => services/devicemanagerservice/include/ability/dm_ability_manager.h (41%) rename services/devicemanagerservice/include/{authdemo/hichain_adapter.h => auth/hichain_connector.h} (40%) delete mode 100644 services/devicemanagerservice/include/device_manager_listener_proxy.h delete mode 100644 services/devicemanagerservice/include/device_manager_service.h delete mode 100644 services/devicemanagerservice/include/device_manager_stub.h rename services/devicemanagerservice/include/{authdemo/device_server_channel.h => message/msg_codec.h} (38%) create mode 100644 services/devicemanagerservice/include/message/msg_head.h create mode 100644 services/devicemanagerservice/include/message/msg_request_auth.h rename services/devicemanagerservice/include/{authdemo/device_client_channel.h => message/msg_response_auth.h} (38%) rename common/utils/include/device_manager_errno.h => services/devicemanagerservice/include/message/msg_sync_group.h (49%) rename interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h => services/devicemanagerservice/include/requestauth/auth_manager.h (31%) create mode 100644 services/devicemanagerservice/include/requestauth/request_session.h create mode 100644 services/devicemanagerservice/include/requestauth/response_session.h rename interfaces/inner_kits/native_cpp/include/device_manager_callback.h => services/devicemanagerservice/include/softbus/softbus_session.h (38%) create mode 100644 services/devicemanagerservice/src/ability/dm_ability_manager.cpp create mode 100644 services/devicemanagerservice/src/auth/hichain_connector.cpp delete mode 100644 services/devicemanagerservice/src/authdemo/device_client_channel.cpp delete mode 100644 services/devicemanagerservice/src/authdemo/device_server_channel.cpp delete mode 100644 services/devicemanagerservice/src/authdemo/hichain_adapter.cpp delete mode 100644 services/devicemanagerservice/src/device_manager_listener_proxy.cpp delete mode 100644 services/devicemanagerservice/src/device_manager_service.cpp delete mode 100644 services/devicemanagerservice/src/device_manager_stub.cpp create mode 100644 services/devicemanagerservice/src/message/msg_codec.cpp rename interfaces/inner_kits/native_cpp/src/dm_device_info.cpp => services/devicemanagerservice/src/message/msg_head.cpp (47%) create mode 100644 services/devicemanagerservice/src/message/msg_request_auth.cpp create mode 100644 services/devicemanagerservice/src/message/msg_response_auth.cpp create mode 100644 services/devicemanagerservice/src/message/msg_sync_group.cpp create mode 100644 services/devicemanagerservice/src/requestauth/auth_manager.cpp create mode 100644 services/devicemanagerservice/src/requestauth/request_session.cpp create mode 100644 services/devicemanagerservice/src/requestauth/response_session.cpp create mode 100644 services/devicemanagerservice/src/softbus/softbus_session.cpp delete mode 100644 services/devicemanagerservice/src/util/anonymous_string.cpp diff --git a/common/include/constants.h b/common/include/constants.h new file mode 100644 index 000000000..d9e21679c --- /dev/null +++ b/common/include/constants.h @@ -0,0 +1,159 @@ +/* + * 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_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; + + // 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; +} +} +#endif diff --git a/interfaces/inner_kits/native_cpp/include/dm_device_info.h b/common/include/device_manager_errno.h similarity index 34% rename from interfaces/inner_kits/native_cpp/include/dm_device_info.h rename to common/include/device_manager_errno.h index 58952222e..ab01276d9 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_device_info.h +++ b/common/include/device_manager_errno.h @@ -1,51 +1,61 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_DEVICE_INFO_H -#define OHOS_DEVICE_MANAGER_DEVICE_INFO_H - -#include "parcel.h" - -namespace OHOS { -namespace DistributedHardware { -enum DMDeviceType : uint8_t { - DEVICE_TYPE_UNKNOWN = 0x00, - DEVICE_TYPE_WIFI_CAMERA = 0x08, - DEVICE_TYPE_AUDIO = 0x0A, - DEVICE_TYPE_PC = 0x0C, - DEVICE_TYPE_PHONE = 0x0E, - DEVICE_TYPE_PAD = 0x11, - DEVICE_TYPE_WATCH = 0x6D, - DEVICE_TYPE_CAR = 0x83, - DEVICE_TYPE_TV = 0x9C, -}; - -enum DmDeviceState : uint8_t { - DEVICE_STATE_UNKNOWN = 0, - DEVICE_STATE_ONLINE = 1, - DEVICE_STATE_OFFLINE = 2, -}; - -struct DmDeviceInfo : public Parcelable { - std::string deviceId; - std::string deviceName; - DMDeviceType deviceTypeId; - bool ReadFromParcel(Parcel &parcel); - virtual bool Marshalling(Parcel &parcel) const override; - static DmDeviceInfo *Unmarshalling(Parcel &parcel); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_DEVICE_INFO_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DEVICE_MANAGER_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/services/devicemanagerservice/include/util/anonymous_string.h b/common/include/device_manager_log.h similarity index 67% rename from services/devicemanagerservice/include/util/anonymous_string.h rename to common/include/device_manager_log.h index dd58b7384..9f5e3ae46 100644 --- a/services/devicemanagerservice/include/util/anonymous_string.h +++ b/common/include/device_manager_log.h @@ -1,26 +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 ANONYMOUS_STRING_H -#define ANONYMOUS_STRING_H -#include - -namespace OHOS { -namespace DistributedHardware { -std::string GetAnonyString(const std::string &value); -std::string GetAnonyInt32(const int32_t value); -} -} -#endif \ No newline at end of file +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DEVICE_MANAGER_LOG_H +#define OHOS_DEVICE_MANAGER_LOG_H + +#include + +#include "dm_log.h" + +namespace OHOS { +namespace DistributedHardware { +#define DMLOG(level, fmt, ...) DMLog(level,\ + (std::string("[") + DH_LOG_TAG + "][" + __FUNCTION__ + "]:" + fmt).c_str(), ##__VA_ARGS__) +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_LOG_H diff --git a/common/utils/include/single_instance.h b/common/include/single_instance.h similarity index 100% rename from common/utils/include/single_instance.h rename to common/include/single_instance.h diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn deleted file mode 100644 index dde1bdd95..000000000 --- a/interfaces/inner_kits/native_cpp/BUILD.gn +++ /dev/null @@ -1,80 +0,0 @@ -# Copyright (C) 2021 Huawei Device Co., Ltd. -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import("//build/ohos.gni") -import("//foundation/distributedhardware/devicemanager/devicemanager.gni") - -config("dmnativeinnerkit_config") { - visibility = [ ":*" ] - include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", - "include", - "${common_path}/log/include", - "${common_path}/utils/include", - ] - - cflags = [ - "-Wall", - "-Werror", - "-Wdate-time", - "-Wfloat-equal", - "-Wshadow", - "-Wformat=2", - "-fdata-sections", - "-ffunction-sections", - "-Os", - ] - - cflags_cc = [ - "-Os", - ] -} - -config("dmnativeinnerkit_public_config") { - include_dirs = [ "include" ] -} - -ohos_shared_library("devicemanagersdk") { - sources = [ - "src/device_manager_proxy.cpp", - "src/device_manager_listener_stub.cpp", - "src/device_manager.cpp", - "src/dm_device_info.cpp", - "src/dm_subscribe_info.cpp", - ] - - configs = [ ":dmnativeinnerkit_config" ] - - public_configs = [ ":dmnativeinnerkit_public_config" ] - - deps = [ "//utils/native/base:utils" ] - - defines = [ - "DH_LOG_TAG=\"devicemanagerkit\"", - "LOG_DOMAIN=0xD004100", - ] - - external_deps = [ - "appexecfwk_standard:appexecfwk_base", - "appexecfwk_standard:appexecfwk_core", - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", - ] - - subsystem_name = "distributedhardware" - - part_name = "device_manager_base" -} diff --git a/interfaces/inner_kits/native_cpp/include/device_manager.h b/interfaces/inner_kits/native_cpp/include/device_manager.h deleted file mode 100644 index a21f8a14c..000000000 --- a/interfaces/inner_kits/native_cpp/include/device_manager.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_H -#define OHOS_DEVICE_MANAGER_H -#include "iremote_object.h" - -#include - -#include "device_manager_callback.h" -#include "device_manager_listener_stub.h" -#include "idevice_manager.h" -#include "single_instance.h" -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -class DmDeathRecipient : public IRemoteObject::DeathRecipient { -public: - void OnRemoteDied(const wptr& remote) override; - DmDeathRecipient() = default; - ~DmDeathRecipient() = default; -}; - -class DeviceManager { -friend class DmDeathRecipient; -DECLARE_SINGLE_INSTANCE(DeviceManager); -public: - int32_t InitDeviceManager(std::string &packageName, std::shared_ptr dmInitCallback); - int32_t UnInitDeviceManager(std::string &packageName); - int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList); - int32_t RegisterDevStateCallback(std::string &packageName, std::string &extra, - std::shared_ptr callback); - int32_t UnRegisterDevStateCallback(std::string &packageName); - int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback); - int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId); - int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra, - std::shared_ptr callback); - -private: - int32_t InitDeviceManagerService(); - bool IsInit(std::string &packageName); - -private: - std::mutex lock_; - sptr dmInterface_; - sptr dmRecipient_; - std::map> dmListener_; - std::map> dmInitCallback_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h b/interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h deleted file mode 100644 index 600b96457..000000000 --- a/interfaces/inner_kits/native_cpp/include/device_manager_listener_stub.h +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_LISTENER_STUB_H -#define OHOS_DEVICE_MANAGER_LISTENER_STUB_H - -#include -#include "iremote_stub.h" -#include "idevice_manager_listener.h" - -#include "device_manager_callback.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerListenerStub : public IRemoteStub { -public: - DeviceManagerListenerStub(); - ~DeviceManagerListenerStub(); - int32_t OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel &reply, MessageOption &option) override; - int32_t OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceFound(std::string &packageName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo) override; - int32_t OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, int32_t failedReason) override; - int32_t OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) override; - int32_t OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, int32_t reason) override; - void AddDeviceStateCallback(std::shared_ptr callback); - void RemoveDeviceStateCallback(); - void AddDiscoverCallback(uint16_t subscribeId, std::shared_ptr callback); - void RemoveDiscoverCallback(uint16_t subscribeId); - void AddAuthenticateCallback(std::string deviceId, std::shared_ptr callback); - -private: - template - int32_t GetParcelableInfo(MessageParcel &reply, T &parcelableInfo); - int32_t OnDeviceOnlineInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDeviceOfflineInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDeviceChangedInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDeviceFoundInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDiscoverFailedInner(MessageParcel &data, MessageParcel &reply); - int32_t OnDiscoverySuccessInner(MessageParcel &data, MessageParcel &reply); - int32_t OnAuthResultInner(MessageParcel &data, MessageParcel &reply); - - using ListenerFunc = int32_t (DeviceManagerListenerStub::*)(MessageParcel& data, MessageParcel& reply); - std::map memberFuncMap_; - std::shared_ptr deviceStateCallback_; - std::map> deviceDiscoverCallbacks_; - std::map> authenticateCallback_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LISTENER_STUB_H diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_proxy.h b/interfaces/inner_kits/native_cpp/include/device_manager_proxy.h deleted file mode 100644 index 8d8a9755f..000000000 --- a/interfaces/inner_kits/native_cpp/include/device_manager_proxy.h +++ /dev/null @@ -1,49 +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_PROXY_H -#define OHOS_DEVICE_MANAGER_PROXY_H - -#include "idevice_manager.h" -#include "iremote_proxy.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerProxy : public IRemoteProxy { -public: - explicit DeviceManagerProxy(const sptr& impl) : IRemoteProxy(impl) {}; - ~DeviceManagerProxy() {}; - - int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) override; - int32_t RegisterDeviceManagerListener(std::string &packageName, sptr listener) override; - int32_t UnRegisterDeviceManagerListener(std::string &packageName) override; - int32_t RegisterDeviceStateCallback(std::string &packageName, std::string &extra) override; - int32_t UnRegisterDeviceStateCallback(std::string &packageName) override; - int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) override; - int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) override; - int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra) override; - -private: - template - int32_t GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos); - bool WriteInterfaceToken(MessageParcel &data); - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_PROXY_H diff --git a/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h b/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h deleted file mode 100644 index 2a6f982ee..000000000 --- a/interfaces/inner_kits/native_cpp/include/dm_subscribe_info.h +++ /dev/null @@ -1,82 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H -#define OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H - -#include "parcel.h" - -namespace OHOS { -namespace DistributedHardware { -enum DmDiscoverMode : int32_t { - /* Passive */ - DISCOVER_MODE_PASSIVE = 0x55, - /* Proactive */ - DISCOVER_MODE_ACTIVE = 0xAA -}; - -enum DmExchangeMedium : int32_t { - /** Automatic medium selection */ - AUTO = 0, - /** Bluetooth */ - BLE = 1, - /** Wi-Fi */ - COAP = 2, - /** USB */ - USB = 3, - MEDIUM_BUTT -}; - -/** - * @brief Enumerates frequencies for publishing services. - * - * This enumeration applies only to Bluetooth and is not supported currently. - */ -enum DmExchangeFreq : int32_t { - /** Low */ - LOW = 0, - /** Medium */ - MID = 1, - /** High */ - HIGH = 2, - /** Super-high */ - SUPER_HIGH = 3, - FREQ_BUTT -}; - -const std::string DM_CAPABILITY_DDMP = "ddmpCapability"; - -struct DmSubscribeInfo : public Parcelable { - /** Service ID */ - uint16_t subscribeId; - /** Discovery mode for service subscription. For details, see {@link DmDiscoverMode}. */ - DmDiscoverMode mode; - /** Service subscription medium. For details, see {@link DmExchangeMedium}. */ - DmExchangeMedium medium; - /** Service subscription frequency. For details, see {@link DmExchangeFreq}. */ - DmExchangeFreq freq; - /** only find the device with the same account */ - bool isSameAccount; - /** find the sleeping devices */ - bool isWakeRemote; - /** Service subscription capability. */ - std::string capability; - bool ReadFromParcel(Parcel &parcel); - virtual bool Marshalling(Parcel &parcel) const override; - static DmSubscribeInfo *Unmarshalling(Parcel &parcel); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SUBSCRIBE_INFO_H diff --git a/interfaces/inner_kits/native_cpp/include/idevice_manager.h b/interfaces/inner_kits/native_cpp/include/idevice_manager.h deleted file mode 100644 index b71235000..000000000 --- a/interfaces/inner_kits/native_cpp/include/idevice_manager.h +++ /dev/null @@ -1,55 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_INTERFACE_H -#define OHOS_DEVICE_MANAGER_INTERFACE_H - -#include "iremote_broker.h" -#include "dm_device_info.h" -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - REGISTER_DEVICE_MANAGER_LISTENER = 0, - UNREGISTER_DEVICE_MANAGER_LISTENER = 1, - REGISTER_DEVICE_STATE_CALLBACK = 2, - UNREGISTER_DEVICE_STATE_CALLBACK = 3, - GET_TRUST_DEVICE_LIST = 4, - START_DEVICE_DISCOVER = 5, - STOP_DEVICE_DISCOVER = 6, - AUTHENTICATE_DEVICE = 7, -}; - -class IDeviceManager : public OHOS::IRemoteBroker { -public: - virtual ~IDeviceManager() {} - virtual int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) = 0; - virtual int32_t RegisterDeviceManagerListener(std::string &packageName, sptr listener) = 0; - virtual int32_t UnRegisterDeviceManagerListener(std::string &packageName) = 0; - virtual int32_t RegisterDeviceStateCallback(std::string &packageName, std::string &extra) = 0; - virtual int32_t UnRegisterDeviceStateCallback(std::string &packageName) = 0; - virtual int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) = 0; - virtual int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) = 0; - virtual int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, - std::string &extra) = 0; - -public: - DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.devicemanager"); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_INTERFACE_H diff --git a/interfaces/inner_kits/native_cpp/src/device_manager.cpp b/interfaces/inner_kits/native_cpp/src/device_manager.cpp deleted file mode 100644 index 65da53e98..000000000 --- a/interfaces/inner_kits/native_cpp/src/device_manager.cpp +++ /dev/null @@ -1,314 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_manager.h" - -#include "iservice_registry.h" -#include "system_ability_definition.h" - -#include "device_manager_errno.h" -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -IMPLEMENT_SINGLE_INSTANCE(DeviceManager); - -int32_t DeviceManager::InitDeviceManagerService() -{ - HILOGI("DeviceManager::InitDeviceManagerService start"); - if (dmInterface_ != nullptr) { - HILOGI("DeviceManagerService Already Init"); - return ERR_OK; - } - - auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); - if (samgr == nullptr) { - HILOGE("Get SystemAbilityManager Failed"); - return ERR_NO_INIT; - } - - auto object = samgr->CheckSystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID); - if (object == nullptr) { - HILOGE("Get DeviceManager SystemAbility Failed"); - return ERR_DEVICEMANAGER_SERVICE_NOT_READY; - } - - if (dmRecipient_ == nullptr) { - dmRecipient_ = sptr(new DmDeathRecipient()); - } - - if (!object->AddDeathRecipient(dmRecipient_)) { - HILOGE("InitDeviceManagerService: AddDeathRecipient Failed"); - } - - dmInterface_ = iface_cast(object); - HILOGI("DeviceManager::InitDeviceManagerService completed"); - return ERR_OK; -} - -bool DeviceManager::IsInit(std::string &packageName) -{ - if (dmInterface_ == nullptr) { - HILOGE("DeviceManager not Init"); - return false; - } - - if (dmListener_.find(packageName) == dmListener_.end()) { - HILOGE("dmListener_ not Init for %{public}s", packageName.c_str()); - return false; - } - return true; -} - -int32_t DeviceManager::InitDeviceManager(std::string &packageName, std::shared_ptr dmInitCallback) -{ - HILOGI("DeviceManager::InitDeviceManager start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty() || dmInitCallback == nullptr) { - HILOGE("InitDeviceManager error: Invalid parameter"); - return ERR_INVALID_VALUE; - } - - HILOGI("InitDeviceManager in, packageName %{public}s", packageName.c_str()); - std::lock_guard autoLock(lock_); - int32_t ret = InitDeviceManagerService(); - if (ret != ERR_OK) { - HILOGE("InitDeviceManager Failed with ret %{public}d", ret); - return ret; - } - - auto iter = dmListener_.find(packageName); - if (iter != dmListener_.end()) { - HILOGI("dmListener_ Already Init"); - dmInitCallback_[packageName] = dmInitCallback; - return ERR_OK; - } - - sptr listener = sptr(new DeviceManagerListenerStub()); - ret = dmInterface_->RegisterDeviceManagerListener(packageName, listener); - if (ret != ERR_OK) { - HILOGE("InitDeviceManager: RegisterDeviceManagerListener Failed with ret %{public}d", ret); - return ret; - } - - dmListener_[packageName] = listener; - dmInitCallback_[packageName] = dmInitCallback; - - HILOGI("DeviceManager::InitDeviceManager completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::UnInitDeviceManager(std::string &packageName) -{ - HILOGI("DeviceManager::UnInitDeviceManager start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("InitDeviceManager error: Invalid parameter"); - return ERR_INVALID_VALUE; - } - - HILOGI("UnInitDeviceManager in, packageName %{public}s", packageName.c_str()); - std::lock_guard autoLock(lock_); - if (dmInterface_ == nullptr) { - HILOGE("DeviceManager not Init"); - return ERR_NO_INIT; - } - - auto iter = dmListener_.find(packageName); - if (iter != dmListener_.end()) { - int32_t ret = dmInterface_->UnRegisterDeviceManagerListener(packageName); - if (ret != ERR_OK) { - HILOGE("UnInitDeviceManager: UnRegisterDeviceManagerListener Failed with ret %{public}d", ret); - return ret; - } - dmListener_.erase(packageName); - dmInitCallback_.erase(packageName); - } - - if (dmListener_.empty()) { - dmRecipient_ = nullptr; - dmInterface_ = nullptr; - } - HILOGI("DeviceManager::UnInitDeviceManager completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - HILOGI("DeviceManager::GetTrustedDeviceList start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("GetTrustedDeviceList in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->GetTrustedDeviceList(packageName, extra, deviceList); - if (ret != ERR_OK) { - HILOGE("RegisterDevStateCallback Failed with ret %{public}d", ret); - return ret; - } - HILOGI("DeviceManager::GetTrustedDeviceList completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::RegisterDevStateCallback(std::string &packageName, std::string &extra, - std::shared_ptr callback) -{ - HILOGI("DeviceManager::RegisterDevStateCallback start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty() || callback == nullptr) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("RegisterDevStateCallback in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->RegisterDeviceStateCallback(packageName, extra); - if (ret != ERR_OK) { - HILOGE("RegisterDevStateCallback Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->AddDeviceStateCallback(callback); - HILOGI("DeviceManager::RegisterDevStateCallback completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::UnRegisterDevStateCallback(std::string &packageName) -{ - HILOGI("DeviceManager::UnRegisterDevStateCallback start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("UnRegisterDevStateCallback in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->UnRegisterDeviceStateCallback(packageName); - if (ret != ERR_OK) { - HILOGE("UnRegisterDeviceStateCallback Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->RemoveDeviceStateCallback(); - HILOGI("DeviceManager::UnRegisterDevStateCallback completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo, - std::shared_ptr callback) -{ - HILOGI("DeviceManager::StartDeviceDiscovery start, packageName: %{public}s", packageName.c_str()); - if (packageName.empty() || callback == nullptr) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("StartDeviceDiscovery in, packageName %{public}s", packageName.c_str()); - { - std::lock_guard autoLock(lock_); - dmListener_[packageName]->AddDiscoverCallback(subscribeInfo.subscribeId, callback); - } - int32_t ret = dmInterface_->StartDeviceDiscovery(packageName, subscribeInfo); - if (ret != ERR_OK) { - HILOGE("StartDeviceDiscovery Failed with ret %{public}d", ret); - return ret; - } - - HILOGI("DeviceManager::StartDeviceDiscovery completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) -{ - HILOGI("DeviceManager::StopDeviceDiscovery start , packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("StopDeviceDiscovery in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->StopDeviceDiscovery(packageName, subscribeId); - if (ret != ERR_OK) { - HILOGE("StopDeviceDiscovery Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->RemoveDiscoverCallback(subscribeId); - HILOGI("DeviceManager::StopDeviceDiscovery completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -int32_t DeviceManager::AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra, - std::shared_ptr callback) -{ - HILOGI("DeviceManager::AuthenticateDevice start , packageName: %{public}s", packageName.c_str()); - if (packageName.empty()) { - HILOGE("Invalid para"); - return ERR_INVALID_VALUE; - } - - if (!IsInit(packageName)) { - HILOGE("DeviceManager not Init for %{public}s", packageName.c_str()); - return ERR_NO_INIT; - } - - HILOGI("AuthenticateDevice in, packageName %{public}s", packageName.c_str()); - int32_t ret = dmInterface_->AuthenticateDevice(packageName, deviceInfo, extra); - if (ret != ERR_OK) { - HILOGE("AuthenticateDevice Failed with ret %{public}d", ret); - return ret; - } - - std::lock_guard autoLock(lock_); - dmListener_[packageName]->AddAuthenticateCallback(deviceInfo.deviceId, callback); - HILOGI("DeviceManager::AuthenticateDevice completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; -} - -void DmDeathRecipient::OnRemoteDied(const wptr& remote) -{ - (void)remote; - HILOGW("DmDeathRecipient : OnRemoteDied"); - for (auto iter : DeviceManager::GetInstance().dmInitCallback_) { - iter.second->OnRemoteDied(); - } -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp deleted file mode 100644 index e3fc817a7..000000000 --- a/interfaces/inner_kits/native_cpp/src/device_manager_listener_stub.cpp +++ /dev/null @@ -1,303 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_manager_listener_stub.h" - -#include "ipc_skeleton.h" -#include "ipc_types.h" - -#include "device_manager_log.h" - -using namespace std; - -namespace OHOS { -namespace DistributedHardware { -DeviceManagerListenerStub::DeviceManagerListenerStub() -{ - memberFuncMap_[ON_DEVICE_ONLINE] = &DeviceManagerListenerStub::OnDeviceOnlineInner; - memberFuncMap_[ON_DEVICE_OFFLINE] = &DeviceManagerListenerStub::OnDeviceOfflineInner; - memberFuncMap_[ON_DEVICE_CHANGE] = &DeviceManagerListenerStub::OnDeviceChangedInner; - memberFuncMap_[ON_DEVICE_FOUND] = &DeviceManagerListenerStub::OnDeviceFoundInner; - memberFuncMap_[ON_DISCOVER_SUCCESS] = &DeviceManagerListenerStub::OnDiscoverySuccessInner; - memberFuncMap_[ON_DISCOVER_FAILED] = &DeviceManagerListenerStub::OnDiscoverFailedInner; - memberFuncMap_[ON_AUTH_RESULT] = &DeviceManagerListenerStub::OnAuthResultInner; -} - -DeviceManagerListenerStub::~DeviceManagerListenerStub() -{ - memberFuncMap_.clear(); -} - -int32_t DeviceManagerListenerStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, - MessageOption &option) -{ - HILOGI("code = %{public}d, flags= %{public}d.", code, option.GetFlags()); - auto itFunc = memberFuncMap_.find(code); - if (itFunc != memberFuncMap_.end()) { - auto memberFunc = itFunc->second; - if (data.ReadInterfaceToken() != DeviceManagerListenerStub::GetDescriptor()) { - HILOGE("interface token check failed!"); - return ERR_INVALID_STATE; - } - return (this->*memberFunc)(data, reply); - } - HILOGW("unsupport code: %{public}d", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); -} - -template -int32_t DeviceManagerListenerStub::GetParcelableInfo(MessageParcel &reply, T &parcelableInfo) -{ - std::unique_ptr info(reply.ReadParcelable()); - if (!info) { - HILOGE("readParcelableInfo failed"); - return ERR_INVALID_VALUE; - } - parcelableInfo = *info; - return ERR_NONE; -} - -int32_t DeviceManagerListenerStub::OnDeviceOnlineInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceOnline(packageName, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceOfflineInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceOffline(packageName, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceChangedInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo deviceInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceChanged(packageName, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceFoundInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt16(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - int32_t ret = OnDeviceFound(packageName, subscribeId, deviceInfo); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDiscoverFailedInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt16(); - int32_t failedReason = data.ReadInt32(); - - int32_t ret = OnDiscoverFailed(packageName, subscribeId, failedReason); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDiscoverySuccessInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt16(); - - int32_t ret = OnDiscoverySuccess(packageName, subscribeId); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnAuthResultInner(MessageParcel &data, MessageParcel &reply) -{ - string packageName = data.ReadString(); - string deviceId = data.ReadString(); - int32_t status = data.ReadInt32(); - int32_t reason = data.ReadInt32(); - - int32_t ret = OnAuthResult(packageName, deviceId, status, reason); - reply.WriteInt32(ret); - return ret; -} - -int32_t DeviceManagerListenerStub::OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceOnline packageName:%{public}s", packageName.c_str()); - if (deviceStateCallback_ == nullptr) { - HILOGE("OnDeviceOnlinecallback not register"); - return ERR_NULL_OBJECT; - } - deviceStateCallback_->OnDeviceOnline(deviceInfo); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceOffline packageName:%{public}s", packageName.c_str()); - if (deviceStateCallback_ == nullptr) { - HILOGE("OnDeviceOnlinecallback not register"); - return ERR_NULL_OBJECT; - } - deviceStateCallback_->OnDeviceOffline(deviceInfo); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceChanged packageName:%{public}s", packageName.c_str()); - if (deviceStateCallback_ == nullptr) { - HILOGE("OnDeviceOnlinecallback not register"); - return ERR_NULL_OBJECT; - } - deviceStateCallback_->OnDeviceChanged(deviceInfo); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDeviceFound(std::string &packageName, uint16_t subscribeId, - const DmDeviceInfo &deviceInfo) -{ - HILOGI("OnDeviceFound packageName:%{public}s, subscribeId:%{public}d.", packageName.c_str(), (int32_t)subscribeId); - auto iter = deviceDiscoverCallbacks_.find(subscribeId); - if (iter == deviceDiscoverCallbacks_.end()) { - HILOGE("OnDeviceFound: no register discoverCallback for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnDeviceFound: discoverCallback is nullptr for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - callback->OnDeviceFound(subscribeId, const_cast(deviceInfo)); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, - int32_t failedReason) -{ - HILOGI("OnDiscoverFailed packageName:%{public}s, subscribeId %{public}d, reason %{public}d", - packageName.c_str(), subscribeId, failedReason); - auto iter = deviceDiscoverCallbacks_.find(subscribeId); - if (iter == deviceDiscoverCallbacks_.end()) { - HILOGE("OnDiscoverFailed: no register discoverCallback for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnDiscoverFailed: discoverCallback is nullptr for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - callback->OnDiscoverFailed(subscribeId, failedReason); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) -{ - HILOGI("OnDiscoverySuccess packageName:%{public}s, subscribeId %{public}d", packageName.c_str(), subscribeId); - auto iter = deviceDiscoverCallbacks_.find(subscribeId); - if (iter == deviceDiscoverCallbacks_.end()) { - HILOGE("OnDiscoverySuccess: no register discoverCallback for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnDiscoverySuccess: discoverCallback is nullptr for subscribeId %{public}d", subscribeId); - return ERR_NULL_OBJECT; - } - callback->OnDiscoverySuccess(subscribeId); - return ERR_OK; -} - -int32_t DeviceManagerListenerStub::OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, - int32_t reason) -{ - HILOGI("OnAuthResult packageName:%{public}s, status %{public}d, reason %{public}d", - packageName.c_str(), status, reason); - auto iter = authenticateCallback_.find(deviceId); - if (iter == authenticateCallback_.end()) { - HILOGE("OnAuthResult: cannot find Auth callback"); - return ERR_NULL_OBJECT; - } - auto callback = iter->second; - if (callback == nullptr) { - HILOGE("OnAuthResult: Auth callback is nullptr"); - return ERR_NULL_OBJECT; - } - callback->OnAuthResult(deviceId, status, reason); - authenticateCallback_.erase(deviceId); - return ERR_OK; -} - -void DeviceManagerListenerStub::AddDeviceStateCallback(std::shared_ptr callback) -{ - deviceStateCallback_ = callback; -} - -void DeviceManagerListenerStub::RemoveDeviceStateCallback() -{ - deviceStateCallback_ = nullptr; -} - -void DeviceManagerListenerStub::AddDiscoverCallback(uint16_t subscribeId, std::shared_ptr callback) -{ - deviceDiscoverCallbacks_[subscribeId] = callback; -} - -void DeviceManagerListenerStub::RemoveDiscoverCallback(uint16_t subscribeId) -{ - deviceDiscoverCallbacks_.erase(subscribeId); -} - -void DeviceManagerListenerStub::AddAuthenticateCallback(std::string deviceId, - std::shared_ptr callback) -{ - authenticateCallback_[deviceId] = callback; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp deleted file mode 100644 index d5045590c..000000000 --- a/interfaces/inner_kits/native_cpp/src/device_manager_proxy.cpp +++ /dev/null @@ -1,316 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_manager_proxy.h" - -#include "ipc_types.h" - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -bool DeviceManagerProxy::WriteInterfaceToken(MessageParcel &data) -{ - if (!data.WriteInterfaceToken(DeviceManagerProxy::GetDescriptor())) { - HILOGE("write interface token failed"); - return false; - } - return true; -} - -int32_t DeviceManagerProxy::RegisterDeviceManagerListener(std::string &packageName, sptr listener) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteRemoteObject(listener)) { - HILOGE("write callback failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(REGISTER_DEVICE_MANAGER_LISTENER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("RegisterDeviceManagerListener SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::UnRegisterDeviceManagerListener(std::string &packageName) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(UNREGISTER_DEVICE_MANAGER_LISTENER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("UnRegisterDeviceManagerListener SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::RegisterDeviceStateCallback(std::string &packageName, std::string &extra) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(extra)) { - HILOGE("write extra failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(REGISTER_DEVICE_STATE_CALLBACK, data, reply, option); - if (error != ERR_NONE) { - HILOGE("RegisterDeviceStateCallback SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::UnRegisterDeviceStateCallback(std::string &packageName) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(UNREGISTER_DEVICE_STATE_CALLBACK, data, reply, option); - if (error != ERR_NONE) { - HILOGE("UnRegisterDeviceStateCallback SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -template -int32_t DeviceManagerProxy::GetParcelableInfos(MessageParcel &reply, std::vector &parcelableInfos) -{ - int32_t infoSize = reply.ReadInt32(); - for (int32_t i = 0; i < infoSize; i++) { - std::unique_ptr info(reply.ReadParcelable()); - if (!info) { - HILOGE("Read Parcelable infos failed"); - return ERR_INVALID_VALUE; - } - parcelableInfos.emplace_back(*info); - } - HILOGI("get parcelable infos success"); - return ERR_NONE; -} - -int32_t DeviceManagerProxy::GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(extra)) { - HILOGE("write extra failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(GET_TRUST_DEVICE_LIST, data, reply, option); - if (error != ERR_NONE) { - HILOGE("GetTrustedDeviceList SendRequest fail, error: %{public}d", error); - return error; - } - - error = GetParcelableInfos(reply, deviceList); - if (error != ERR_NONE) { - HILOGE("GetTrustedDeviceList GetParcelableInfos fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&subscribeInfo)) { - HILOGE("write subscribeInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(START_DEVICE_DISCOVER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("StartDeviceDiscovery SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(STOP_DEVICE_DISCOVER, data, reply, option); - if (error != ERR_NONE) { - HILOGE("StopDeviceDiscovery SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} - -int32_t DeviceManagerProxy::AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, - std::string &extra) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(extra)) { - HILOGE("write extra failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(AUTHENTICATE_DEVICE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("AuthenticateDevice SendRequest fail, error: %{public}d", error); - return error; - } - return ERR_NONE; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp b/interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp deleted file mode 100644 index 0bba105f1..000000000 --- a/interfaces/inner_kits/native_cpp/src/dm_subscribe_info.cpp +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "dm_subscribe_info.h" - -namespace OHOS { -namespace DistributedHardware { -bool DmSubscribeInfo::ReadFromParcel(Parcel &parcel) -{ - subscribeId = parcel.ReadInt16(); - mode = (DmDiscoverMode)parcel.ReadInt32(); - medium = (DmExchangeMedium)parcel.ReadInt32(); - freq = (DmExchangeFreq)parcel.ReadInt32(); - isSameAccount = parcel.ReadBool(); - isWakeRemote = parcel.ReadBool(); - capability = parcel.ReadString(); - return true; -} - -DmSubscribeInfo *DmSubscribeInfo::Unmarshalling(Parcel &parcel) -{ - DmSubscribeInfo *info = new (std::nothrow) DmSubscribeInfo(); - if (info == nullptr) { - return nullptr; - } - - if (!info->ReadFromParcel(parcel)) { - delete info; - info = nullptr; - } - return info; -} - -bool DmSubscribeInfo::Marshalling(Parcel &parcel) const -{ - parcel.WriteInt16(subscribeId); - parcel.WriteInt32((int32_t)mode); - parcel.WriteInt32((int32_t)medium); - parcel.WriteInt32((uint8_t)freq); - parcel.WriteBool(isSameAccount); - parcel.WriteBool(isWakeRemote); - parcel.WriteString(capability); - return true; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/interfaces/kits/js/@ohos.distributedHardware.deviceManager.d.ts b/interfaces/kits/js/@ohos.distributedHardware.deviceManager.d.ts new file mode 100644 index 000000000..3826528f6 --- /dev/null +++ b/interfaces/kits/js/@ohos.distributedHardware.deviceManager.d.ts @@ -0,0 +1,311 @@ +/* + * Copyright (c) 2020 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + import { AsyncCallback, Callback } from './basic'; + + declare namespace deviceManager { + /** + * DeviceInfo + */ + interface DeviceInfo { + /** + * Device ID. + */ + deviceId: string; + + /** + * Device name of the device. + */ + deviceName: string; + + /** + * Device type of the device. + */ + deviceType: DeviceType; + } + + /** + * Device Type definitions + */ + enum DeviceType { + /** + * Indicates an unknown device type. + */ + UNKNOWN_TYPE = 0, + + /** + * Indicates a speak. + */ + SPEAKER = 0x0A, + + /** + * Indicates a smartphone. + */ + PHONE = 0x0E, + + /** + * Indicates a tablet. + */ + TABLET = 0x11, + + /** + * Indicates a smart watch. + */ + WEARABLE = 0x6D, + + /** + * Indicates a car. + */ + CAR = 0x83, + + /** + * Indicates a smart TV. + */ + TV = 0x9C, + } + + /** + * Device state change event definition + */ + enum DeviceStateChangeAction { + /** + * device online action + */ + ONLINE = 0, + + /** + * device ready action, the device information synchronization was completed + */ + READY = 1, + + /** + * device offline action + */ + OFFLINE = 2, + + /** + * device change action + */ + CHANGE = 3, + } + + /** + * Service subscribe info for device discover + * + * @systemapi this method can be used only by system applications + */ + interface SubscribeInfo { + /** + * Service subscribe ID, the value is in scope [0, 65535], should be unique for each discover process + */ + subscribeId: number; + + /** + * Discovery mode for service subscription. + */ + mode: DiscoverMode; + + /** + * Service subscription medium. + */ + medium: ExchangeMedium; + + /** + * Service subscription frequency. + */ + freq: ExchangeFreq; + + /** + * only find the device with the same account. + */ + isSameAccount: boolean; + + /** + * find the sleeping devices. + */ + isWakeRemote: boolean; + + /** + * Subscribe capability. + */ + capability: SubscribeCap; + } + + /** + * device discover mode + * + * @systemapi this method can be used only by system applications + */ + enum DiscoverMode { + /** + * Passive. + */ + DISCOVER_MODE_PASSIVE = 0x55, + + /** + * Proactive. + */ + DISCOVER_MODE_ACTIVE = 0xAA + } + + /** + * device discover medium + * + * @systemapi this method can be used only by system applications + */ + enum ExchangeMedium { + /** + * Automatic medium selection. + */ + AUTO = 0, + + /** + * Bluetooth + */ + BLE = 1, + + /** + * Wi-Fi + */ + COAP = 2, + + /** + * USB + */ + USB = 3 + } + + /** + * device discover freq + * + * @systemapi this method can be used only by system applications + */ + enum ExchangeFreq { + /** + * Low + */ + Low = 0, + + /** + * Medium + */ + MID = 1, + + /** + * High + */ + HIGH = 2, + + /** + * Super-high + */ + SUPER_HIGH = 3 + } + + /** + * device discover capability + * + * @systemapi this method can be used only by system applications + */ + enum SubscribeCap { + /** + * ddmpCapability + */ + SUBSCRIBE_CAPABILITY_DDMP = 0 + } + + /** + * Creates a {@code DeviceManager} instance + * + *

To manage devices, you must first call this method to obtain a {@code DeviceManager} instance and then + * use this instance to call other device management methods. + * + * @param bundleName Indicates the bundle name of the application. + * @param callback Indicates the callback to the invoked upon {@code DeviceManager} instance creation. + */ + function createDeviceManager(bundleName: string, callback: AsyncCallback): void; + + /** + * Provides methods for managing devices. + */ + interface DeviceManager { + /** + * Releases the {@code DeviceManager} instance after the methods for device management are no longer used + */ + Release(): void; + + /** + * obtain a list of trusted devices. + * + * @param options Indicates the extra parameters to be passed to this method for device filtering or sorting. + * This parameter can be null. For details about available values, see {@link #TARGET_PACKAGE_NAME} and + * {@link #SORT_TYPE}. + * @return Returns a list of trusted devices. + */ + getTrustedDeviceListSync(): Array; + + /** + * Start to discover device. + * + * @param bundleName Indicates the bundle name of the application. + * @param subscribeInfo subscribe info to discover device + * @systemapi this method can be used only by system applications. + */ + startDeviceDiscovery(subscribeInfo: SubscribeInfo): void; + + /** + * Stop to discover device. + * + * @param bundleName Indicates the bundle name of the application. + * @param subscribeId Service subscribe ID + * @systemapi this method can be used only by system applications. + */ + stopDeviceDiscovery(subscribeId: number): void; + + /** + * authenticate the specified device. + * + * @param bundleName Indicates the bundle name of the application. + * @param deviceInfo deviceInfo of device to authenticate + * @systemapi this method can be used only by system applications. + */ + authenticateDevice(deviceInfo: DeviceInfo): void; + + /** + * Register a device state callback so that the application can be notified upon device state changes based on + * the application bundle name. + * + * @param bundleName Indicates the bundle name of the application. + * @param callback Indicates the device state callback to register. + */ + on(type: 'deviceStateChange', callback: Callback<{ action: DeviceStateChangeAction, device: DeviceInfo }>): void; + + /** + * UnRegister device state callback based on the application bundle name + * + * @param bundleName Indicates the bundle name of the application. + * @param callback Indicates the device state callback to register. + */ + off(type: 'deviceStateChange', callback: Callback<{ action: DeviceStateChangeAction, device: DeviceInfo }>): void; + + + + } + + + + + +} \ No newline at end of file diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index f2ea6932d..efec0aaa3 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -14,51 +14,37 @@ import("//build/ohos.gni") import("//foundation/distributedhardware/devicemanager/devicemanager.gni") -config("dmnativejs_config") { - visibility = [ ":*" ] +ohos_shared_library("devicemanager") { include_dirs = [ "//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", - "${common_path}/log/include", - "${common_path}/utils/include", + "${utils_path}/include/log", + "${common_path}/include/ipc", "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/standard", ] - cflags = [ - "-Wall", - "-Werror", - "-Wdate-time", - "-Wfloat-equal", - "-Wshadow", - "-Wformat=2", - "-fdata-sections", - "-ffunction-sections", - "-Os", - ] - - cflags_cc = [ - "-Os", - ] -} - -ohos_shared_library("devicemanager") { sources = [ "src/native_devicemanager_js.cpp", "src/dm_native_event.cpp", ] - configs = [ ":dmnativejs_config" ] - deps = [ + "${utils_path}:devicemanagerutils", "//utils/native/base:utils", "//foundation/ace/napi:ace_napi", "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", ] + cflags_cc = build_flags + defines = [ + "HI_LOG_ENABLE", "DH_LOG_TAG=\"devicemanagerkit_js\"", "LOG_DOMAIN=0xD004100", ] diff --git a/interfaces/kits/js/include/dm_native_event.h b/interfaces/kits/js/include/dm_native_event.h index dcffbd1d3..6a3858bdd 100644 --- a/interfaces/kits/js/include/dm_native_event.h +++ b/interfaces/kits/js/include/dm_native_event.h @@ -33,7 +33,7 @@ public: virtual void On(std::string &eventType, napi_value handler); virtual void Off(std::string &eventType); - virtual void OnEvent(const std::string &eventType, size_t argc, const napi_value* argv); + virtual void OnEvent(const std::string &eventType, size_t argc, const napi_value *argv); protected: napi_env env_; diff --git a/interfaces/kits/js/include/native_devicemanager_js.h b/interfaces/kits/js/include/native_devicemanager_js.h index 872d7b457..14ece32fa 100644 --- a/interfaces/kits/js/include/native_devicemanager_js.h +++ b/interfaces/kits/js/include/native_devicemanager_js.h @@ -24,6 +24,8 @@ #include "dm_native_event.h" #include "dm_device_info.h" #include "dm_subscribe_info.h" +#include "nlohmann/json.hpp" +#include "dm_device_info.h" const int DM_NAPI_BUF_LENGTH = 256; @@ -38,6 +40,16 @@ struct AsyncCallbackInfo { int32_t status = -1; }; +struct AuthAsyncCallbackInfo { + napi_env env = nullptr; + + char bundleName[DM_NAPI_BUF_LENGTH] = {0}; + size_t bundleNameLen = 0; + + napi_ref callback = nullptr; + int32_t authType = -1; +}; + enum DmNapiDevStateChangeAction { ONLINE = 0, READY = 1, @@ -72,7 +84,7 @@ class DmNapiDiscoverCallback : public OHOS::DistributedHardware::DiscoverCallbac public: explicit DmNapiDiscoverCallback(std::string &bundleName) : refCount_(0), bundleName_(bundleName) {} virtual ~DmNapiDiscoverCallback() {}; - void OnDeviceFound(uint16_t subscribeId, OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; + void OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) override; void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) override; void OnDiscoverySuccess(uint16_t subscribeId) override; void IncreaseRefCount(); @@ -88,12 +100,32 @@ class DmNapiAuthenticateCallback : public OHOS::DistributedHardware::Authenticat public: explicit DmNapiAuthenticateCallback(std::string &bundleName) : bundleName_(bundleName) {} virtual ~DmNapiAuthenticateCallback() {}; - void OnAuthResult(std::string &deviceId, int32_t status, int32_t reason) override; + void OnAuthResult(std::string &deviceId, int32_t pinToken, int32_t status, int32_t reason) override; private: std::string bundleName_; }; +class DmNapiCheckAuthCallback : public OHOS::DistributedHardware::CheckAuthCallback{ +public: + explicit DmNapiCheckAuthCallback(std::string &bundleName) : bundleName_(bundleName) {} + virtual ~DmNapiCheckAuthCallback() {}; + void OnCheckAuthResult(std::string &deviceId, int32_t resultCode, int32_t flag) override; + +private: + std::string bundleName_; +}; + +class DmNapiDeviceManagerFaCallback : public OHOS::DistributedHardware::DeviceManagerFaCallback{ +public: + explicit DmNapiDeviceManagerFaCallback(std::string &bundleName) : bundleName_(bundleName) {} + virtual ~DmNapiDeviceManagerFaCallback() {}; + void OnCall(std::string ¶mJson) override; + +private: + std::string bundleName_; +}; + class DeviceManagerNapi : public DmNativeEvent { public: explicit DeviceManagerNapi(napi_env env, napi_value thisVar); @@ -105,9 +137,12 @@ public: static napi_value GetTrustedDeviceListSync(napi_env env, napi_callback_info info); static napi_value StartDeviceDiscoverSync(napi_env env, napi_callback_info info); static napi_value StopDeviceDiscoverSync(napi_env env, napi_callback_info info); - static napi_value AuthenticateDeviceSync(napi_env env, napi_callback_info info); + static napi_value 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); @@ -115,31 +150,50 @@ public: static void DeviceInfoToJsArray(const napi_env& env, const std::vector& vecDevInfo, const int idx, napi_value& arrayResult); + static void DmAuthParamToJsAuthParam(const napi_env& env, + const OHOS::DistributedHardware::DmAuthParam& authParam ,napi_value& paramResult); static void SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, napi_value& result); static void SetValueUtf8String(const napi_env& env, const std::string& fieldStr, const std::string& str, napi_value& result); static void JsObjectToString(const napi_env& env, const napi_value& object, - const std::string& fieldStr, const int bufLen, std::string& fieldRef); + const std::string& fieldStr, char *dest, const int 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); + 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); 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); + 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); + 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); + static void JsToDmAuthExtra(const napi_env& env, const napi_value& param, nlohmann::json &jsonObj); void OnDeviceStateChange(DmNapiDevStateChangeAction action, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo); void OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo); void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason); - void OnAuthResult(const std::string& deviceId, int32_t status, int32_t reason); + void OnAuthResult(const std::string& deviceId, int32_t pinToken, 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& paramResult); private: napi_env env_; napi_ref wrapper_; static napi_ref sConstructor_; std::string bundleName_; + static AuthAsyncCallbackInfo authAsyncCallbackInfo_; + static AuthAsyncCallbackInfo verifyAsyncCallbackInfo_; }; #endif // OHOS_DEVICE_MANAGER_NATIVE_DEVICEMANAGER_JS_H diff --git a/interfaces/kits/js/src/dm_native_event.cpp b/interfaces/kits/js/src/dm_native_event.cpp index d3aca3d17..70084134b 100644 --- a/interfaces/kits/js/src/dm_native_event.cpp +++ b/interfaces/kits/js/src/dm_native_event.cpp @@ -38,7 +38,7 @@ DmNativeEvent::~DmNativeEvent() void DmNativeEvent::On(std::string &eventType, napi_value handler) { - HILOGI("DmNativeEvent On in for event: %{public}s", eventType.c_str()); + DMLOG(DM_LOG_INFO, "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) { - HILOGI("DmNativeEvent Off in for event: %{public}s", eventType.c_str()); + DMLOG(DM_LOG_INFO, "DmNativeEvent Off in for event: %s", eventType.c_str()); napi_handle_scope scope = nullptr; napi_open_handle_scope(env_, &scope); if (scope == nullptr) { - HILOGE("scope is nullptr"); + DMLOG(DM_LOG_ERROR, "scope is nullptr"); return; } auto iter = eventMap_.find(eventType); if (iter == eventMap_.end()) { - HILOGE("eventType %{public}s not find", eventType.c_str()); + DMLOG(DM_LOG_ERROR, "eventType %s not find", eventType.c_str()); return; } auto listener = iter->second; @@ -66,40 +66,40 @@ void DmNativeEvent::Off(std::string &eventType) napi_close_handle_scope(env_, scope); } -void DmNativeEvent::OnEvent(const std::string &eventType, size_t argc, const napi_value* argv) +void DmNativeEvent::OnEvent(const std::string &eventType, size_t argc, const napi_value *argv) { - HILOGI("OnEvent for %{public}s", eventType.c_str()); + DMLOG(DM_LOG_INFO, "OnEvent for %s", eventType.c_str()); napi_handle_scope scope = nullptr; napi_open_handle_scope(env_, &scope); if (scope == nullptr) { - HILOGE("scope is nullptr"); + DMLOG(DM_LOG_ERROR, "scope is nullptr"); return; } auto iter = eventMap_.find(eventType); if (iter == eventMap_.end()) { - HILOGE("eventType %{public}s not find", eventType.c_str()); + DMLOG(DM_LOG_ERROR, "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) { - HILOGE("napi_get_reference_value thisVar for %{public}s failed, status=%{public}d", eventType.c_str(), status); + DMLOG(DM_LOG_ERROR, "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) { - HILOGE("napi_get_reference_value handler for %{public}s failed, status=%{public}d", eventType.c_str(), status); + DMLOG(DM_LOG_ERROR, "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) { - HILOGE("napi_call_function for %{public}s failed, status=%{public}d", eventType.c_str(), status); + DMLOG(DM_LOG_ERROR, "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 15a9df211..989298da5 100644 --- a/interfaces/kits/js/src/native_devicemanager_js.cpp +++ b/interfaces/kits/js/src/native_devicemanager_js.cpp @@ -16,9 +16,11 @@ #include "native_devicemanager_js.h" #include +#include "nlohmann/json.hpp" #include "device_manager.h" #include "device_manager_log.h" +#include "constants.h" using namespace OHOS::DistributedHardware; @@ -33,20 +35,26 @@ namespace { const std::string DM_NAPI_EVENT_DEVICE_STATE_CHANGE = "deviceStateChange"; const std::string DM_NAPI_EVENT_DEVICE_FOUND = "deviceFound"; const std::string DM_NAPI_EVENT_DEVICE_DISCOVER_FAIL = "discoverFail"; -const std::string DM_NAPI_EVENT_DEVICE_AUTH_RESULT = "authResult"; +const std::string DM_NAPI_EVENT_DMFA_CALLBACK = "dmFaCallback"; const std::string DM_NAPI_EVENT_DEVICE_SERVICE_DIE = "serviceDie"; const std::string DEVICE_MANAGER_NAPI_CLASS_NAME = "DeviceManager"; const int DM_NAPI_ARGS_ONE = 1; const int DM_NAPI_ARGS_TWO = 2; +const int DM_NAPI_ARGS_THREE = 3; const int DM_NAPI_SUB_ID_MAX = 65535; +const int DM_AUTH_TYPE_PINCODE = 1; +const int DM_AUTH_DIRECTION_CLIENT = 1; + std::map g_deviceManagerMap; std::map> g_initCallbackMap; std::map> g_deviceStateCallbackMap; std::map> g_discoverCallbackMap; std::map> g_authCallbackMap; +std::map> g_checkAuthCallbackMap; +std::map> g_dmfaCallbackMap; } enum DmNapiSubscribeCap { @@ -54,67 +62,68 @@ enum DmNapiSubscribeCap { }; napi_ref DeviceManagerNapi::sConstructor_ = nullptr; +AuthAsyncCallbackInfo DeviceManagerNapi::authAsyncCallbackInfo_ = {0}; +AuthAsyncCallbackInfo DeviceManagerNapi::verifyAsyncCallbackInfo_ = {0}; void DmNapiInitCallback::OnRemoteDied() { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnRemoteDied, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnRemoteDied, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnEvent("serviceDie", 0, nullptr); } -void DmNapiDeviceStateCallback::OnDeviceOnline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DmNapiDeviceStateCallback::OnDeviceOnline(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceOnline, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDeviceOnline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::ONLINE, deviceInfo); } -void DmNapiDeviceStateCallback::OnDeviceReady(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DmNapiDeviceStateCallback::OnDeviceReady(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceOnline, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDeviceOnline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::READY, deviceInfo); } -void DmNapiDeviceStateCallback::OnDeviceOffline(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DmNapiDeviceStateCallback::OnDeviceOffline(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceOffline, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDeviceOffline, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::OFFLINE, deviceInfo); } -void DmNapiDeviceStateCallback::OnDeviceChanged(const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DmNapiDeviceStateCallback::OnDeviceChanged(const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceChanged, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDeviceChanged, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } deviceManagerNapi->OnDeviceStateChange(DmNapiDevStateChangeAction::CHANGE, deviceInfo); } -void DmNapiDiscoverCallback::OnDeviceFound(uint16_t subscribeId, - OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DmNapiDiscoverCallback::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDeviceFound, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDeviceFound, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - HILOGI("OnDeviceFound for %{public}s, subscribeId %{public}d", bundleName_.c_str(), (int32_t)subscribeId); + DMLOG(DM_LOG_INFO, "OnDeviceFound for %s, subscribeId %d", bundleName_.c_str(), (int32_t)subscribeId); deviceManagerNapi->OnDeviceFound(subscribeId, deviceInfo); } @@ -122,7 +131,7 @@ void DmNapiDiscoverCallback::OnDiscoverFailed(uint16_t subscribeId, int32_t fail { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDiscoverFailed, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDiscoverFailed, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } @@ -133,10 +142,10 @@ void DmNapiDiscoverCallback::OnDiscoverySuccess(uint16_t subscribeId) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnDiscoverySuccess, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnDiscoverySuccess, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - HILOGE("DiscoverySuccess for %{public}s, subscribeId %{public}d", bundleName_.c_str(), (int32_t)subscribeId); + DMLOG(DM_LOG_INFO, "DiscoverySuccess for %s, subscribeId %d", bundleName_.c_str(), (int32_t)subscribeId); } void DmNapiDiscoverCallback::IncreaseRefCount() @@ -154,14 +163,34 @@ int32_t DmNapiDiscoverCallback::GetRefCount() return refCount_; } -void DmNapiAuthenticateCallback::OnAuthResult(std::string &deviceId, int32_t status, int32_t reason) +void DmNapiAuthenticateCallback::OnAuthResult(std::string &deviceId, int32_t pinToken, 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()); + return; + } + deviceManagerNapi->OnAuthResult(deviceId, pinToken, status, reason); +} + +void DmNapiCheckAuthCallback::OnCheckAuthResult(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()); + return; + } + deviceManagerNapi->OnVerifyResult(deviceId, resultCode, flag); +} + +void DmNapiDeviceManagerFaCallback::OnCall(std::string ¶mJson) { DeviceManagerNapi *deviceManagerNapi = DeviceManagerNapi::GetDeviceManagerNapi(bundleName_); if (deviceManagerNapi == nullptr) { - HILOGE("OnAuthResult, deviceManagerNapi not find for bunderName %{public}s", bundleName_.c_str()); + DMLOG(DM_LOG_ERROR, "OnCall, deviceManagerNapi not find for bunderName %s", bundleName_.c_str()); return; } - deviceManagerNapi->OnAuthResult(deviceId, status, reason); + deviceManagerNapi->OnDmfaCall(paramJson); } DeviceManagerNapi::DeviceManagerNapi(napi_env env, napi_value thisVar) : DmNativeEvent(env, thisVar) @@ -186,8 +215,7 @@ DeviceManagerNapi *DeviceManagerNapi::GetDeviceManagerNapi(std::string &buldleNa return iter->second; } -void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, - const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, const DmDeviceInfo &deviceInfo) { napi_value result; napi_create_object(env_, &result); @@ -203,9 +231,9 @@ void DeviceManagerNapi::OnDeviceStateChange(DmNapiDevStateChangeAction action, OnEvent("deviceStateChange", DM_NAPI_ARGS_ONE, &result); } -void DeviceManagerNapi::OnDeviceFound(uint16_t subscribeId, const OHOS::DistributedHardware::DmDeviceInfo &deviceInfo) +void DeviceManagerNapi::OnDeviceFound(uint16_t subscribeId, const DmDeviceInfo &deviceInfo) { - HILOGI("OnDeviceFound for subscribeId %{public}d", (int32_t)subscribeId); + DMLOG(DM_LOG_INFO, "OnDeviceFound for subscribeId %d", (int32_t)subscribeId); napi_value result; napi_create_object(env_, &result); SetValueInt32(env_, "subscribeId", (int)subscribeId, result); @@ -222,7 +250,7 @@ void DeviceManagerNapi::OnDeviceFound(uint16_t subscribeId, const OHOS::Distribu void DeviceManagerNapi::OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) { - HILOGI("OnDiscoverFailed for subscribeId %{public}d", (int32_t)subscribeId); + DMLOG(DM_LOG_INFO, "OnDiscoverFailed for subscribeId %d", (int32_t)subscribeId); napi_value result; napi_create_object(env_, &result); SetValueInt32(env_, "subscribeId", (int)subscribeId, result); @@ -230,53 +258,165 @@ void DeviceManagerNapi::OnDiscoverFailed(uint16_t subscribeId, int32_t failedRea OnEvent("discoverFail", DM_NAPI_ARGS_ONE, &result); } -void DeviceManagerNapi::OnAuthResult(const std::string& deviceId, int32_t status, int32_t reason) +void DeviceManagerNapi::OnDmfaCall(const std::string ¶mJson) { - HILOGI("OnAuthResult for status: %{public}d, reason: %{public}d", status, reason); + DMLOG(DM_LOG_INFO, "OnCall for paramJson"); napi_value result; napi_create_object(env_, &result); + SetValueUtf8String(env_, "param", paramJson, result); + OnEvent("dmFaCallback", DM_NAPI_ARGS_ONE, &result); +} - SetValueUtf8String(env_, "deviceId", deviceId, result); - SetValueInt32(env_, "status", (int)status, result); - SetValueInt32(env_, "reason", (int)reason, result); - OnEvent("authResult", DM_NAPI_ARGS_ONE, &result); +void DeviceManagerNapi::OnAuthResult(const std::string& deviceId, int32_t pinToken, int32_t status, int32_t reason) +{ + DMLOG(DM_LOG_INFO, "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 }; + + if (status == 0) { + DMLOG(DM_LOG_INFO, "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"); + napi_create_object(env_, &result[0]); + SetValueInt32(env_, "code", status, result[0]); + SetValueInt32(env_, "reason", reason, result[0]); + napi_get_undefined(env_, &result[1]); + } + + napi_value callResult = nullptr; + napi_value handler = nullptr; + napi_get_reference_value(env_, authAsyncCallbackInfo_.callback, &handler); + if (handler != nullptr) { + 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"); + } + g_authCallbackMap.erase(bundleName_); } -void DeviceManagerNapi::SetValueUtf8String(const napi_env &env, const std::string& fieldStr, const std::string& str, - napi_value& result) +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); + napi_value thisVar = nullptr; + napi_get_reference_value(env_, thisVarRef_, &thisVar); + napi_value result[DM_NAPI_ARGS_TWO] = { 0 }; + if (resultCode == 0) { + napi_get_undefined(env_, &result[0]); + napi_create_object(env_, &result[1]); + SetValueUtf8String(env_, "deviceId", deviceId, result[1]); + SetValueInt32(env_, "level", flag, result[1]); + } else { + napi_create_object(env_, &result[0]); + SetValueInt32(env_, "code", resultCode, result[0]); + napi_get_undefined(env_, &result[1]); + } + + napi_value callResult = nullptr; + napi_value handler = nullptr; + napi_get_reference_value(env_, verifyAsyncCallbackInfo_.callback, &handler); + if (handler != nullptr) { + 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"); + } + g_checkAuthCallbackMap.erase(bundleName_); +} + +void DeviceManagerNapi::SetValueUtf8String(const napi_env &env, const std::string &fieldStr, const std::string &str, + napi_value &result) { napi_value value; napi_create_string_utf8(env, str.c_str(), NAPI_AUTO_LENGTH, &value); napi_set_named_property(env, result, fieldStr.c_str(), value); } -void DeviceManagerNapi::SetValueInt32(const napi_env& env, const std::string& fieldStr, const int intValue, - napi_value& result) +void DeviceManagerNapi::SetValueInt32(const napi_env &env, const std::string &fieldStr, const int intValue, + napi_value &result) { napi_value value; napi_create_int32(env, intValue, &value); napi_set_named_property(env, result, fieldStr.c_str(), value); } -void DeviceManagerNapi::DeviceInfoToJsArray(const napi_env& env, - const std::vector& vecDevInfo, - const int idx, napi_value& arrayResult) +void DeviceManagerNapi::DeviceInfoToJsArray(const napi_env &env, + const std::vector &vecDevInfo, + const int idx, napi_value &arrayResult) { napi_value result; napi_create_object(env, &result); - SetValueUtf8String(env, "deviceId", vecDevInfo[idx].deviceId.c_str(), result); - SetValueUtf8String(env, "deviceName", vecDevInfo[idx].deviceName.c_str(), result); + SetValueUtf8String(env, "deviceId", vecDevInfo[idx].deviceId, result); + SetValueUtf8String(env, "deviceName", vecDevInfo[idx].deviceName, result); SetValueInt32(env, "deviceType", (int)vecDevInfo[idx].deviceTypeId, result); napi_status status = napi_set_element(env, arrayResult, idx, result); if (status != napi_ok) { - HILOGE("DmDeviceInfo To JsArray set element error: %{public}d", status); + DMLOG(DM_LOG_ERROR, "DmDeviceInfo To JsArray set element error: %d", status); } } -void DeviceManagerNapi::JsObjectToString(const napi_env& env, const napi_value& object, - const std::string& fieldStr, const int bufLen, std::string& fieldRef) +void DeviceManagerNapi::DmAuthParamToJsAuthParamy(const napi_env& env, + const DmAuthParam& authParam, napi_value& paramResult) +{ + DMLOG(DM_LOG_INFO, "DmAuthParamToJsAuthParamy in"); + SetValueInt32(env, "authType", authParam.authType, paramResult); + + napi_value extraInfo; + napi_create_object(env, &extraInfo); + SetValueInt32(env, "direction", authParam.direction, extraInfo); + SetValueInt32(env, "pinToken", authParam.pinToken, extraInfo); + if (authParam.direction == DM_AUTH_DIRECTION_CLIENT) { + napi_set_named_property(env, paramResult, "extraInfo", extraInfo); + return; + } + + SetValueUtf8String(env, "packageName", authParam.packageName, extraInfo); + SetValueUtf8String(env, "appName", authParam.appName, extraInfo); + SetValueUtf8String(env, "appDescription", authParam.appDescription, extraInfo); + SetValueInt32(env, "business", authParam.business, extraInfo); + SetValueInt32(env, "pinCode", authParam.pincode, extraInfo); + napi_set_named_property(env, paramResult, "extraInfo", extraInfo); + + size_t appIconLen = (size_t)authParam.imageinfo.GetAppIconLen(); + if (appIconLen > 0) { + void* appIcon = nullptr; + 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) { + napi_value appIconArray = nullptr; + napi_create_typedarray(env, napi_uint8_array, appIconLen, appIconBuffer, 0, &appIconArray); + napi_set_named_property(env, paramResult, "appIcon", appIconArray); + } + } + + size_t appThumbnailLen = (size_t)authParam.imageinfo.GetAppThumbnailLen(); + if (appThumbnailLen > 0) { + void* appThumbnail = nullptr; + napi_value appThumbnailBuffer = nullptr; + napi_create_arraybuffer(env, appThumbnailLen, &appThumbnail, &appThumbnailBuffer); + if (appThumbnail != nullptr && + memcpy_s(appThumbnail, appThumbnailLen, 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); + } + } +} + +void DeviceManagerNapi::JsObjectToString(const napi_env &env, const napi_value &object, + const std::string &fieldStr, char *dest, const int destLen) { bool hasProperty = false; NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); @@ -287,26 +427,43 @@ void DeviceManagerNapi::JsObjectToString(const napi_env& env, const napi_value& napi_get_named_property(env, object, fieldStr.c_str(), &field); NAPI_CALL_RETURN_VOID(env, napi_typeof(env, field, &valueType)); NAPI_ASSERT_RETURN_VOID(env, valueType == napi_string, "Wrong argument type. String expected."); - if (bufLen <= 0) { - HILOGE("js object to str bufLen invalid"); - return; - } - std::unique_ptr buf = std::make_unique(bufLen); - if (buf == nullptr) { - HILOGE("js object to str malloc failed"); - return; - } - (void)memset_s(buf.get(), bufLen, 0, bufLen); size_t result = 0; - NAPI_CALL_RETURN_VOID(env, napi_get_value_string_utf8(env, field, buf.get(), bufLen, &result)); - fieldRef = buf.get(); + 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()); + } +} + +std::string DeviceManagerNapi::JsObjectToString(const napi_env& env, const napi_value& param) +{ + DMLOG(DM_LOG_INFO, "JsObjectToString in."); + size_t size = 0; + if (napi_get_value_string_utf8(env, param, nullptr, 0, &size) != napi_ok) { + return ""; + } + if (size == 0) { + return ""; + } + char *buf = new (std::nothrow) char[size + 1]; + if (buf == nullptr) { + return ""; + } + memset_s(buf, sizeof(buf), 0, sizeof(buf)); + bool rev = napi_get_value_string_utf8(env, param, buf, size + 1, &size) == napi_ok; + + std::string value; + if (rev) { + value = buf; } else { - HILOGE("devicemanager napi js to str no property: %{public}s", fieldStr.c_str()); + value = ""; } + delete[] buf; + buf = nullptr; + return value; } -void DeviceManagerNapi::JsObjectToInt(const napi_env& env, const napi_value& object, - const std::string& fieldStr, int& fieldRef) +void DeviceManagerNapi::JsObjectToInt(const napi_env &env, const napi_value &object, + const std::string &fieldStr, int &fieldRef) { bool hasProperty = false; NAPI_CALL_RETURN_VOID(env, napi_has_named_property(env, object, fieldStr.c_str(), &hasProperty)); @@ -319,12 +476,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 { - HILOGE("devicemanager napi js to int no property: %{public}s", fieldStr.c_str()); + DMLOG(DM_LOG_ERROR, "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)); @@ -337,17 +494,17 @@ 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 { - HILOGE("devicemanager napi js to bool no property: %{public}s", fieldStr.c_str()); + DMLOG(DM_LOG_ERROR, "devicemanager napi js to bool no property: %s", fieldStr.c_str()); } } -int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env& env, const napi_value& object, - OHOS::DistributedHardware::DmSubscribeInfo& info) +int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env &env, const napi_value &object, + DmSubscribeInfo &info) { int subscribeId = -1; JsObjectToInt(env, object, "subscribeId", subscribeId); if (subscribeId < 0 || subscribeId > DM_NAPI_SUB_ID_MAX) { - HILOGE("DeviceManagerNapi::JsToDmSubscribeInfo, subscribeId error, subscribeId: %{public}d ", subscribeId); + DMLOG(DM_LOG_ERROR, "DeviceManagerNapi::JsToDmSubscribeInfo, subscribeId error, subscribeId: %d ", subscribeId); return -1; } @@ -371,25 +528,178 @@ int32_t DeviceManagerNapi::JsToDmSubscribeInfo(const napi_env& env, const napi_v int capability = -1; JsObjectToInt(env, object, "capability", capability); if (capability == DmNapiSubscribeCap::DM_NAPI_SUBSCRIBE_CAPABILITY_DDMP) { - info.capability = std::string(DM_CAPABILITY_DDMP); + (void)strncpy_s(info.capability, sizeof(info.capability), DM_CAPABILITY_OSD, strlen(DM_CAPABILITY_OSD)); } return 0; } -void DeviceManagerNapi::JsToDmDeviceInfo(const napi_env& env, const napi_value& object, - OHOS::DistributedHardware::DmDeviceInfo& info) +void DeviceManagerNapi::JsToDmDeviceInfo(const napi_env &env, const napi_value &object, + DmDeviceInfo &info) { - JsObjectToString(env, object, "deviceId", DM_NAPI_BUF_LENGTH, info.deviceId); - JsObjectToString(env, object, "deviceName", DM_NAPI_BUF_LENGTH, info.deviceName); + JsObjectToString(env, object, "deviceId", info.deviceId, sizeof(info.deviceId)); + JsObjectToString(env, object, "deviceName", info.deviceName, sizeof(info.deviceName)); int deviceType = -1; JsObjectToInt(env, object, "deviceType", deviceType); info.deviceTypeId = (DMDeviceType)deviceType; } +void DeviceManagerNapi::JsToDmAppImageInfoAndDmExtra(const napi_env& env, const napi_value& object, + DmAppImageInfo& appImageInfo, std::string& extra, int32_t& authType) +{ + DMLOG(DM_LOG_INFO, "JsToDmAppImageInfoAndDmExtra in."); + int authTypeTemp = -1; + JsObjectToInt(env, object, "authType", authTypeTemp); + authType = authTypeTemp; + + uint8_t* appIconBufferPtr = nullptr; + int32_t appIconBufferLen = 0; + JsToDmBuffer(env, object, "appIcon", &appIconBufferPtr, appIconBufferLen); + + 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; + } + if (appThumbnailBufferPtr != nullptr) { + free(appThumbnailBufferPtr); + appThumbnailBufferPtr = nullptr; + } + + nlohmann::json jsonObj; + jsonObj[AUTH_TYPE] = authType; + std::string extraInfo = "extraInfo"; + + JsToJsonObject(env, object, "extraInfo", jsonObj); + extra = jsonObj.dump(); + DMLOG(DM_LOG_INFO, "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) +{ + DMLOG(DM_LOG_INFO, "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()); + return; + } + + napi_value field; + napi_get_named_property(env, object, fieldStr.c_str(), &field); + napi_typedarray_type type; + size_t length = 0; + 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); + if (type != napi_uint8_array || length == 0 || data == nullptr) { + DMLOG(DM_LOG_ERROR, "Invaild AppIconInfo"); + return; + } + *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()); + return; + } + if (memcpy_s(*bufferPtr, length, data, length) != 0) { + DMLOG(DM_LOG_ERROR, "memcpy_s failed, filed %s", fieldStr.c_str()); + free(*bufferPtr); + *bufferPtr = nullptr; + return; + } + bufferLen = length; +} + +void DeviceManagerNapi::JsToJsonObject(const napi_env& env, const napi_value& object, + const std::string& fieldStr, nlohmann::json &jsonObj) +{ + DMLOG(DM_LOG_INFO, "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()); + return; + } + + napi_value jsonField; + napi_get_named_property(env, object, fieldStr.c_str(), &jsonField); + napi_valuetype jsValueType = napi_undefined; + napi_value jsProNameList = nullptr; + 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); + + // TODO 校验各个参数的类型是否正确 + napi_value jsProName = nullptr; + napi_value jsProValue = nullptr; + for (uint32_t index = 0; index < jsProCount; index++) { + napi_get_element(env, jsProNameList, index, &jsProName); + std::string strProName = JsObjectToString(env, jsProName); + napi_get_named_property(env, jsonField, strProName.c_str(), &jsProValue); + napi_typeof(env, jsProValue, &jsValueType); + 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()); + 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); + 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()); + } else { + jsonObj[strProName] = elementValue; + DMLOG(DM_LOG_INFO, "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()); + break; + } + } + } +} + +void DeviceManagerNapi::JsToDmAuthInfo(const napi_env& env, const napi_value& object, std::string& extra) +{ + DMLOG(DM_LOG_INFO, "%s called.", __func__); + int authType = -1; + int 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; + } + JsToJsonObject(env, object, "extraInfo", jsonObj); + extra = jsonObj.dump(); +} void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &eventType) { - HILOGE("CreateDmCallback for bunderName %{public}s eventType %{public}s", bundleName.c_str(), eventType.c_str()); + DMLOG(DM_LOG_ERROR, "CreateDmCallback for bunderName %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()) { @@ -397,7 +707,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) { - HILOGE("RegisterDevStateCallback failed for bunderName %{public}s", bundleName.c_str()); + DMLOG(DM_LOG_ERROR, "RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); return; } g_deviceStateCallbackMap[bundleName] = callback; @@ -419,12 +729,17 @@ void DeviceManagerNapi::CreateDmCallback(std::string &bundleName, std::string &e discoverCallback->IncreaseRefCount(); return; } - - if (eventType == DM_NAPI_EVENT_DEVICE_AUTH_RESULT) { - auto iter = g_authCallbackMap.find(bundleName); - if (iter == g_authCallbackMap.end()) { - auto callback = std::make_shared(bundleName); - g_authCallbackMap[bundleName] = callback; + + if (eventType == DM_NAPI_EVENT_DMFA_CALLBACK) { + auto iter = g_dmfaCallbackMap.find(bundleName); + if (iter == g_dmfaCallbackMap.end()) { + 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()); + return; + } + g_dmfaCallbackMap[bundleName] = callback; } return; } @@ -435,12 +750,12 @@ 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()) { - HILOGE("ReleaseDmCallback: cannot find stateCallback for bunderName %{public}s", bundleName.c_str()); + DMLOG(DM_LOG_ERROR, "ReleaseDmCallback: cannot find stateCallback for bunderName %s", bundleName.c_str()); return; } int32_t ret = DeviceManager::GetInstance().UnRegisterDevStateCallback(bundleName); if (ret != 0) { - HILOGE("RegisterDevStateCallback failed for bunderName %{public}s", bundleName.c_str()); + DMLOG(DM_LOG_ERROR, "RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); return; } g_deviceStateCallbackMap.erase(bundleName); @@ -462,19 +777,74 @@ void DeviceManagerNapi::ReleaseDmCallback(std::string &bundleName, std::string & return; } - if (eventType == DM_NAPI_EVENT_DEVICE_AUTH_RESULT) { - auto iter = g_authCallbackMap.find(bundleName); - if (iter == g_authCallbackMap.end()) { + 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()); + return; + } + int32_t ret = DeviceManager::GetInstance().UnRegisterDeviceManagerFaCallback(bundleName); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "RegisterDevStateCallback failed for bunderName %s", bundleName.c_str()); return; } + g_dmfaCallbackMap.erase(bundleName); + return; + } +} - g_authCallbackMap.erase(bundleName); +napi_value DeviceManagerNapi::SetUserOperationSync(napi_env env, napi_callback_info info) +{ + DMLOG(DM_LOG_INFO, "SetUserOperationSync in"); + GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); + napi_valuetype valueType; + napi_typeof(env, argv[0], &valueType); + NAPI_ASSERT(env, valueType == napi_number, "Wrong argument type. Object expected."); + + int32_t action = 0; + napi_get_value_int32(env, argv[0], &action); + DeviceManagerNapi *deviceManagerWrapper = nullptr; + 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); } + napi_value result = nullptr; + napi_get_undefined(env, &result); + return result; +} + +napi_value DeviceManagerNapi::GetAuthenticationParamSync(napi_env env, napi_callback_info info) +{ + DMLOG(DM_LOG_INFO, "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().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; + } + + napi_create_object(env, &resultParam); + DmAuthParamToJsAuthParamy(env, authParam, resultParam); + return resultParam; } napi_value DeviceManagerNapi::GetTrustedDeviceListSync(napi_env env, napi_callback_info info) { - HILOGI("GetTrustedDeviceList in"); + DMLOG(DM_LOG_INFO, "GetTrustedDeviceList in"); size_t argc = 0; napi_value thisVar = nullptr; napi_value array = nullptr; @@ -488,7 +858,7 @@ napi_value DeviceManagerNapi::GetTrustedDeviceListSync(napi_env env, napi_callba std::vector devList; int32_t ret = DeviceManager::GetInstance().GetTrustedDeviceList(deviceManagerWrapper->bundleName_, extra, devList); if (ret != 0) { - HILOGE("GetTrustedDeviceList for bunderName %{public}s failed, ret %{public}d", + DMLOG(DM_LOG_ERROR, "GetTrustedDeviceList for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); return array; } @@ -498,14 +868,14 @@ napi_value DeviceManagerNapi::GetTrustedDeviceListSync(napi_env env, napi_callba napi_create_array(env, &array); napi_is_array(env, array, &isArray); if (isArray == false) { - HILOGE("napi_create_array fail"); + DMLOG(DM_LOG_ERROR, "napi_create_array fail"); } for (size_t i = 0; i != devList.size(); ++i) { DeviceInfoToJsArray(env, devList, i, array); } } else { - HILOGE("devList is null"); + DMLOG(DM_LOG_ERROR, "devList is null"); } return array; @@ -513,7 +883,7 @@ napi_value DeviceManagerNapi::GetTrustedDeviceListSync(napi_env env, napi_callba napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callback_info info) { - HILOGI("StartDeviceDiscoverSync in"); + DMLOG(DM_LOG_INFO, "StartDeviceDiscoverSync in"); GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); napi_value result = nullptr; napi_valuetype valueType; @@ -538,7 +908,7 @@ napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callbac int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(deviceManagerWrapper->bundleName_, subInfo, discoverCallback); if (ret != 0) { - HILOGE("StartDeviceDiscovery for bunderName %{public}s failed, ret %{public}d", + DMLOG(DM_LOG_ERROR, "StartDeviceDiscovery for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); return result; } @@ -549,7 +919,7 @@ napi_value DeviceManagerNapi::StartDeviceDiscoverSync(napi_env env, napi_callbac napi_value DeviceManagerNapi::StopDeviceDiscoverSync(napi_env env, napi_callback_info info) { - HILOGI("StopDeviceDiscoverSync in"); + DMLOG(DM_LOG_INFO, "StopDeviceDiscoverSync in"); GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); napi_value result = nullptr; napi_valuetype valueType; @@ -565,7 +935,7 @@ napi_value DeviceManagerNapi::StopDeviceDiscoverSync(napi_env env, napi_callback int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(deviceManagerWrapper->bundleName_, (int16_t)subscribeId); if (ret != 0) { - HILOGE("StopDeviceDiscovery for bunderName %{public}s failed, ret %{public}d", + DMLOG(DM_LOG_ERROR, "StopDeviceDiscovery for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); return result; } @@ -574,14 +944,25 @@ napi_value DeviceManagerNapi::StopDeviceDiscoverSync(napi_env env, napi_callback return result; } -napi_value DeviceManagerNapi::AuthenticateDeviceSync(napi_env env, napi_callback_info info) +napi_value DeviceManagerNapi::AuthenticateDevice(napi_env env, napi_callback_info info) { - HILOGI("AuthenticateDeviceSync in"); - GET_PARAMS(env, info, DM_NAPI_ARGS_ONE); + DMLOG(DM_LOG_INFO, "AuthenticateDevice in"); + GET_PARAMS(env, info, DM_NAPI_ARGS_THREE); napi_value result = nullptr; - napi_valuetype valueType; - napi_typeof(env, argv[0], &valueType); - NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected."); + napi_valuetype deviceInfoType; + napi_typeof(env, argv[0], &deviceInfoType); + NAPI_ASSERT(env, deviceInfoType == napi_object, "Wrong argument type. Object expected."); + + napi_valuetype authparamType; + napi_typeof(env, argv[1], &authparamType); + NAPI_ASSERT(env, authparamType == napi_object, "Wrong argument type. Object expected."); + + napi_valuetype eventHandleType = napi_undefined; + napi_typeof(env, argv[2], &eventHandleType); + NAPI_ASSERT(env, eventHandleType == napi_function, "Wrong argument type. Function expected."); + + authAsyncCallbackInfo_.env = env; + napi_create_reference(env, argv[2], 1, &authAsyncCallbackInfo_.callback); DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); @@ -597,13 +978,55 @@ napi_value DeviceManagerNapi::AuthenticateDeviceSync(napi_env env, napi_callback DmDeviceInfo deviceInfo; JsToDmDeviceInfo(env, argv[0], deviceInfo); - std::string extra = ""; + DmAppImageInfo appImageInfo(nullptr, 0, nullptr, 0); + std::string extra; + JsToDmAppImageInfoAndDmExtra(env, argv[1], appImageInfo, extra, authAsyncCallbackInfo_.authType); + int32_t ret = DeviceManager::GetInstance().AuthenticateDevice(deviceManagerWrapper->bundleName_, deviceInfo, - extra, authCallback); + appImageInfo, extra, authCallback); if (ret != 0) { - HILOGE("AuthenticateDevice for bunderName %{public}s failed, ret %{public}d", + DMLOG(DM_LOG_ERROR, "AuthenticateDevice for bunderName %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"); + GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); + napi_value result = nullptr; + napi_valuetype valueType; + napi_typeof(env, argv[0], &valueType); + NAPI_ASSERT(env, valueType == napi_object, "Wrong argument type. Object expected."); + + napi_valuetype eventHandleType = napi_undefined; + napi_typeof(env, argv[1], &eventHandleType); + NAPI_ASSERT(env, eventHandleType == napi_function, "Wrong argument type. Object expected."); + + verifyAsyncCallbackInfo_.env = env; + napi_create_reference(env, argv[1], 1, &verifyAsyncCallbackInfo_.callback); + + 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; + } else { + verifyCallback = iter->second; + } + std::string authParam; + JsToDmAuthInfo(env, argv[0], authParam); + + int32_t ret = DeviceManager::GetInstance().CheckAuthentication(deviceManagerWrapper->bundleName_, authParam, verifyCallback); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "VerifyAuthInfo for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); - return result; } napi_get_undefined(env, &result); @@ -612,7 +1035,7 @@ napi_value DeviceManagerNapi::AuthenticateDeviceSync(napi_env env, napi_callback napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) { - HILOGI("JsOn in"); + 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"); @@ -635,7 +1058,7 @@ napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - HILOGI("JsOn for bunderName %{public}s, eventType %{public}s ", deviceManagerWrapper->bundleName_.c_str(), + DMLOG(DM_LOG_INFO, "JsOn for bunderName %s, eventType %s ", deviceManagerWrapper->bundleName_.c_str(), eventType.c_str()); deviceManagerWrapper->On(eventType, argv[1]); CreateDmCallback(deviceManagerWrapper->bundleName_, eventType); @@ -647,7 +1070,7 @@ napi_value DeviceManagerNapi::JsOn(napi_env env, napi_callback_info info) napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) { - HILOGI("JsOff in"); + 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"); @@ -673,7 +1096,7 @@ napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - HILOGI("JsOff for bunderName %{public}s, eventType %{public}s ", deviceManagerWrapper->bundleName_.c_str(), + DMLOG(DM_LOG_INFO, "JsOff for bunderName %s, eventType %s ", deviceManagerWrapper->bundleName_.c_str(), eventType.c_str()); deviceManagerWrapper->Off(eventType); ReleaseDmCallback(deviceManagerWrapper->bundleName_, eventType); @@ -685,7 +1108,7 @@ napi_value DeviceManagerNapi::JsOff(napi_env env, napi_callback_info info) napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_info info) { - HILOGI("ReleaseDeviceManager in"); + DMLOG(DM_LOG_INFO, "ReleaseDeviceManager in"); size_t argc = 0; napi_value thisVar = nullptr; napi_value result = nullptr; @@ -695,10 +1118,10 @@ napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_i DeviceManagerNapi *deviceManagerWrapper = nullptr; napi_unwrap(env, thisVar, reinterpret_cast(&deviceManagerWrapper)); - HILOGI("ReleaseDeviceManager for bunderName %{public}s", deviceManagerWrapper->bundleName_.c_str()); + DMLOG(DM_LOG_INFO, "ReleaseDeviceManager for bunderName %s", deviceManagerWrapper->bundleName_.c_str()); int32_t ret = DeviceManager::GetInstance().UnInitDeviceManager(deviceManagerWrapper->bundleName_); if (ret != 0) { - HILOGE("ReleaseDeviceManager for bunderName %{public}s failed, ret %{public}d", + DMLOG(DM_LOG_ERROR, "ReleaseDeviceManager for bunderName %s failed, ret %d", deviceManagerWrapper->bundleName_.c_str(), ret); napi_create_uint32(env, ret, &result); return result; @@ -709,6 +1132,7 @@ napi_value DeviceManagerNapi::ReleaseDeviceManager(napi_env env, napi_callback_i g_deviceStateCallbackMap.erase(deviceManagerWrapper->bundleName_); g_discoverCallbackMap.erase(deviceManagerWrapper->bundleName_); g_authCallbackMap.erase(deviceManagerWrapper->bundleName_); + g_checkAuthCallbackMap.erase(deviceManagerWrapper->bundleName_); napi_get_undefined(env, &result); return result; } @@ -725,7 +1149,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) { - HILOGE("InitDeviceManager for bunderName %{public}s failed", bundleName.c_str()); + DMLOG(DM_LOG_ERROR, "InitDeviceManager for bunderName %s failed", bundleName.c_str()); return; } g_initCallbackMap[bundleName] = initCallback; @@ -741,12 +1165,12 @@ void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbac napi_create_string_utf8(env, asCallbackInfo->bundleName, NAPI_AUTO_LENGTH, &argv); napi_status ret = napi_new_instance(env, ctor, DM_NAPI_ARGS_ONE, &argv, &result[1]); if (ret != napi_ok) { - HILOGE("Create DeviceManagerNapi for bunderName %{public}s failed", asCallbackInfo->bundleName); + DMLOG(DM_LOG_ERROR, "Create DeviceManagerNapi for bunderName %s failed", asCallbackInfo->bundleName); asCallbackInfo->status = -1; } if (asCallbackInfo->status == 0) { - HILOGI("InitDeviceManager for bunderName %{public}s success", asCallbackInfo->bundleName); + DMLOG(DM_LOG_INFO, "InitDeviceManager for bunderName %s success", asCallbackInfo->bundleName); napi_get_undefined(env, &result[0]); napi_value callback = nullptr; napi_value callResult = nullptr; @@ -754,7 +1178,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 { - HILOGI("InitDeviceManager for bunderName %{public}s failed", asCallbackInfo->bundleName); + DMLOG(DM_LOG_INFO, "InitDeviceManager for bunderName %s failed", asCallbackInfo->bundleName); napi_value message = nullptr; napi_create_object(env, &result[0]); napi_create_int32(env, asCallbackInfo->status, &message); @@ -771,7 +1195,7 @@ void DeviceManagerNapi::HandleCreateDmCallBack(const napi_env &env, AsyncCallbac napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_info info) { - HILOGI("CreateDeviceManager in"); + DMLOG(DM_LOG_INFO, "CreateDeviceManager in"); GET_PARAMS(env, info, DM_NAPI_ARGS_TWO); NAPI_ASSERT(env, argc >= DM_NAPI_ARGS_TWO, "Wrong number of arguments, required 2"); @@ -798,7 +1222,7 @@ napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_in napi_value DeviceManagerNapi::Constructor(napi_env env, napi_callback_info info) { - HILOGI("DeviceManagerNapi Constructor in"); + DMLOG(DM_LOG_INFO, "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"); @@ -810,7 +1234,7 @@ napi_value DeviceManagerNapi::Constructor(napi_env env, napi_callback_info info) size_t typeLen = 0; napi_get_value_string_utf8(env, argv[0], bundleName, sizeof(bundleName), &typeLen); - HILOGI("create DeviceManagerNapi for packageName:%{public}s", bundleName); + DMLOG(DM_LOG_INFO, "create DeviceManagerNapi for packageName:%s", bundleName); DeviceManagerNapi *obj = new DeviceManagerNapi(env, thisVar); obj->bundleName_ = std::string(bundleName); g_deviceManagerMap[obj->bundleName_] = obj; @@ -833,7 +1257,10 @@ napi_value DeviceManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_FUNCTION("getTrustedDeviceListSync", GetTrustedDeviceListSync), DECLARE_NAPI_FUNCTION("startDeviceDiscovery", StartDeviceDiscoverSync), DECLARE_NAPI_FUNCTION("stopDeviceDiscovery", StopDeviceDiscoverSync), - DECLARE_NAPI_FUNCTION("authenticateDevice", AuthenticateDeviceSync), + DECLARE_NAPI_FUNCTION("authenticateDevice", AuthenticateDevice), + DECLARE_NAPI_FUNCTION("verifyAuthInfo", VerifyAuthInfo), + DECLARE_NAPI_FUNCTION("setUserOperation", SetUserOperationSync), + DECLARE_NAPI_FUNCTION("getAuthenticationParam", GetAuthenticationParamSync), DECLARE_NAPI_FUNCTION("on", JsOn), DECLARE_NAPI_FUNCTION("off", JsOff) }; @@ -842,14 +1269,14 @@ napi_value DeviceManagerNapi::Init(napi_env env, napi_value exports) DECLARE_NAPI_STATIC_FUNCTION("createDeviceManager", CreateDeviceManager), }; - HILOGD("DeviceManagerNapi::Init() is called!"); + 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)); NAPI_CALL(env, napi_create_reference(env, dmClass, 1, &sConstructor_)); NAPI_CALL(env, napi_set_named_property(env, exports, DEVICE_MANAGER_NAPI_CLASS_NAME.c_str(), dmClass)); NAPI_CALL(env, napi_define_properties(env, exports, sizeof(static_prop) / sizeof(static_prop[0]), static_prop)); - HILOGI("All props and functions are configured.."); + DMLOG(DM_LOG_INFO, "All props and functions are configured.."); return exports; } @@ -858,7 +1285,7 @@ napi_value DeviceManagerNapi::Init(napi_env env, napi_value exports) */ static napi_value Export(napi_env env, napi_value exports) { - HILOGI("Export() is called!"); + DMLOG(DM_LOG_INFO, "Export() is called!"); DeviceManagerNapi::Init(env, exports); return exports; } @@ -881,6 +1308,6 @@ static napi_module g_dmModule = { */ extern "C" __attribute__((constructor)) void RegisterModule(void) { - HILOGI("RegisterModule() is called!"); + DMLOG(DM_LOG_INFO, "RegisterModule() is called!"); napi_module_register(&g_dmModule); } diff --git a/services/devicemanagerservice/BUILD.gn b/services/devicemanagerservice/BUILD.gn index 35ff65151..0e6a16139 100644 --- a/services/devicemanagerservice/BUILD.gn +++ b/services/devicemanagerservice/BUILD.gn @@ -11,83 +11,181 @@ # See the License for the specific language governing permissions and # limitations under the License. -import("//build/ohos.gni") +if (defined(ohos_lite)) { + import("//build/lite/config/component/lite_component.gni") +} else { + import("//build/ohos.gni") +} + import("//foundation/distributedhardware/devicemanager/devicemanager.gni") -config("dmservice_config") { - visibility = [ ":*" ] - include_dirs = [ - "//utils/native/base/include", - "//utils/system/safwk/native/include", - "include", - "include/softbus", - "include/authdemo", - "include/util", - "${common_path}/log/include", - "${common_path}/utils/include", - "${innerkits_path}/native_cpp/include", - "//base/security/deviceauth/interfaces/innerkits", - "//third_party/json/include", - "//base/startup/syspara_lite/adapter/native/syspara/include", - ] +if (defined(ohos_lite)) { + executable("devicemanagerservice") { + include_dirs = [ + "include", + "include/ability", + "include/softbus", + "include/requestauth", + "include/auth", + "include/ipc", + "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" + ] - cflags = [ - "-Wall", - "-Werror", - "-Wdate-time", - "-Wfloat-equal", - "-Wshadow", - "-Wformat=2", - "-fvisibility=hidden", - "-fdata-sections", - "-ffunction-sections", - "-Os", - ] + sources = [ + "src/ability/dm_ability_manager.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/ipc/ipc_server_adapter.cpp", + "src/ipc/ipc_server_listener_adapter.cpp", + "src/softbus/softbus_adapter.cpp", + "src/softbus/softbus_session.cpp", + "src/auth/hichain_connector.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", + ] - cflags_cc = [ - "-fvisibility-inlines-hidden", - "-Os", - ] -} + defines = [ + "LITE_DEVICE", + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"devicemanagerservice\"", + "LOG_DOMAIN=0xD004100", + ] + + cflags_cc = build_flags -ohos_shared_library("devicemanagerservice") { - sources = [ - "src/device_manager_service.cpp", - "src/device_manager_stub.cpp", - "src/device_manager_listener_proxy.cpp", - "src/softbus/softbus_adapter.cpp", - "src/authdemo/device_client_channel.cpp", - "src/authdemo/device_server_channel.cpp", - "src/authdemo/hichain_adapter.cpp", - "src/util/anonymous_string.cpp", - ] + deps = [ + "${utils_path}:devicemanagerutils", + "${innerkits_path}/native_cpp:devicemanagersdk", + "//base/security/deviceauth/services:deviceauth_sdk", + "//base/startup/syspara_lite/frameworks/parameter/src:sysparam", + "//utils/native/lite:utils", + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//foundation/communication/ipc_lite:liteipc_adapter", + "//foundation/communication/dsoftbus/sdk:softbus_client", + "//foundation/distributedschedule/samgr_lite/samgr:samgr", + "//third_party/bounds_checking_function:libsec_shared", + "//third_party/mbedtls:mbedtls_shared", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + ] + } +} else { + ohos_shared_library("devicemanagerservice") { + include_dirs = [ + "//utils/native/base/include", + "//utils/system/safwk/native/include", + "include", + "include/ability", + "include/softbus", + "include/requestauth", + "include/auth", + "include/ipc", + "include/message", + "include/ipc/standard", + "${utils_path}/include/cipher", + "${utils_path}/include/log", + "${utils_path}/include", + "${utils_path}/include/ipc/standard", + "${common_path}/include", + "${common_path}/include/ipc", + "${common_path}/include/ipc/model", + "${innerkits_path}/native_cpp/include", + "${innerkits_path}/native_cpp/include/ipc/standard", + "//base/security/deviceauth/interfaces/innerkits", + "//base/startup/syspara_lite/adapter/native/syspara/include", + "//third_party/json/include", + ] + + sources = [ + "src/ability/dm_ability_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/ipc/ipc_server_adapter.cpp", + "src/ipc/ipc_server_listener_adapter.cpp", + "src/softbus/softbus_adapter.cpp", + "src/softbus/softbus_session.cpp", + "src/auth/hichain_connector.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", + ] - configs = [ ":dmservice_config" ] + deps = [ + "//utils/native/base:utils", + "${utils_path}:devicemanagerutils", + "${innerkits_path}/native_cpp:devicemanagersdk", + "//base/security/deviceauth/services:deviceauth_sdk", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + ] - deps = [ - "//utils/native/base:utils", - "${innerkits_path}/native_cpp:devicemanagersdk", - "//base/security/deviceauth/services:deviceauth_sdk", - ] + defines = [ + "HI_LOG_ENABLE", + "DH_LOG_TAG=\"devicemanagerservice\"", + "LOG_DOMAIN=0xD004100", + ] - defines = [ - "DH_LOG_TAG=\"devicemanager\"", - "LOG_DOMAIN=0xD004100", - ] + cflags_cc = build_flags - external_deps = [ - "appexecfwk_standard:appexecfwk_base", - "appexecfwk_standard:appexecfwk_core", - "appexecfwk_standard:libeventhandler", - "hiviewdfx_hilog_native:libhilog", - "ipc:ipc_core", - "safwk:system_ability_fwk", - "samgr_L2:samgr_proxy", - "dsoftbus_standard:softbus_client", - "startup_l2:syspara", - ] + external_deps = [ + "appexecfwk_standard:appexecfwk_base", + "appexecfwk_standard:appexecfwk_core", + "appexecfwk_standard:libeventhandler", + "hiviewdfx_hilog_native:libhilog", + "ipc:ipc_core", + "safwk:system_ability_fwk", + "samgr_L2:samgr_proxy", + "dsoftbus_standard:softbus_client", + "startup_l2:syspara", + ] - subsystem_name = "distributedhardware" + subsystem_name = "distributedhardware" - part_name = "device_manager_base" + part_name = "device_manager_base" + } } diff --git a/common/log/include/device_manager_log.h b/services/devicemanagerservice/include/ability/dm_ability_manager.h similarity index 41% rename from common/log/include/device_manager_log.h rename to services/devicemanagerservice/include/ability/dm_ability_manager.h index 2350623f2..b4157f8b7 100644 --- a/common/log/include/device_manager_log.h +++ b/services/devicemanagerservice/include/ability/dm_ability_manager.h @@ -1,54 +1,65 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_LOG_H -#define OHOS_DEVICE_MANAGER_LOG_H -#include "hilog/log.h" - -namespace OHOS { -namespace DistributedHardware { -static constexpr OHOS::HiviewDFX::HiLogLabel DM_LABEL = {LOG_CORE, LOG_DOMAIN, DH_LOG_TAG}; - -#define PRINT_LOG(Level, fmt, ...) \ - OHOS::HiviewDFX::HiLog::Level(DM_LABEL, "[%{public}s] " fmt, __FUNCTION__, ##__VA_ARGS__) - -#ifdef HILOGD -#undef HILOGD -#endif - -#ifdef HILOGI -#undef HILOGI -#endif - -#ifdef HILOGW -#undef HILOGW -#endif - -#ifdef HILOGE -#undef HILOGE -#endif - -#ifdef HILOGF -#undef HILOGF -#endif - -#define HILOGD(fmt, ...) PRINT_LOG(Debug, fmt, ##__VA_ARGS__) -#define HILOGI(fmt, ...) PRINT_LOG(Info, fmt, ##__VA_ARGS__) -#define HILOGW(fmt, ...) PRINT_LOG(Warn, fmt, ##__VA_ARGS__) -#define HILOGE(fmt, ...) PRINT_LOG(Error, fmt, ##__VA_ARGS__) -#define HILOGF(fmt, ...) PRINT_LOG(Fatal, fmt, ##__VA_ARGS__) -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LOG_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DM_ABILITY_MANAGER_H +#define OHOS_DM_ABILITY_MANAGER_H + +#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 AbilityStatus : int32_t { + ABILITY_STATUS_FAILED = 0, + ABILITY_STATUS_SUCCESS = 1, + ABILITY_STATUS_START = 2 +}; + +typedef 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); + void StartAbilityDone(); + +private: + void waitForTimeout(uint32_t timeout_s); + +private: + sem_t mSem_; + AbilityStatus mStatus_; + AbilityRole mAbilityStatus_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif diff --git a/services/devicemanagerservice/include/authdemo/hichain_adapter.h b/services/devicemanagerservice/include/auth/hichain_connector.h similarity index 40% rename from services/devicemanagerservice/include/authdemo/hichain_adapter.h rename to services/devicemanagerservice/include/auth/hichain_connector.h index 55ca7e5b2..7066deb92 100644 --- a/services/devicemanagerservice/include/authdemo/hichain_adapter.h +++ b/services/devicemanagerservice/include/auth/hichain_connector.h @@ -1,114 +1,99 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_HICHAIN_ADAPTER_H -#define OHOS_HICHAIN_ADAPTER_H - -#include -#include -#include -#include -#include - -#include "device_auth.h" -#include "event_handler.h" -#include "nlohmann/json.hpp" -#include "thread_pool.h" - -#include "device_client_channel.h" -#include "device_server_channel.h" -#include "single_instance.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - SUCCESS = 0, - GROUP_CREATE_FAILED = 1, - MEMBER_ADD_FAILED = 2, - CREATE_CHANNEL_FAILED = 3, -}; - -struct DeviceReqInfo { - std::string deviceId; - std::string ipAddr; - short port; -}; - -class BindCallback { -public: - virtual void onBindSuccess(std::string deviceId, const char* returnData) = 0; - virtual void onBindFailed(std::string deviceId, int32_t errorCode) = 0; - virtual void onUnBindSuccess(std::string /* deviceId */, const char* /* returnData */) {} - virtual void onUnBindFailed(std::string /* deviceId */, int32_t /* errorCode*/) {} - virtual ~BindCallback() {} -}; - -class HichainAuthCallBack { -public: - static bool onTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); - static void onSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen); - static void onFinish(int64_t requestId, int operationCode, const char *returnData); - static void onError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn); - static char* onBindRequest(int64_t requestId, int operationCode, const char *reqParams); -}; - -class HichainAdapter { -DECLARE_SINGLE_INSTANCE(HichainAdapter); -public: - int Init(); - - int32_t Bind(const DeviceReqInfo& devReqInfo, std::shared_ptr callback, bool sync = false); - - void OnBindSuccess(int64_t requestId, const char* returnData); - void OnBindFailed(int64_t requestId, int32_t errorCode); - - void UnBind(const std::string& deviceId); - void OnUnBindFinished(); - - bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); - - void OnGroupCreated(int64_t requestId, const char *groupInfo); - - char* OnBindRequest(int64_t requestId, int operationCode, const char *reqParams); - -private: - std::string GetGroupIdByName(int32_t groupType, const std::string& groupName); - int32_t CreateGroup(int64_t requestId); - int32_t AddMemeber(int64_t requestId, std::string& groupId, const std::string& pinCode); - int64_t GenRequestId(); - -private: - std::atomic requestIdIndex_ {0}; - std::map bindingDeviceMap_; - std::map> clientBindReqMap_; - std::map> bindCallBackMap_; - const DeviceGroupManager* deviceGroupManager_ = nullptr; - std::unique_ptr deviceServerInst_; - mutable ThreadPool threadPool_; - - DeviceAuthCallback deviceAuthCallback_ = { - .onTransmit = HichainAuthCallBack::onTransmit, - .onSessionKeyReturned = HichainAuthCallBack::onSessionKeyReturned, - .onFinish = HichainAuthCallBack::onFinish, - .onError = HichainAuthCallBack::onError, - .onRequest = HichainAuthCallBack::onBindRequest, - }; - - // call back for socket channel - std::function onError_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_HICHAIN_ADAPTER_H \ No newline at end of file +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_HICHAIN_CONNECTOR_H +#define OHOS_HICHAIN_CONNECTOR_H + +#include +#include +#include + +#include "nlohmann/json.hpp" + +#include "device_auth.h" + +#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; + std::string groupOwner; + int32_t groupType; + int32_t groupVisibility; + + GroupInfo() : groupName(""), groupId(""), groupOwner(""), groupType(0), groupVisibility(0) {} +}; + +void from_json(const nlohmann::json& jsonObject, GroupInfo& groupInfo); + +class GroupCreateCallback { +public: + virtual void OnGroupCreated(int64_t requestId, const std::string &groupId) = 0; +}; + +class HichainAuthenCallBack { +public: + static bool onTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); + static void onSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen); + static void onFinish(int64_t requestId, int operationCode, const char *returnData); + static void onError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn); + static char *onRequest(int64_t requestId, int operationCode, const char *reqParams); +}; + +class HichainConnector { +DECLARE_SINGLE_INSTANCE(HichainConnector); +public: + int Init(); + bool OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen); + int64_t GenRequestId(); + void RegisterConnectorCallback(std::shared_ptr callback); + int32_t CreateGroup(int64_t requestId, const std::string &groupName); + int32_t AddMemeber(std::string deviceId, std::shared_ptr msgResponseAuth); + void NotifyHostOnCheckAuthResult(int errorCode); + void GetRelatedGroups(std::string DeviceId, std::vector &groupList); + void SyncGroups(std::string deviceId, std::vector &remoteGroupIdList); + 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); + +private: + std::string GetConnectPara(std::string deviceId, std::shared_ptr msgResponseAuth); + bool IsGroupInfoInvalid(GroupInfo &group); + +private: + std::atomic requestIdIndex_ {0}; + std::shared_ptr groupCreateCallback_ = nullptr; + const DeviceGroupManager* deviceGroupManager_ = nullptr; + DeviceAuthCallback deviceAuthCallback_ = { + .onTransmit = nullptr, + .onFinish = HichainAuthenCallBack::onFinish, + .onError = HichainAuthenCallBack::onError, + .onRequest = HichainAuthenCallBack::onRequest, + }; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_HICHAIN_ADAPTER_H diff --git a/services/devicemanagerservice/include/device_manager_listener_proxy.h b/services/devicemanagerservice/include/device_manager_listener_proxy.h deleted file mode 100644 index d32f7837a..000000000 --- a/services/devicemanagerservice/include/device_manager_listener_proxy.h +++ /dev/null @@ -1,44 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_LISTENER_PROXY_H -#define OHOS_DEVICE_MANAGER_LISTENER_PROXY_H - -#include "idevice_manager_listener.h" -#include "iremote_proxy.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerListenerProxy : public IRemoteProxy { -public: - explicit DeviceManagerListenerProxy(const sptr& impl) - : IRemoteProxy(impl) {}; - ~DeviceManagerListenerProxy() {}; - int32_t OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) override; - int32_t OnDeviceFound(std::string &packageName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo) override; - int32_t OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, int32_t failedReason) override; - int32_t OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) override; - int32_t OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, int32_t reason) override; -private: - bool WriteInterfaceToken(MessageParcel &data); - -private: - static inline BrokerDelegator delegator_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LISTENER_PROXY_H diff --git a/services/devicemanagerservice/include/device_manager_service.h b/services/devicemanagerservice/include/device_manager_service.h deleted file mode 100644 index af19ab97e..000000000 --- a/services/devicemanagerservice/include/device_manager_service.h +++ /dev/null @@ -1,98 +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_SERVICE_H -#define OHOS_DEVICE_MANAGER_SERVICE_H - -#include -#include -#include -#include -#include -#include "system_ability.h" -#include "thread_pool.h" -#include "iremote_stub.h" -#include "idevice_manager.h" -#include "idevice_manager_listener.h" -#include "device_manager_stub.h" -#include "single_instance.h" -#include "hichain_adapter.h" - -namespace OHOS { -namespace DistributedHardware { -enum class ServiceRunningState { - STATE_NOT_START, - STATE_RUNNING -}; - -enum DmBindStatus : uint32_t { - STATE_BIND_SUCCESS, - STATE_BIND_FAILD -}; - -class AppDeathRecipient : public IRemoteObject::DeathRecipient { -public: - void OnRemoteDied(const wptr& remote) override; - AppDeathRecipient() = default; - ~AppDeathRecipient() = default; -}; - -class HiChainBindCallback : public BindCallback { -public: - void onBindSuccess(std::string deviceId, const char* returnData) override; - void onBindFailed(std::string deviceId, int32_t errorCode) override; -}; - -class DeviceManagerService : public SystemAbility, public DeviceManagerStub { -friend class HiChainBindCallback; -DECLARE_SYSTEM_ABILITY(DeviceManagerService); -DECLARE_SINGLE_INSTANCE_BASE(DeviceManagerService); -public: - DeviceManagerService(); - ~DeviceManagerService() = default; - void OnStart() override; - void OnStop() override; - ServiceRunningState QueryServiceState() const; - - int32_t GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) override; - int32_t RegisterDeviceManagerListener(std::string &packageName, sptr listener) override; - int32_t UnRegisterDeviceManagerListener(std::string &packageName) override; - int32_t RegisterDeviceStateCallback(std::string &packageName, std::string &extra) override; - int32_t UnRegisterDeviceStateCallback(std::string &packageName) override; - int32_t StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) override; - int32_t StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) override; - int32_t AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, std::string &extra) override; - const std::map>& GetDmListener(); - const sptr GetDmListener(std::string packageName) const; - -private: - bool Init(); - void RegisterDeviceStateListener(); - -private: - bool registerToService_; - ServiceRunningState state_; - mutable ThreadPool threadPool_; - std::mutex listenerLock_; - std::shared_ptr hichainBindCallback_; - std::map> appRecipient_; - std::map> dmListener_; - std::map devStateCallbackParas_; - std::map authCallbackParas_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_SERVICE_H diff --git a/services/devicemanagerservice/include/device_manager_stub.h b/services/devicemanagerservice/include/device_manager_stub.h deleted file mode 100644 index db5555468..000000000 --- a/services/devicemanagerservice/include/device_manager_stub.h +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_STUB_H -#define OHOS_DEVICE_MANAGER_STUB_H - -#include -#include "iremote_stub.h" -#include "idevice_manager.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceManagerStub : public IRemoteStub { -public: - DeviceManagerStub(); - ~DeviceManagerStub(); - int32_t OnRemoteRequest(uint32_t code, - MessageParcel &data, MessageParcel &reply, MessageOption &option) override; -private: - int32_t RegisterDeviceManagerListenerInner(MessageParcel &data, MessageParcel &reply); - int32_t UnRegisterDeviceManagerListenerInner(MessageParcel &data, MessageParcel &reply); - int32_t RegisterDeviceStateCallbackInner(MessageParcel &data, MessageParcel &reply); - int32_t UnRegisterDeviceStateCallbackInner(MessageParcel &data, MessageParcel &reply); - int32_t GetTrustedDeviceListInner(MessageParcel &data, MessageParcel &reply); - int32_t StartDeviceDiscoveryInner(MessageParcel &data, MessageParcel &reply); - int32_t StopDeviceDiscoveryInner(MessageParcel &data, MessageParcel &reply); - int32_t AuthenticateDeviceInner(MessageParcel &data, MessageParcel &reply); - template - int32_t GetParcelableInfo(MessageParcel &reply, T &parcelableInfo); - bool EnforceInterceToken(MessageParcel &data); - using CmdProcFunc = int32_t (DeviceManagerStub::*)(MessageParcel &data, MessageParcel &reply); - std::map memberFuncMap_; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_STUB_H diff --git a/services/devicemanagerservice/include/authdemo/device_server_channel.h b/services/devicemanagerservice/include/message/msg_codec.h similarity index 38% rename from services/devicemanagerservice/include/authdemo/device_server_channel.h rename to services/devicemanagerservice/include/message/msg_codec.h index 6e3b279fc..8162f88de 100644 --- a/services/devicemanagerservice/include/authdemo/device_server_channel.h +++ b/services/devicemanagerservice/include/message/msg_codec.h @@ -1,53 +1,45 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_SERVER_CHANNEL_H -#define OHOS_DEVICE_SERVER_CHANNEL_H - -#include -#include -#include - -#include "device_auth.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceServerChannel { -public: - DeviceServerChannel(const DeviceGroupManager& deviceGroupManager, - std::function onError) - : socketFd_(-1), clientFd_(-1), deviceGroupManager_(deviceGroupManager), onError_(onError) {} - ~DeviceServerChannel(); - - DeviceServerChannel()=delete; - DeviceServerChannel(const DeviceServerChannel&)=delete; - DeviceServerChannel &operator=(const DeviceServerChannel&)=delete; - -public: - int32_t Start(const int32_t port); - bool Send(const char* data, const int32_t dataLen); - void Receive(); - void OnDataReceived(const char* data, const int32_t dataLen); - void ResetConnection(); - -private: - int32_t socketFd_; - int32_t clientFd_; - const DeviceGroupManager& deviceGroupManager_; - std::function onError_; -}; -} -} -#endif \ No newline at end of file +/* + * 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); +}; +} +} +#endif diff --git a/services/devicemanagerservice/include/message/msg_head.h b/services/devicemanagerservice/include/message/msg_head.h new file mode 100644 index 000000000..b79b99f3e --- /dev/null +++ b/services/devicemanagerservice/include/message/msg_head.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_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 new file mode 100644 index 000000000..30083bdb1 --- /dev/null +++ b/services/devicemanagerservice/include/message/msg_request_auth.h @@ -0,0 +1,83 @@ +/* + * 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() {}; + 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); + void GetDecodeAppInfo(const std::string appString, uint8_t **outBuffer, int32_t& outBufferLen); + int32_t GetMsgSlice(); + int32_t GetMsgCnt(); + std::string GetRequestDeviceId(); + +private: + std::string ToHexString(int32_t value); + std::string EncodeDevInfo(); + static int32_t DecodeFirstPackageMsg(nlohmann::json &json, std::shared_ptr msg); + static void DecodeDeviceInfo(nlohmann::json &json, std::shared_ptr msg); + static std::string StringSub(std::string &thumbStr, int32_t start, int32_t length); + int32_t GetEncodedAppInfo(const uint8_t *dataSrc, size_t srcLen, std::string &outString); + 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); + +public: + std::shared_ptr mHead_; + std::string mHostPkg_; + std::string mTargetPkg_; + std::string mDeviceName_; + std::string mToken_; + std::string mDeviceId_; + std::string mDeviceType_; + std::string mAppName_; + std::string mAppDescription_; + std::string mAppIcon_; + std::string mAppThumbnail_; + int32_t mAuthType_; + int32_t mGroupVisibility_; + int32_t mMsgSlice_; + int32_t mMsgCnt_ = 0; + int32_t mThumbnailSize_; + int32_t mAppIconSize_; +}; +} +} + + +#endif diff --git a/services/devicemanagerservice/include/authdemo/device_client_channel.h b/services/devicemanagerservice/include/message/msg_response_auth.h similarity index 38% rename from services/devicemanagerservice/include/authdemo/device_client_channel.h rename to services/devicemanagerservice/include/message/msg_response_auth.h index dac934e17..3cde51ec7 100644 --- a/services/devicemanagerservice/include/authdemo/device_client_channel.h +++ b/services/devicemanagerservice/include/message/msg_response_auth.h @@ -1,53 +1,60 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_CLIENT_CHANNEL_H -#define OHOS_DEVICE_CLIENT_CHANNEL_H - -#include -#include - -#include "device_auth.h" - -namespace OHOS { -namespace DistributedHardware { -class DeviceClientChannel { -public: - DeviceClientChannel(int64_t requestId, const DeviceGroupManager& deviceGroupManager, - std::function onError) - : requestId_(requestId), socketFd_(-1), deviceGroupManager_(deviceGroupManager), onError_(onError) {} - ~DeviceClientChannel(); - - DeviceClientChannel()=delete; - DeviceClientChannel(const DeviceClientChannel&)=delete; - DeviceClientChannel &operator=(const DeviceClientChannel&)=delete; - -public: - int32_t Connect(const std::string& ip, short port); - bool Send(const char* data, const int32_t dataLen); - void Receive(void); - void OnDataReceived(const char* data, const int32_t dataLen); - void ResetConnection(); - -private: - int64_t requestId_; - int32_t socketFd_; - const DeviceGroupManager& deviceGroupManager_; - // call back for socket channel - std::function onError_; -}; -} -} -#endif \ No newline at end of file +/* + * 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 "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_; + int32_t mReply_; + std::string mNetId_; + std::string mGroupId_; + std::string mGroupName_; + std::string mDeviceId_; + int32_t mPinCode_; + int64_t mRequestId_; + std::vector mSyncGroupList_; +}; +} +} +#endif diff --git a/common/utils/include/device_manager_errno.h b/services/devicemanagerservice/include/message/msg_sync_group.h similarity index 49% rename from common/utils/include/device_manager_errno.h rename to services/devicemanagerservice/include/message/msg_sync_group.h index e2b8cf2c5..c04694fe6 100644 --- a/common/utils/include/device_manager_errno.h +++ b/services/devicemanagerservice/include/message/msg_sync_group.h @@ -1,36 +1,41 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_ERRNO_H -#define OHOS_DEVICE_MANAGER_ERRNO_H -#include "errors.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - DISTRIBUTEDHARDWARE_MODULE_DEVICEMANAGER = 0x00 -}; - -// Error code for Common -constexpr ErrCode DEVICE_MANAGER_ERR_OFFSET = ErrCodeOffset(SUBSYS_DISTRIBUTEDHARDWARE, - DISTRIBUTEDHARDWARE_MODULE_DEVICEMANAGER); -enum { - ERR_DEVICEMANAGER_OPERATION_FAILED = DEVICE_MANAGER_ERR_OFFSET + 1, - ERR_DEVICEMANAGER_SERVICE_NOT_READY = DEVICE_MANAGER_ERR_OFFSET + 2, - ERR_DEVICEMANAGER_DEVICE_ALREADY_TRUSTED = DEVICE_MANAGER_ERR_OFFSET + 3, -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LOG_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_MSG_SYNC_GROUP_H +#define OHOS_MSG_SYNC_GROUP_H + +#include +#include + +#include "nlohmann/json.hpp" + +#include "msg_head.h" + +namespace OHOS { +namespace DistributedHardware { +class MsgSyncGroup { +public: + MsgSyncGroup(std::vector &groupList, std::string &deviceId); + ~MsgSyncGroup() = default; + void Encode(nlohmann::json &json); + +private: + std::shared_ptr mHead_; + std::string mDeviceId_; + std::vector mGroupIdList_; +}; +} +} +#endif \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h b/services/devicemanagerservice/include/requestauth/auth_manager.h similarity index 31% rename from interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h rename to services/devicemanagerservice/include/requestauth/auth_manager.h index bf55490d3..95b71c369 100644 --- a/interfaces/inner_kits/native_cpp/include/idevice_manager_listener.h +++ b/services/devicemanagerservice/include/requestauth/auth_manager.h @@ -1,50 +1,62 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_LISTENER_INTERFACE_H -#define OHOS_DEVICE_MANAGER_LISTENER_INTERFACE_H - -#include "iremote_broker.h" -#include "dm_device_info.h" - -namespace OHOS { -namespace DistributedHardware { -enum { - ON_DEVICE_ONLINE = 0, - ON_DEVICE_OFFLINE = 1, - ON_DEVICE_CHANGE = 2, - ON_DEVICE_FOUND = 3, - ON_DISCOVER_SUCCESS = 4, - ON_DISCOVER_FAILED = 5, - ON_AUTH_RESULT = 6, -}; - -class IDeviceManagerListener : public OHOS::IRemoteBroker { -public: - virtual ~IDeviceManagerListener() {} - virtual int32_t OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDeviceFound(std::string &packageName, uint16_t subscribeId, const DmDeviceInfo &deviceInfo) = 0; - virtual int32_t OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, int32_t failedReason) = 0; - virtual int32_t OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) = 0; - virtual int32_t OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, int32_t reason) = 0; - -public: - DECLARE_INTERFACE_DESCRIPTOR(u"ohos.distributedhardware.devicemanagerlistener"); -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_LISTENER_INTERFACE_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_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(); + +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_ = ""; + 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 new file mode 100644 index 000000000..0c411f4c1 --- /dev/null +++ b/services/devicemanagerservice/include/requestauth/request_session.h @@ -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. + */ + +#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, const DmDeviceInfo &devReqInfo, const DmAppImageInfo &imageInfo, + std::string &extrasJson); + ~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); + +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: + int32_t mSessionType_; + int32_t mStatus_; + std::string mHostPkgName_; + std::string mTargetPkgName; + std::string mToken_; + int32_t mPinToken_; + DmDeviceInfo mDevInfo_; + DmAppImageInfo mImageInfo_; + long long mChannelId_; + bool mIsChannelOpened_ {false}; + std::string mRemoteDeviceId_; + std::string mRemoteNetId_; + std::string mRemoteGroupId_; + std::string mRemoteGroupName_; + long long mRequestId_; + std::shared_ptr responseMsgPtr_; +}; +} +} +#endif diff --git a/services/devicemanagerservice/include/requestauth/response_session.h b/services/devicemanagerservice/include/requestauth/response_session.h new file mode 100644 index 000000000..40a54ad9c --- /dev/null +++ b/services/devicemanagerservice/include/requestauth/response_session.h @@ -0,0 +1,86 @@ +/* + * 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_RESPONSE_SESSION_H +#define OHOS_RESPONSE_SESSION_H + +#include +#include +#include +#include + +#include "single_instance.h" +#include "dm_device_info.h" +#include "msg_response_auth.h" +#include "msg_request_auth.h" +#include "hichain_connector.h" + +namespace OHOS { +namespace DistributedHardware { + +#define CLICK_OK "CLICK_OK" +#define CLICK_CANCEL "CLICK_CANCEL" + +#define AUTH_OK "AUTH_OK" +#define AUTH_ERROR "AUTH_ERROR" + +#define CREATE_GROUP_DONE "CREATE_GROUP_DONE" +#define CREATE_GROUP_ERROR "CREATE_GROUP_ERROR" + +enum ResponseSessionStatus : int32_t { + SESSION_INIT = 0, + SESSION_WAITTING_USER_CONFIRM = 1, + SESSION_WAITTING_GROUP_CREATED = 2, + SESSION_WAITTING_PIN_CODE = 3 +}; + +class ResponseSession : public GroupCreateCallback, 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 BuildAuthenticationInfo(DmAuthParam &authParam); + void OnReceiveMsg(long long channelId, std::string &message); + long long GetRequestId(); + int32_t GetPinCodeByReqId(int64_t requestId); + bool IsMyChannelId(long long channelId); + +private: + void Release(); + int32_t DecodeReqMsg(std::string &message); + int32_t StartFaService(); + std::string GenerateGroupName(); + void OnUserConfirm(); + void OnUserReject(int32_t errorCode); + void CancelDisplay(); + int32_t GeneratePincode(); + +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_; +}; +} // namespace DistributedHardware +} // namespace OHOS + + +#endif diff --git a/services/devicemanagerservice/include/softbus/softbus_adapter.h b/services/devicemanagerservice/include/softbus/softbus_adapter.h index 6d0ba83dc..63fc95b3d 100644 --- a/services/devicemanagerservice/include/softbus/softbus_adapter.h +++ b/services/devicemanagerservice/include/softbus/softbus_adapter.h @@ -17,68 +17,60 @@ #define OHOS_DEVICE_MANAGER_SOFTBUS_ADAPTER_H #include +#include #include #include #include "softbus_bus_center.h" #include "discovery_service.h" #include "dm_device_info.h" #include "dm_subscribe_info.h" -#include "single_instance.h" namespace OHOS { namespace DistributedHardware { -struct SubscribeInfoAdapter { - SubscribeInfo info; - uint16_t subscribeIdOrigin; - uint16_t subscribeIdPrefix; +class PublishServiceCallBack { +public: + static void OnPublishSuccess(int32_t publishId); + static void OnPublishFail(int32_t publishId, PublishFailReason reason); }; class SoftbusAdapter { -DECLARE_SINGLE_INSTANCE(SoftbusAdapter); public: - static int32_t GetSoftbusTrustDevices(const std::string &packageName, std::string &extra, - std::vector &deviceList); - void RegSoftBusDeviceStateListener(); - int32_t StartSoftbusDiscovery(std::string &packageName, DmSubscribeInfo &info); - int32_t StopSoftbusDiscovery(std::string &packageName, uint16_t subscribeId); - static void OnSoftbusDeviceOffline(NodeBasicInfo *info); + static 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(int subscribeId, DiscoveryFailReason failReason); - static void OnSoftbusDiscoverySuccess(int subscribeId); - static void OnSoftbusJoinLNNResult(ConnectionAddr *addr, const char *networkId, int32_t retCode); - static void OnSoftbusLeaveLNNResult(const char *networkId, int32_t retCode); - const std::map>>& GetsubscribeInfos(); - int32_t SoftbusJoinLnn(std::string devId); - int32_t SoftbusLeaveLnn(std::string networkId); - int32_t GetConnectionIpAddr(std::string deviceId, std::string &ipAddr); - static bool IsDeviceOnLine(std::string &deviceId); - + static void OnSoftbusDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason); + static void OnSoftbusDiscoverySuccess(int32_t subscribeId); private: - static void OnSoftBusDeviceStateChange(DmDeviceState state, NodeBasicInfo *info); - std::string GetPackageNameBySubscribeId(uint16_t subscribeId); - bool GetsubscribeIdAdapter(std::string packageName, int16_t originId, int32_t &adapterId); - bool GetPackageNameBySubscribeId(int32_t adapterId, std::string &packageName); - void SaveDiscoverDeviceInfo(const DeviceInfo *deviceInfo); - void RemoveDiscoverDeviceInfo(const std::string deviceId); - + 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: - std::map>> subscribeInfos_; - std::map> discoverDeviceInfoMap_; - std::vector> discoverDeviceInfoVector_; - std::atomic subscribeIdPrefix {0}; - INodeStateCb softbusNodeStateCb = { - .events = EVENT_NODE_STATE_ONLINE | EVENT_NODE_STATE_OFFLINE | EVENT_NODE_STATE_INFO_CHANGED, - .onNodeOnline = OnSoftBusDeviceOnline, - .onNodeOffline = OnSoftbusDeviceOffline, - .onNodeBasicInfoChanged = OnSoftbusDeviceInfoChanged - }; - IDiscoveryCallback softbusDiscoverCallback = { - .OnDeviceFound = OnSoftbusDeviceFound, - .OnDiscoverFailed = OnSoftbusDiscoverFailed, - .OnDiscoverySuccess = OnSoftbusDiscoverySuccess + 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 diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h b/services/devicemanagerservice/include/softbus/softbus_session.h similarity index 38% rename from interfaces/inner_kits/native_cpp/include/device_manager_callback.h rename to services/devicemanagerservice/include/softbus/softbus_session.h index 58aff430f..455fcb5a4 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_callback.h +++ b/services/devicemanagerservice/include/softbus/softbus_session.h @@ -1,52 +1,53 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef OHOS_DEVICE_MANAGER_CALLBACK_H -#define OHOS_DEVICE_MANAGER_CALLBACK_H -#include "dm_device_info.h" - -namespace OHOS { -namespace DistributedHardware { -class DmInitCallback { -public: - virtual ~DmInitCallback() {} - virtual void OnRemoteDied() = 0; -}; - -class DeviceStateCallback { -public: - virtual ~DeviceStateCallback() {} - virtual void OnDeviceOnline(const DmDeviceInfo &deviceInfo) = 0; - virtual void OnDeviceReady(const DmDeviceInfo &deviceInfo) = 0; - virtual void OnDeviceOffline(const DmDeviceInfo &deviceInfo) = 0; - virtual void OnDeviceChanged(const DmDeviceInfo &deviceInfo) = 0; -}; - -class DiscoverCallback { -public: - virtual ~DiscoverCallback() {} - virtual void OnDiscoverySuccess(uint16_t subscribeId) = 0; - virtual void OnDiscoverFailed(uint16_t subscribeId, int32_t failedReason) = 0; - virtual void OnDeviceFound(uint16_t subscribeId, DmDeviceInfo &deviceInfo) = 0; -}; - -class AuthenticateCallback { -public: - virtual ~AuthenticateCallback() {} - virtual void OnAuthResult(std::string &deviceId, int32_t status, int32_t reason) = 0; -}; -} // namespace DistributedHardware -} // namespace OHOS -#endif // OHOS_DEVICE_MANAGER_CALLBACK_H +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DEVICE_MANAGER_SOFTBUS_SESSION_H +#define OHOS_DEVICE_MANAGER_SOFTBUS_SESSION_H + +#include +#include +#include + +#include "session.h" +#include "single_instance.h" +#include "softbus_common.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; + ~SoftbusSession(); +private: + int32_t SendData(int32_t sessionId, const void *data, int32_t len); +private: + const char *PKG_NAME = "com.huawei.devicemanager"; + const char *SESSION_NAME = "com.huawei.devicemanager.resident"; + std::set sessionIdSet_; + std::vector messages_ {}; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DEVICE_MANAGER_SOFTBUS_SESSION_H diff --git a/services/devicemanagerservice/src/ability/dm_ability_manager.cpp b/services/devicemanagerservice/src/ability/dm_ability_manager.cpp new file mode 100644 index 000000000..6297a97c9 --- /dev/null +++ b/services/devicemanagerservice/src/ability/dm_ability_manager.cpp @@ -0,0 +1,94 @@ +/* + * 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_record.h" +#include "ability_manager_service.h" +#include "parameter.h" +#include "semaphore.h" + +#include "constants.h" +#include "device_manager_log.h" + +namespace OHOS { +namespace DistributedHardware { +namespace { +const int32_t ABILITY_START_TIMEOUT = 3; // 3 second +} +IMPLEMENT_SINGLE_INSTANCE(DmAbilityManager); + +AbilityRole DmAbilityManager::GetAbilityRole() +{ + return mAbilityStatus_; +} + +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"; + + mStatus_ = AbilityStatus::ABILITY_STATUS_START; + AAFwk::Want want; + AppExecFwk::ElementName element(deviceId, bundleName, abilityName); + want.SetElement(element); + + 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"); + mStatus_ = AbilityStatus::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_ = AbilityStatus::ABILITY_STATUS_SUCCESS; + sem_post(&mSem_); +} +} +} diff --git a/services/devicemanagerservice/src/auth/hichain_connector.cpp b/services/devicemanagerservice/src/auth/hichain_connector.cpp new file mode 100644 index 000000000..4022ceb13 --- /dev/null +++ b/services/devicemanagerservice/src/auth/hichain_connector.cpp @@ -0,0 +1,424 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "hichain_connector.h" + +#include +#include +#include +#include + +#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" + +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 = "com.huawei.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) +{ + if (jsonObject.find(FIELD_GROUP_NAME) != jsonObject.end()) { + groupInfo.groupName = jsonObject.at(FIELD_GROUP_NAME).get(); + } + + if (jsonObject.find(FIELD_GROUP_ID) != jsonObject.end()) { + groupInfo.groupId = jsonObject.at(FIELD_GROUP_ID).get(); + } + + if (jsonObject.find(FIELD_GROUP_OWNER) != jsonObject.end()) { + groupInfo.groupOwner = jsonObject.at(FIELD_GROUP_OWNER).get(); + } + + if (jsonObject.find(FIELD_GROUP_TYPE) != jsonObject.end()) { + groupInfo.groupType = jsonObject.at(FIELD_GROUP_TYPE).get(); + } + + if (jsonObject.find(FIELD_GROUP_VISIBILITY) != jsonObject.end()) { + groupInfo.groupVisibility = jsonObject.at(FIELD_GROUP_VISIBILITY).get(); + } +} + +int HichainConnector::Init() +{ + DMLOG(DM_LOG_INFO, "HichainConnector::init, init device auth service."); + InitDeviceAuthService(); + + deviceGroupManager_ = GetGmInstance(); + if (deviceGroupManager_ == nullptr) { + DMLOG(DM_LOG_INFO, "HichainConnector::init, failed to init group manager!"); + return -1; + } + deviceGroupManager_->regCallback(DEVICE_MANAGER_APP.c_str(), &deviceAuthCallback_); + DMLOG(DM_LOG_INFO, "HichainConnector::init, init hichain adapter success."); + return 0; +} + +int64_t HichainConnector::GenRequestId() +{ + return EncryptUtils::GenRandLongLong(MIN_REQUEST_ID, MAX_REQUEST_ID); +} + +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; + } + + DMLOG(DM_LOG_INFO, "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; + jsonObj[FIELD_GROUP_NAME] = groupName; + 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()); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "Faild to start CreateGroup task, ret: %d, requestId %lld.", ret, requestId); + return ret; + } + + return SUCCESS; +} + +void HichainConnector::RegisterConnectorCallback(std::shared_ptr callback) +{ + groupCreateCallback_ = callback; +} + +void HichainConnector::OnGroupCreated(int64_t requestId, const std::string &returnData) +{ + if (groupCreateCallback_ == nullptr) { + DMLOG(DM_LOG_ERROR, "HichainConnector::OnGroupCreated groupCreateCallback_ not registe."); + return; + } + + nlohmann::json jsonObject = nlohmann::json::parse(returnData); + if (jsonObject.is_discarded()) { + DMLOG(DM_LOG_ERROR, "HichainConnector::OnGroupCreated returnData not json."); + groupCreateCallback_->OnGroupCreated(requestId, ""); + return; + } + + if (jsonObject.find(FIELD_GROUP_ID) == jsonObject.end()) { + DMLOG(DM_LOG_ERROR, "HichainConnector::OnGroupCreated failed to get groupId."); + groupCreateCallback_->OnGroupCreated(requestId, ""); + return; + } + + std::string groupId = jsonObject.at(FIELD_GROUP_ID).get(); + DMLOG(DM_LOG_INFO, "group create success, groupId:%s.", GetAnonyString(groupId).c_str()); + groupCreateCallback_->OnGroupCreated(requestId, groupId); +} + +int32_t HichainConnector::AddMemeber(std::string deviceId, std::shared_ptr msgResponseAuth) +{ + DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber"); + if (deviceGroupManager_ == nullptr) { + DMLOG(DM_LOG_INFO, "HichainConnector::AddMemeber group manager is null."); + return -1; + } + + 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 HichainConnector::GetConnectPara(std::string deviceId, std::shared_ptr msgResponseAuth) +{ + 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 jsonPara.dump(); +} + +void HichainConnector::GetRelatedGroups(std::string deviceId, std::vector &groupList) +{ + DMLOG(DM_LOG_INFO, "HichainConnector::GetRelatedGroups Start to get local related groups."); + uint32_t groupNum = 0; + char* returnGroups = nullptr; + int ret = deviceGroupManager_->getRelatedGroups(DEVICE_MANAGER_APP.c_str(), deviceId.c_str(), + &returnGroups, &groupNum); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups faild , ret: %d.", ret); + return; + } + + if (returnGroups == nullptr) { + DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups faild , returnGroups is nullptr"); + return; + } + + if (groupNum == 0) { + DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups group failed, groupNum is 0."); + return; + } + + 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; + } + + std::vector groupInfos = jsonObject.get>(); + if (groupInfos.size() == 0) { + DMLOG(DM_LOG_ERROR, "HichainConnector::GetRelatedGroups group failed, groupInfos is empty."); + return; + } + + groupList = groupInfos; + return; +} + +void HichainConnector::GetSyncGroupList(std::vector &groupList, std::vector &syncGroupList) +{ + if (groupList.empty()) { + DMLOG(DM_LOG_ERROR, "groupList is empty."); + return ; + } + + for (auto group : groupList) { + if (IsGroupInfoInvalid(group)) { + continue; + } + syncGroupList.push_back(group.groupId); + } +} + +bool HichainConnector::IsGroupInfoInvalid(GroupInfo &group) +{ + if (group.groupType == GROUP_TYPE_IDENTICAL_ACCOUNT_GROUP || group.groupVisibility == GROUP_VISIBILITY_PUBLIC || + group.groupOwner != DEVICE_MANAGER_APP) { + return true; + } + return false; +} + +void HichainConnector::SyncGroups(std::string deviceId, std::vector &remoteGroupIdList) +{ + std::vector groupInfoList; + GetRelatedGroups(deviceId, groupInfoList); + for (auto &groupInfo : groupInfoList) { + if (IsGroupInfoInvalid(groupInfo)) { + continue; + } + + std::vector::iterator iter; + iter = std::find(remoteGroupIdList.begin(), remoteGroupIdList.end(), groupInfo.groupId); + if (iter == remoteGroupIdList.end()) { + (void)DelMemberFromGroup(groupInfo.groupId, 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()); + nlohmann::json jsonObj; + jsonObj[FIELD_GROUP_ID] = groupId; + jsonObj[FIELD_DELETE_ID] = deviceId; + std::string deleteParams = jsonObj.dump(); + + int ret = deviceGroupManager_->deleteMemberFromGroup(requestId, DEVICE_MANAGER_APP.c_str(), deleteParams.c_str()); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "HichainConnector::DelMemberFromGroup faild , ret: %d.", ret); + return ret; + } + return 0; +} + +void HichainConnector::DeleteGroup(std::string& groupId) +{ + int64_t requestId = GenRequestId(); + nlohmann::json jsonObj; + jsonObj[FIELD_GROUP_ID] = groupId; + std::string disbandParams = jsonObj.dump(); + + int ret = deviceGroupManager_->deleteGroup(requestId, DEVICE_MANAGER_APP.c_str(), disbandParams.c_str()); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "HichainConnector::DeleteGroup faild , ret: %d.", ret); + } +} + +void HichainAuthenCallBack::onFinish(int64_t requestId, int 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().NotifyHostOnCheckAuthResult(SUCCESS); + // TODO: 对于server端，需要通过requestId获取到对应的respsession，通知PIN码界面取消显示. + // 不管成功失败都要显示,对应RespSession的状态重置 + } + + if (operationCode == GroupOperationCode::GROUP_CREATE) { + DMLOG(DM_LOG_INFO, "Create group success"); + std::string returnStr = returnData; + HichainConnector::GetInstance().OnGroupCreated(requestId, returnStr); + } + + 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, int operationCode, int 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().NotifyHostOnCheckAuthResult(FAIL); + // TODO: 对于server端，需要通过requestId获取到对应的respsession，通知PIN码界面取消显示. + // 不管成功失败都要显示,对应RespSession的状态重置 + } + + if (operationCode == GroupOperationCode::GROUP_CREATE) { + DMLOG(DM_LOG_ERROR, "Create group failed"); + HichainConnector::GetInstance().NotifyHostOnCheckAuthResult(FAIL); + // TODO 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, int operationCode, const char *reqParams) +{ + if (operationCode != GroupOperationCode::MEMBER_JOIN) { + DMLOG(DM_LOG_ERROR, "HichainAuthenCallBack::onRequest operationCode %d", operationCode); + return nullptr; + } + + // TODO: Step1: 根据requestId获取RespSession里面保存的PIN码，需要校验requestId的合法性，否则获取失败 + + // TODO: 获取PIN码失败厂家，FIELD_CONFIRMATION玮拒绝，成功的情况玮ACCEPTED + 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; +} + +void HichainConnector::NotifyHostOnCheckAuthResult(int errorCode) +{ + DMLOG(DM_LOG_INFO, "notify host result, errorcode: %d", errorCode); + std::string hostPkgName = "com.ohos.devicemanagerui"; + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + + std::string authParam = AuthManager::GetInstance().GetAuthPara(); + IpcServerListenerAdapter::GetInstance().OnCheckAuthResult(hostPkgName, authParam, errorCode, 0); +} +} +} diff --git a/services/devicemanagerservice/src/authdemo/device_client_channel.cpp b/services/devicemanagerservice/src/authdemo/device_client_channel.cpp deleted file mode 100644 index f1ccaea7b..000000000 --- a/services/devicemanagerservice/src/authdemo/device_client_channel.cpp +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_client_channel.h" - -#include -#include - -#include -#include -#include -#include - -#include -#include - -#include -#include - -#include - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - constexpr int32_t CLIENT_DATA_BUFFER_LENGTH = 2048; - const int32_t RECV_DATA_TIMEOUT = 5; - const int32_t REQUEST_ID_LENGTH = 10; -} - -DeviceClientChannel::~DeviceClientChannel() -{ - if (socketFd_ != -1) { - close(socketFd_); - socketFd_ = -1; - } -} - -int32_t DeviceClientChannel::Connect(const std::string& ip, short port) -{ - HILOGI("DeviceClientChannel::Connect begin to connect to server."); - int32_t socketFd = socket(AF_INET, SOCK_STREAM, 0); - if (socketFd == -1) { - HILOGE("DeviceClientChannel::Connect create socket failed, errMsg: %{public}s.", strerror(errno)); - return -1; - } - - struct sockaddr_in addr; - if (memset_s(&addr, sizeof(addr), 0, sizeof(addr)) != EOK) { - HILOGE("DeviceClientChannel::Connect error init addr."); - close(socketFd); - return -1; - } - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = inet_addr(ip.c_str()); - addr.sin_port = htons(port); - - int32_t ret = connect(socketFd, (struct sockaddr*) &addr, sizeof(addr)); - if (ret == -1) { - HILOGE("DeviceClientChannel::Connect connet server failed, errMsg: %{public}s.", strerror(errno)); - close(socketFd); - return -1; - } - - socketFd_ = socketFd; - HILOGI("DeviceClientChannel::Connect connect to server, fd: %{public}d.", socketFd_); - - // wait five seconds, if recv none, release the connection - struct timeval timeout = {RECV_DATA_TIMEOUT, 0}; - setsockopt(socketFd_, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval)); - return 0; -} - -bool DeviceClientChannel::Send(const char* data, const int32_t dataLen) -{ - // The client needs to add requestId to the header of the data - std::stringstream reqIdStr; - reqIdStr << requestId_; - - int32_t sendDataLen = dataLen + REQUEST_ID_LENGTH; - std::unique_ptr sendData = std::make_unique(sendDataLen); - if (memset_s(sendData.get(), sendDataLen, 0, sendDataLen) != EOK) { - HILOGE("DeviceClientChannel::Send error init send data."); - return false; - } - - if (memcpy_s(sendData.get(), sendDataLen, reqIdStr.str().c_str(), REQUEST_ID_LENGTH) != EOK) { - HILOGE("DeviceClientChannel::Send error init requestId."); - return false; - } - - if (memcpy_s(sendData.get() + REQUEST_ID_LENGTH, sendDataLen - REQUEST_ID_LENGTH, data, dataLen) != EOK) { - HILOGE("DeviceClientChannel::Send error init data."); - return false; - } - - int32_t ret = send(socketFd_, sendData.get(), sendDataLen, 0); - if (ret == -1) { - HILOGE("DeviceClientChannel::send data failed, errMsg: %{public}s.", strerror(errno)); - return false; - } - - HILOGI("DeviceClientChannel::send data, size:%{public}d.", ret); - return true; -} - -void DeviceClientChannel::Receive() -{ - HILOGI("DeviceClientChannel::Receive data, socketFd:%{public}d.", socketFd_); - char dataBuf[CLIENT_DATA_BUFFER_LENGTH] = {0}; - - while (socketFd_ != -1) { - (void)memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf)); - int32_t rc = recv(socketFd_, dataBuf, sizeof(dataBuf), 0); - if (rc == 0) { - HILOGE("DeviceClientChannel::Receive error, client shutdown, socketFd_:%{public}d, errMsg: %{public}s.", - socketFd_, strerror(errno)); - close(socketFd_); - socketFd_ = -1; - break; - } else if (rc == -1 || rc == EAGAIN) { - HILOGE("DeviceClientChannel::Receive data failed, socketFd_:%{public}d, errMsg: %{public}s.", - socketFd_, strerror(errno)); - close(socketFd_); - socketFd_ = -1; - break; - } else { - HILOGI("DeviceClientChannel::Receive data, socketFd_:%{public}d, size:%{public}d.", socketFd_, rc); - OnDataReceived(dataBuf, rc); - } - } - HILOGI("DeviceClientChannel::Receive data end, socketFd:%{public}d.", socketFd_); -} - -void DeviceClientChannel::OnDataReceived(const char* data, const int32_t dataLen) -{ - int ret = deviceGroupManager_.processData(requestId_, (uint8_t *) data, dataLen); - HILOGI("DeviceClientChannel::OnDataReceived process data, ret:%{public}d, dataLen:%{public}d.", ret, dataLen); - if (ret != 0) { - close(socketFd_); - socketFd_ = -1; - onError_(requestId_, 0, ret, nullptr); - } -} - -void DeviceClientChannel::ResetConnection() -{ - HILOGI("DeviceClientChannel::ResetConnection bind finished, release connection."); - close(socketFd_); - socketFd_ = -1; -} -} -} \ No newline at end of file diff --git a/services/devicemanagerservice/src/authdemo/device_server_channel.cpp b/services/devicemanagerservice/src/authdemo/device_server_channel.cpp deleted file mode 100644 index af142ff3c..000000000 --- a/services/devicemanagerservice/src/authdemo/device_server_channel.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_server_channel.h" - -#include -#include - -#include -#include - -#include -#include - -#include -#include - -#include - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - const int32_t DATA_BUFFER_LENGTH = 2048; - const int32_t REQUEST_ID_LENGTH = 10; - const int32_t LISTENING_QUEUE_LEN = 10; - const int64_t MIN_REQUEST_ID = 1000000000; - const int32_t RECV_DATA_TIMEOUT = 5; -} - -DeviceServerChannel::~DeviceServerChannel() -{ - if (socketFd_ != -1) { - close(socketFd_); - socketFd_ = -1; - } - - if (clientFd_ != -1) { - close(clientFd_); - clientFd_ = -1; - } -} - -int32_t DeviceServerChannel::Start(const int32_t port) -{ - HILOGI("DeviceServerChannel::Start begin to start server."); - if (port <= 0) { - HILOGE("DeviceServerChannel::start port is invalid."); - return -1; - } - - int32_t socketFd = socket(AF_INET, SOCK_STREAM, 0); - if (socketFd == -1) { - HILOGE("DeviceServerChannel::start create socket failed, errMsg: %{public}s.", strerror(errno)); - return -1; - } - - struct sockaddr_in addr; - if (memset_s(&addr, sizeof(addr), 0, sizeof(addr)) != EOK) { - HILOGE("DeviceServerChannel::Start error init addr."); - close(socketFd); - return -1; - } - addr.sin_family = AF_INET; - addr.sin_addr.s_addr = INADDR_ANY; - addr.sin_port = htons(port); - - int32_t ret = bind(socketFd, (struct sockaddr*) &addr, sizeof(addr)); - if (ret == -1) { - HILOGE("DeviceServerChannel::start bind addr failed, errMsg: %{public}s.", strerror(errno)); - close(socketFd); - return -1; - } - - socketFd_ = socketFd; - HILOGI("DeviceServerChannel::start bind addr success, fd:%{public}d.", socketFd_); - - ret = listen(socketFd_, LISTENING_QUEUE_LEN); - if (ret == -1) { - HILOGE("DeviceServerChannel::start listen port failed, errMsg: %{public}s.", strerror(errno)); - close(socketFd_); - socketFd_ = -1; - return -1; - } - - return 0; -} - -void DeviceServerChannel::Receive() -{ - HILOGI("DeviceServerChannel::receive begin to listen client connecting."); - struct sockaddr_in client_addr; - socklen_t len = sizeof(client_addr); - - while (true) { - int32_t fd = accept(socketFd_, (struct sockaddr*) &client_addr, &len); - if (fd == -1) { - HILOGE("DeviceServerChannel::receive accept connect failed, errMsg: %{public}s.", strerror(errno)); - continue; - } - - if (clientFd_ != -1) { - HILOGW("DeviceServerChannel::receive another client is connected, close new connect."); - close(fd); - continue; - } - - HILOGI("DeviceServerChannel::receive new client in."); - clientFd_ = fd; - - // wait five seconds, if recv none, release the connection - struct timeval timeout = {RECV_DATA_TIMEOUT, 0}; - setsockopt(clientFd_, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(struct timeval)); - - // demo project, blocked here to receive data, informal solution, will be discard later - char dataBuf[DATA_BUFFER_LENGTH] = {0}; - while (clientFd_ != -1) { - if (memset_s(dataBuf, sizeof(dataBuf), 0, sizeof(dataBuf)) != EOK) { - HILOGE("DeviceServerChannel::receive error init data buf."); - close(clientFd_); - clientFd_ = -1; - break; - } - - int32_t rc = recv(clientFd_, dataBuf, sizeof(dataBuf), 0); - if (rc == 0) { - HILOGE("DeviceServerChannel::receive error, client shutdown."); - close(clientFd_); - clientFd_ = -1; - break; - } else if (rc == -1 || rc == EAGAIN) { - HILOGE("DeviceServerChannel::receive receive data failed, errMsg: %{public}s.", strerror(errno)); - close(clientFd_); - clientFd_ = -1; - break; - } else { - HILOGI("DeviceServerChannel::receive receive data, size:%{public}d.", rc); - OnDataReceived(dataBuf, rc); - } - } - } -} - -void DeviceServerChannel::OnDataReceived(const char* data, const int32_t dataLen) -{ - HILOGI("DeviceServerChannel::OnDataReceived dataLen:%{public}d.", dataLen); - if (dataLen < REQUEST_ID_LENGTH) { - HILOGI("DeviceServerChannel::OnDataReceived error, data is invalid."); - return; - } - - // the client adds requestId to the header of data, the server needs to parse the original data - char reqIdChar[REQUEST_ID_LENGTH + 1] = {0}; - (void)memcpy_s(reqIdChar, sizeof(reqIdChar), data, REQUEST_ID_LENGTH); - reqIdChar[REQUEST_ID_LENGTH] = '\0'; - int64_t requestId = strtoll(reqIdChar, nullptr, REQUEST_ID_LENGTH); - if (requestId < MIN_REQUEST_ID) { - HILOGI("DeviceServerChannel::OnDataReceived error, requestId is invalid."); - return; - } - - const char* newData = data + REQUEST_ID_LENGTH; - int len = dataLen - REQUEST_ID_LENGTH; - int ret = deviceGroupManager_.processData(requestId, (const uint8_t *) newData, len); - HILOGI("DeviceServerChannel::OnDataReceived process data, ret:%{public}d, dataLen:%{public}d.", ret, len); - if (ret != 0) { - onError_(requestId, 0, ret, nullptr); - close(clientFd_); - clientFd_ = -1; - } -} - -bool DeviceServerChannel::Send(const char* data, const int32_t dataLen) -{ - int32_t ret = send(clientFd_, data, dataLen, 0); - if (ret == -1) { - HILOGE("DeviceServerChannel::send failed,socket:%{public}d,errMsg: %{public}s.", clientFd_, strerror(errno)); - return false; - } - - HILOGI("DeviceServerChannel::send data,socket:%{public}d, size:%{public}d.", clientFd_, ret); - return true; -} - -void DeviceServerChannel::ResetConnection() -{ - HILOGI("DeviceServerChannel::ResetConnection bind finished, release connection."); - close(clientFd_); - clientFd_ = -1; -} -} -} \ No newline at end of file diff --git a/services/devicemanagerservice/src/authdemo/hichain_adapter.cpp b/services/devicemanagerservice/src/authdemo/hichain_adapter.cpp deleted file mode 100644 index 5ccc74020..000000000 --- a/services/devicemanagerservice/src/authdemo/hichain_adapter.cpp +++ /dev/null @@ -1,384 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "hichain_adapter.h" - -#include -#include -#include -#include - -#include "parameter.h" - -#include "anonymous_string.h" -#include "device_client_channel.h" -#include "device_manager_log.h" -#include "device_server_channel.h" - - -namespace OHOS { -namespace DistributedHardware { -namespace { -// demo solution, may has security issues, later will be replaced by a formal plan -const std::string PIN_CODE = ""; -const int32_t PORT = -1; - -const std::string DEVICE_MANAGER_APP = "ohos.distributedhardware.devicemanager"; -const std::string DEVICE_MANAGER_GROUPNAME = "DMPeerToPeerGroup"; - -const int64_t MIN_REQUEST_ID = 1000000000; -const int64_t MAX_REQUEST_ID = 9999999999; - -const int32_t DEVICE_UUID_LENGTH = 65; -const int32_t PEER_TO_PEER_GROUP = 256; -const int32_t FIELD_EXPIRE_TIME_VALUE = 90; - -const int32_t THREAD_POOL_NUMBER = 20; -} - -IMPLEMENT_SINGLE_INSTANCE(HichainAdapter); - -int HichainAdapter::Init() -{ - HILOGI("HichainAdapter::init, begin to init hichain adapter."); - if (threadPool_.GetThreadsNum() == 0) { - threadPool_.Start(THREAD_POOL_NUMBER); - } - - bindingDeviceMap_.clear(); - bindCallBackMap_.clear(); - clientBindReqMap_.clear(); - - // call back for socket channel - using std::placeholders::_1; - using std::placeholders::_2; - using std::placeholders::_3; - using std::placeholders::_4; - onError_ = std::bind(HichainAuthCallBack::onError, _1, _2, _3, _4); - - HILOGI("HichainAdapter::init, init device auth service."); - InitDeviceAuthService(); - - // get group auth manager instance, and register callback - deviceGroupManager_ = GetGmInstance(); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::init, failed to init group manager!"); - return -1; - } - deviceGroupManager_->regCallback(DEVICE_MANAGER_APP.c_str(), &deviceAuthCallback_); - - HILOGI("HichainAdapter::init, start socket server channel."); - deviceServerInst_ = std::make_unique(*deviceGroupManager_, onError_); - if (deviceServerInst_->Start(PORT) == -1) { - HILOGE("HichainAdapter::init, failed to start server!"); - return -1; - } - - // start the server channel to receive data - auto receiveFunc = [this]() { - this->deviceServerInst_->Receive(); - }; - threadPool_.AddTask(receiveFunc); - - HILOGI("HichainAdapter::init, init hichain adapter success."); - return 0; -} - -int32_t HichainAdapter::Bind(const DeviceReqInfo& devReqInfo, std::shared_ptr callback, bool sync) -{ - (void)sync; - HILOGI("HichainAdapter::Bind, begin to bind device: %{public}s.", GetAnonyString(devReqInfo.deviceId).c_str()); - for (auto &item : bindingDeviceMap_) { - if (item.second == devReqInfo.deviceId) { - HILOGW("HichainAdapter::bind device is binding, update call back."); - } - } - - int64_t requestId = GenRequestId(); - std::shared_ptr clientChannel = - std::make_shared(requestId, *deviceGroupManager_, onError_); - if (clientChannel->Connect(devReqInfo.ipAddr, PORT) == -1) { - HILOGE("HichainAdapter::bind failed to connect to server, create channel failed."); - return CREATE_CHANNEL_FAILED; - } - - // start the client channel to recevice data - auto receiveFunc = [&clientChannel]() { - clientChannel->Receive(); - }; - threadPool_.AddTask(receiveFunc); - - std::string groupId = GetGroupIdByName(PEER_TO_PEER_GROUP, DEVICE_MANAGER_GROUPNAME); - if (groupId == "") { - HILOGE("HichainAdapter::bind group not exist, begin to create group."); - int32_t ret = CreateGroup(requestId); - if (ret != 0) { - HILOGE("HichainAdapter::bind faild to start create group task, ret: %{public}d.", ret); - return GROUP_CREATE_FAILED; - } - } else { - HILOGE("HichainAdapter::bind group exist, begin to add member."); - int ret = AddMemeber(requestId, groupId, PIN_CODE); - if (ret != 0) { - HILOGE("HichainAdapter::bind faild to start add member task, ret: %{public}d.", ret); - return MEMBER_ADD_FAILED; - } - } - - clientBindReqMap_[requestId] = clientChannel; - bindingDeviceMap_[requestId] = devReqInfo.deviceId; - bindCallBackMap_[requestId] = callback; - return SUCCESS; -} - -std::string HichainAdapter::GetGroupIdByName(int32_t groupType, const std::string& groupName) -{ - HILOGI("HichainAdapter::GetGroupIdByName get group info."); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::GetGroupIdByName group manager is null."); - return ""; - } - - nlohmann::json reqParam; - reqParam[FIELD_GROUP_TYPE] = groupType; - reqParam[FIELD_GROUP_NAME] = groupName; - - char* returnGroupVec = nullptr; - uint32_t groupNum = 0; - int32_t ret = deviceGroupManager_->getGroupInfo(DEVICE_MANAGER_APP.c_str(), reqParam.dump().c_str(), - &returnGroupVec, &groupNum); - if (ret != 0) { - HILOGE("HichainAdapter::GetGroupIdByName failed to get group info, ret=%{public}d.", ret); - return ""; - } - - if (groupNum == 0) { - HILOGE("HichainAdapter::GetGroupIdByName group not exist, return empty."); - return ""; - } - - nlohmann::json groupObj = nlohmann::json::parse(returnGroupVec, nullptr, false); - if (groupObj.is_discarded()) { - HILOGE("HichainAdapter::GetGroupIdByName parse group info error, json invalid."); - return ""; - } - - for (auto& item : groupObj) { - if (item.contains(FIELD_GROUP_ID)) { - return item.at(FIELD_GROUP_ID); - } - } - - HILOGI("HichainAdapter::GetGroupIdByName group info not found, return empty"); - return ""; -} - -int32_t HichainAdapter::CreateGroup(int64_t requestId) -{ - HILOGE("HichainAdapter::CreateGroup requestId:%{public}lld.", requestId); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::CreateGroup group manager is null."); - return -1; - } - - nlohmann::json jsonObj; - jsonObj[FIELD_GROUP_TYPE] = PEER_TO_PEER_GROUP; - jsonObj[FIELD_GROUP_NAME] = DEVICE_MANAGER_GROUPNAME; - - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - - jsonObj[FIELD_DEVICE_ID] = localDeviceId; - jsonObj[FIELD_USER_TYPE] = 0; - jsonObj[FIELD_GROUP_VISIBILITY] = -1; - jsonObj[FIELD_EXPIRE_TIME] = FIELD_EXPIRE_TIME_VALUE; - - return deviceGroupManager_->createGroup(requestId, DEVICE_MANAGER_APP.c_str(), jsonObj.dump().c_str()); -} - -int32_t HichainAdapter::AddMemeber(int64_t requestId, std::string& groupId, const std::string& pinCode) -{ - HILOGE("HichainAdapter::AddMemeber requestId:%{public}lld.", requestId); - if (deviceGroupManager_ == nullptr) { - HILOGE("HichainAdapter::AddMemeber group manager is null."); - return -1; - } - - nlohmann::json jsonObj; - jsonObj[FIELD_GROUP_ID] = groupId; - jsonObj[FIELD_GROUP_TYPE] = PEER_TO_PEER_GROUP; - jsonObj[FIELD_PIN_CODE] = pinCode; - jsonObj[FIELD_IS_ADMIN] = true; - return deviceGroupManager_->addMemberToGroup(requestId, DEVICE_MANAGER_APP.c_str(), jsonObj.dump().c_str()); -} - -bool HichainAdapter::OnTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen) -{ - HILOGI("HichainAdapter::OnTransmit requestId:%{public}lld, size:%{public}d.", requestId, dataLen); - if (clientBindReqMap_.count(requestId) > 0) { - HILOGI("HichainAdapter::OnTransmit client send to server."); - return clientBindReqMap_[requestId]->Send((const char*) data, dataLen); - } else { - HILOGI("HichainAdapter::OnTransmit server send to client."); - return deviceServerInst_->Send((const char*) data, dataLen); - } -} - -void HichainAdapter::OnGroupCreated(int64_t requestId, const char *groupInfo) -{ - nlohmann::json jsonObject = nlohmann::json::parse(groupInfo); - if (jsonObject.find(FIELD_GROUP_ID) == jsonObject.end()) { - HILOGE("HichainAdapter::onGroupCreated failed to get groupId."); - OnBindFailed(requestId, GROUP_CREATE_FAILED); - return; - } - - std::string groupId = jsonObject.at(FIELD_GROUP_ID).get(); - HILOGI("HichainAdapter::onGroupCreated group create success,groupId:%{public}s.", GetAnonyString(groupId).c_str()); - - // group创建成功之后，需要添加把对端设备添加到创建好的群组中 - int ret = AddMemeber(requestId, groupId, PIN_CODE); - if (ret != 0) { - HILOGE("HichainAdapter::onGroupCreated faild to start add member task, ret: %{public}d.", ret); - OnBindFailed(requestId, MEMBER_ADD_FAILED); - return; - } -} - -char* HichainAdapter::OnBindRequest(int64_t requestId, int operationCode, const char *reqParams) -{ - (void)requestId; - (void)operationCode; - (void)reqParams; - - HILOGI("HichainAdapter::OnBindRequest."); - nlohmann::json jsonObj; - jsonObj[FIELD_CONFIRMATION] = REQUEST_ACCEPTED; - jsonObj[FIELD_PIN_CODE] = PIN_CODE; - char localDeviceId[DEVICE_UUID_LENGTH] = {0}; - GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); - jsonObj[FIELD_DEVICE_ID] = localDeviceId; - - std::string jsonStr = jsonObj.dump(); - char *buffer = strdup(jsonStr.c_str()); - return buffer; -} - -void HichainAdapter::OnBindSuccess(int64_t requestId, const char* returnData) -{ - HILOGI("HichainAdapter::OnBindSuccess requestId:%{public}lld,dataLen:%{public}d.", requestId, strlen(returnData)); - if (bindCallBackMap_.count(requestId) == 1) { - bindCallBackMap_[requestId]->onBindSuccess(bindingDeviceMap_[requestId], returnData); - bindCallBackMap_.erase(requestId); - } - - if (clientBindReqMap_.count(requestId) == 1) { - clientBindReqMap_[requestId]->ResetConnection(); - clientBindReqMap_[requestId].reset(); - clientBindReqMap_.erase(requestId); - } - - if (bindingDeviceMap_.count(requestId) == 1) { - bindingDeviceMap_.erase(requestId); - } - - deviceServerInst_->ResetConnection(); -} - -int64_t HichainAdapter::GenRequestId() -{ - int64_t requestId = 0; - do { - requestId = (int64_t)requestIdIndex_ + MIN_REQUEST_ID; - if (requestId > MAX_REQUEST_ID) { - requestId = MIN_REQUEST_ID; - requestIdIndex_ = 0; - } else { - requestIdIndex_++; - } - } while (clientBindReqMap_.count(requestId) != 0); - return requestId; -} - -void HichainAdapter::OnBindFailed(int64_t requestId, int32_t errorCode) -{ - HILOGI("HichainAdapter::OnBindFailed requestId:%{public}lld, errorCode:%{public}d.", requestId, errorCode); - if (bindCallBackMap_.count(requestId) == 1) { - bindCallBackMap_[requestId]->onBindFailed(bindingDeviceMap_[requestId], errorCode); - bindCallBackMap_.erase(requestId); - } - - if (clientBindReqMap_.count(requestId) == 1) { - clientBindReqMap_[requestId].reset(); - clientBindReqMap_.erase(requestId); - } - - if (bindingDeviceMap_.count(requestId) == 1) { - bindingDeviceMap_.erase(requestId); - } -} - -void HichainAdapter::UnBind(const std::string& deviceId) -{ - // reserved interface, to be implemented - (void)deviceId; -} - -void HichainAdapter::OnUnBindFinished() -{ - // reserved interface, to be implemented -} - -bool HichainAuthCallBack::onTransmit(int64_t requestId, const uint8_t *data, uint32_t dataLen) -{ - HILOGI("HichainAuthCallBack::onTransmit requestId:%{public}lld,size:%{public}d.", requestId, dataLen); - return HichainAdapter::GetInstance().OnTransmit(requestId, data, dataLen); -} - -void HichainAuthCallBack::onSessionKeyReturned(int64_t requestId, const uint8_t *sessionKey, uint32_t sessionKeyLen) -{ - (void)requestId; - (void)sessionKey; - HILOGI("HichainAuthCallBack::onSessionKeyReturned size:%{public}d.", sessionKeyLen); -} - -void HichainAuthCallBack::onFinish(int64_t requestId, int operationCode, const char *returnData) -{ - HILOGI("HichainAuthCallBack::onFinish reqId:%{public}lld, operation:%{public}d.", requestId, operationCode); - if (operationCode == GroupOperationCode::GROUP_CREATE) { - HichainAdapter::GetInstance().OnGroupCreated(requestId, returnData); - return; - } - - if (operationCode == GroupOperationCode::MEMBER_INVITE || operationCode == GroupOperationCode::MEMBER_JOIN) { - HichainAdapter::GetInstance().OnBindSuccess(requestId, returnData); - } -} - -void HichainAuthCallBack::onError(int64_t requestId, int operationCode, int errorCode, const char *errorReturn) -{ - (void)errorReturn; - HILOGI("HichainAuthCallBack::onError reqId:%{public}lld, operation:%{public}d, errorCode:%{public}d.", - requestId, operationCode, errorCode); - HichainAdapter::GetInstance().OnBindFailed(requestId, errorCode); -} - -char* HichainAuthCallBack::onBindRequest(int64_t requestId, int operationCode, const char *reqParams) -{ - HILOGI("HichainAuthCallBack::onBindRequest reqId:%{public}lld, operation: %{public}d.", requestId, operationCode); - return HichainAdapter::GetInstance().OnBindRequest(requestId, operationCode, reqParams); -} -} -} diff --git a/services/devicemanagerservice/src/device_manager_listener_proxy.cpp b/services/devicemanagerservice/src/device_manager_listener_proxy.cpp deleted file mode 100644 index d721ef705..000000000 --- a/services/devicemanagerservice/src/device_manager_listener_proxy.cpp +++ /dev/null @@ -1,294 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_manager_listener_proxy.h" - -#include "ipc_types.h" - -#include "device_manager_log.h" - -namespace OHOS { -namespace DistributedHardware { -bool DeviceManagerListenerProxy::WriteInterfaceToken(MessageParcel &data) -{ - if (!data.WriteInterfaceToken(DeviceManagerListenerProxy::GetDescriptor())) { - HILOGE("write interface token failed"); - return false; - } - return true; -} - -int32_t DeviceManagerListenerProxy::OnDeviceOnline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_ONLINE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceOnline SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDeviceOffline(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_OFFLINE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceOffline SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDeviceChanged(std::string &packageName, const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_CHANGE, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceChanged SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDeviceFound(std::string &packageName, uint16_t subscribeId, - const DmDeviceInfo &deviceInfo) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeId failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteParcelable(&deviceInfo)) { - HILOGE("write deviceInfo failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DEVICE_FOUND, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDeviceFound SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDiscoverFailed(std::string &packageName, uint16_t subscribeId, - int32_t failedReason) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeId failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt32(failedReason)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DISCOVER_FAILED, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDiscoverFailed SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnDiscoverySuccess(std::string &packageName, uint16_t subscribeId) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt16(subscribeId)) { - HILOGE("write subscribeId failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_DISCOVER_SUCCESS, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnDiscoverySuccess SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} - -int32_t DeviceManagerListenerProxy::OnAuthResult(std::string &packageName, std::string &deviceId, int32_t status, - int32_t reason) -{ - sptr remote = Remote(); - if (remote == nullptr) { - HILOGE("remote service null"); - return ERR_NULL_OBJECT; - } - - MessageParcel data; - MessageParcel reply; - MessageOption option; - if (!WriteInterfaceToken(data)) { - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(packageName)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteString(deviceId)) { - HILOGE("write packageName failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt32(status)) { - HILOGE("write status failed"); - return ERR_FLATTEN_OBJECT; - } - - if (!data.WriteInt32(reason)) { - HILOGE("write reason failed"); - return ERR_FLATTEN_OBJECT; - } - - int32_t error = remote->SendRequest(ON_AUTH_RESULT, data, reply, option); - if (error != ERR_NONE) { - HILOGE("OnAuthResult SendRequest fail, error: %{public}d", error); - return error; - } - - return ERR_NONE; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/src/device_manager_service.cpp b/services/devicemanagerservice/src/device_manager_service.cpp deleted file mode 100644 index 5da977ab7..000000000 --- a/services/devicemanagerservice/src/device_manager_service.cpp +++ /dev/null @@ -1,291 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_manager_service.h" - -#include "if_system_ability_manager.h" -#include "ipc_skeleton.h" -#include "ipc_types.h" -#include "iservice_registry.h" -#include "string_ex.h" -#include "system_ability_definition.h" - -#include "anonymous_string.h" -#include "device_manager_errno.h" -#include "device_manager_log.h" -#include "softbus_adapter.h" - -#include "hichain_adapter.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - const int32_t THREAD_POOL_TASK_NUM = 1; -} - -IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService); - -const bool REGISTER_RESULT = SystemAbility::MakeAndRegisterAbility(&DeviceManagerService::GetInstance()); - -DeviceManagerService::DeviceManagerService() : SystemAbility(DISTRIBUTED_HARDWARE_DEVICEMANAGER_SA_ID, true) -{ - registerToService_ = false; - state_ = ServiceRunningState::STATE_NOT_START; - hichainBindCallback_ = std::make_shared(); -} - -void DeviceManagerService::OnStart() -{ - HILOGI("DeviceManagerService::OnStart start"); - if (state_ == ServiceRunningState::STATE_RUNNING) { - HILOGD("DeviceManagerService has already started."); - return; - } - if (!Init()) { - HILOGE("failed to init DeviceManagerService"); - return; - } - state_ = ServiceRunningState::STATE_RUNNING; -} - -bool DeviceManagerService::Init() -{ - HILOGI("DeviceManagerService::Init ready to init."); - if (!registerToService_) { - bool ret = Publish(this); - if (!ret) { - HILOGE("DeviceManagerService::Init Publish failed!"); - return false; - } - registerToService_ = true; - } - if (threadPool_.GetThreadsNum() == 0) { - threadPool_.Start(THREAD_POOL_TASK_NUM); - } - RegisterDeviceStateListener(); - return true; -} - -void DeviceManagerService::OnStop() -{ - HILOGI("DeviceManagerService::OnStop ready to stop service."); - state_ = ServiceRunningState::STATE_NOT_START; - registerToService_ = false; -} - -ServiceRunningState DeviceManagerService::QueryServiceState() const -{ - return state_; -} - -void DeviceManagerService::RegisterDeviceStateListener() -{ - auto registerFunc = []() { - SoftbusAdapter::GetInstance().RegSoftBusDeviceStateListener(); - HichainAdapter::GetInstance().Init(); - }; - threadPool_.AddTask(registerFunc); -} - -int32_t DeviceManagerService::RegisterDeviceManagerListener(std::string &packageName, sptr listener) -{ - if (packageName.empty() || listener == nullptr) { - HILOGE("Error: parameter invalid"); - return ERR_NULL_OBJECT; - } - - HILOGI("In, packageName: %{public}s", packageName.c_str()); - std::lock_guard autoLock(listenerLock_); - auto iter = dmListener_.find(packageName); - if (iter != dmListener_.end()) { - HILOGI("RegisterDeviceManagerListener: listener already exists"); - return ERR_NONE; - } - - sptr appRecipient = sptr(new AppDeathRecipient()); - if (!listener->AddDeathRecipient(appRecipient)) { - HILOGE("RegisterDeviceManagerListener: AddDeathRecipient Failed"); - } - dmListener_[packageName] = listener; - appRecipient_[packageName] = appRecipient; - return ERR_NONE; -} - -int32_t DeviceManagerService::UnRegisterDeviceManagerListener(std::string &packageName) -{ - if (packageName.empty()) { - HILOGE("Error: parameter invalid"); - return ERR_NULL_OBJECT; - } - - HILOGI("In, packageName: %{public}s", packageName.c_str()); - std::lock_guard autoLock(listenerLock_); - auto listenerIter = dmListener_.find(packageName); - if (listenerIter == dmListener_.end()) { - HILOGI("UnRegisterDeviceManagerListener: listener not exists"); - return ERR_NONE; - } - - auto recipientIter = appRecipient_.find(packageName); - if (recipientIter == appRecipient_.end()) { - HILOGI("UnRegisterDeviceManagerListener: appRecipient not exists"); - dmListener_.erase(packageName); - return ERR_NONE; - } - - auto listener = listenerIter->second; - auto appRecipient = recipientIter->second; - listener->RemoveDeathRecipient(appRecipient); - appRecipient_.erase(packageName); - dmListener_.erase(packageName); - return ERR_NONE; -} - -int32_t DeviceManagerService::RegisterDeviceStateCallback(std::string &packageName, std::string &extra) -{ - HILOGI("In, packageName: %{public}s", packageName.c_str()); - devStateCallbackParas_[packageName] = extra; - return ERR_NONE; -} - -int32_t DeviceManagerService::UnRegisterDeviceStateCallback(std::string &packageName) -{ - HILOGI("In, packageName: %{public}s", packageName.c_str()); - devStateCallbackParas_.erase(packageName); - return ERR_NONE; -} - -int32_t DeviceManagerService::GetTrustedDeviceList(std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - HILOGI("In, packageName: %{public}s", packageName.c_str()); - return SoftbusAdapter::GetSoftbusTrustDevices(packageName, extra, deviceList); -} - -int32_t DeviceManagerService::StartDeviceDiscovery(std::string &packageName, DmSubscribeInfo &subscribeInfo) -{ - HILOGI("In, packageName: %{public}s, subscribeId %{public}d", packageName.c_str(), - (int32_t)subscribeInfo.subscribeId); - return SoftbusAdapter::GetInstance().StartSoftbusDiscovery(packageName, subscribeInfo); -} - -int32_t DeviceManagerService::StopDeviceDiscovery(std::string &packageName, uint16_t subscribeId) -{ - HILOGI("In, packageName: %{public}s, subscribeId %{public}d", packageName.c_str(), (int32_t)subscribeId); - return SoftbusAdapter::GetInstance().StopSoftbusDiscovery(packageName, subscribeId); -} - -int32_t DeviceManagerService::AuthenticateDevice(std::string &packageName, const DmDeviceInfo &deviceInfo, - std::string &extra) -{ - (void)extra; - - std::string deviceId = deviceInfo.deviceId; - if (SoftbusAdapter::IsDeviceOnLine(deviceId)) { - HILOGI("AuthenticateDevice, deviceId is already in trusted list, return."); - return ERR_DEVICEMANAGER_DEVICE_ALREADY_TRUSTED; - } - - DeviceReqInfo devReqInfo; - devReqInfo.deviceId = deviceId; - HILOGI("AuthenticateDevice In, packageName: %{public}s, deviceId %{public}s", packageName.c_str(), - GetAnonyString(deviceId).c_str()); - int32_t ret = SoftbusAdapter::GetInstance().GetConnectionIpAddr(deviceId, devReqInfo.ipAddr); - if (ret != ERR_OK) { - HILOGE("AuthenticateDevice Error: can not find ip by deviceId."); - return ret; - } - - authCallbackParas_[deviceId] = packageName; - return HichainAdapter::GetInstance().Bind(devReqInfo, hichainBindCallback_, false); -} - -const std::map>& DeviceManagerService::GetDmListener() -{ - return dmListener_; -} - -const sptr DeviceManagerService::GetDmListener(std::string packageName) const -{ - auto iter = dmListener_.find(packageName); - if (iter == dmListener_.end()) { - return nullptr; - } - auto remote = iter->second; - sptr dmListener = iface_cast(remote); - return dmListener; -} - -void AppDeathRecipient::OnRemoteDied(const wptr& remote) -{ - HILOGW("AppDeathRecipient: OnRemoteDied"); - std::map> listeners = DeviceManagerService::GetInstance().GetDmListener(); - std::string packageName; - for (auto iter : listeners) { - if (iter.second == remote.promote()) { - packageName = iter.first; - break; - } - } - - if (packageName.empty()) { - HILOGE("AppDeathRecipient: OnRemoteDied, no packageName matched"); - return; - } - - HILOGI("AppDeathRecipient: OnRemoteDied for %{public}s", packageName.c_str()); - DeviceManagerService::GetInstance().UnRegisterDeviceManagerListener(packageName); -} - - -void HiChainBindCallback::onBindSuccess(std::string deviceId, const char *returnData) -{ - (void)returnData; - HILOGI("onBindSuccess, DM bind succeed, deviceId: %{public}s", GetAnonyString(deviceId).c_str()); - auto res = DeviceManagerService::GetInstance().authCallbackParas_; - auto iter = res.find(deviceId); - if (iter == res.end()) { - HILOGE("onBindSuccess deviceInfo not found by deviceId."); - return; - } - - std::string packageName = iter->second; - sptr dmListener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (dmListener != nullptr) { - dmListener->OnAuthResult(packageName, deviceId, DmBindStatus::STATE_BIND_SUCCESS, ERR_NONE); - } - - int32_t ret = SoftbusAdapter::GetInstance().SoftbusJoinLnn(deviceId); - HILOGI("onBindSuccess, DM bind succeed, joinlnn ret=%{public}d.", ret); -} - -void HiChainBindCallback::onBindFailed(std::string deviceId, int32_t errorCode) -{ - HILOGI("onBindFailed, DM bind failed, deviceId: %{public}s, errorCode: %{public}d", - GetAnonyString(deviceId).c_str(), errorCode); - auto res = DeviceManagerService::GetInstance().authCallbackParas_; - auto iter = res.find(deviceId); - if (iter == res.end()) { - HILOGE("onBindFailed deviceInfo not found by deviceId."); - return; - } - - std::string packageName = iter->second; - sptr dmListener = DeviceManagerService::GetInstance().GetDmListener(packageName); - - dmListener->OnAuthResult(packageName, deviceId, DmBindStatus::STATE_BIND_FAILD, errorCode); -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/src/device_manager_stub.cpp b/services/devicemanagerservice/src/device_manager_stub.cpp deleted file mode 100644 index 9ab1bf5ca..000000000 --- a/services/devicemanagerservice/src/device_manager_stub.cpp +++ /dev/null @@ -1,205 +0,0 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "device_manager_stub.h" - -#include "ipc_skeleton.h" -#include "ipc_types.h" - - -#include "device_manager_log.h" - -using namespace std; - -namespace OHOS { -namespace DistributedHardware { -DeviceManagerStub::DeviceManagerStub() -{ - memberFuncMap_[GET_TRUST_DEVICE_LIST] = &DeviceManagerStub::GetTrustedDeviceListInner; - memberFuncMap_[REGISTER_DEVICE_MANAGER_LISTENER] = &DeviceManagerStub::RegisterDeviceManagerListenerInner; - memberFuncMap_[UNREGISTER_DEVICE_MANAGER_LISTENER] = &DeviceManagerStub::UnRegisterDeviceManagerListenerInner; - memberFuncMap_[REGISTER_DEVICE_STATE_CALLBACK] = &DeviceManagerStub::RegisterDeviceStateCallbackInner; - memberFuncMap_[UNREGISTER_DEVICE_STATE_CALLBACK] = &DeviceManagerStub::UnRegisterDeviceStateCallbackInner; - memberFuncMap_[START_DEVICE_DISCOVER] = &DeviceManagerStub::StartDeviceDiscoveryInner; - memberFuncMap_[STOP_DEVICE_DISCOVER] = &DeviceManagerStub::StopDeviceDiscoveryInner; - memberFuncMap_[AUTHENTICATE_DEVICE] = &DeviceManagerStub::AuthenticateDeviceInner; -} - -DeviceManagerStub::~DeviceManagerStub() -{ - memberFuncMap_.clear(); -} - -int32_t DeviceManagerStub::OnRemoteRequest(uint32_t code, - MessageParcel& data, MessageParcel &reply, MessageOption &option) -{ - HILOGI("code = %{public}d, flags= %{public}d.", code, option.GetFlags()); - auto itFunc = memberFuncMap_.find(code); - if (itFunc != memberFuncMap_.end()) { - auto memberFunc = itFunc->second; - if (memberFunc != nullptr) { - if (!EnforceInterceToken(data)) { - HILOGE("interface token check failed!"); - return ERR_INVALID_STATE; - } - return (this->*memberFunc)(data, reply); - } - } - HILOGW("unsupport code: %{public}d", code); - return IPCObjectStub::OnRemoteRequest(code, data, reply, option); -} - -int32_t DeviceManagerStub::RegisterDeviceManagerListenerInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - sptr listener = data.ReadRemoteObject(); - int32_t result = RegisterDeviceManagerListener(packageName, listener); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::UnRegisterDeviceManagerListenerInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - int32_t result = UnRegisterDeviceManagerListener(packageName); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::RegisterDeviceStateCallbackInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - string extra = data.ReadString(); - HILOGI("packageName:%{public}s, extra:%{public}s", packageName.c_str(), extra.c_str()); - int32_t result = RegisterDeviceStateCallback(packageName, extra); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::UnRegisterDeviceStateCallbackInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - HILOGI("packageName:%{public}s", packageName.c_str()); - int32_t result = UnRegisterDeviceStateCallback(packageName); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::GetTrustedDeviceListInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - string extra = data.ReadString(); - HILOGI("packageName:%{public}s, extra:%{public}s", packageName.c_str(), extra.c_str()); - std::vector devInfos; - int32_t result = GetTrustedDeviceList(packageName, extra, devInfos); - reply.WriteInt32(devInfos.size()); - for (auto &it : devInfos) { - if (!reply.WriteParcelable(&it)) { - return ERR_INVALID_VALUE; - } - } - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -template -int32_t DeviceManagerStub::GetParcelableInfo(MessageParcel &reply, T &parcelableInfo) -{ - std::unique_ptr info(reply.ReadParcelable()); - if (!info) { - HILOGE("readParcelableInfo failed"); - return ERR_INVALID_VALUE; - } - parcelableInfo = *info; - return ERR_NONE; -} - -int32_t DeviceManagerStub::StartDeviceDiscoveryInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - DmSubscribeInfo subscribeInfo; - int32_t result = GetParcelableInfo(data, subscribeInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - HILOGI("packageName:%{public}s, subscribeId: %{public}d", packageName.c_str(), subscribeInfo.subscribeId); - result = StartDeviceDiscovery(packageName, subscribeInfo); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::StopDeviceDiscoveryInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - uint16_t subscribeId = data.ReadInt32(); - HILOGI("packageName:%{public}s, subscribeId: %{public}d", packageName.c_str(), subscribeId); - int32_t result = StopDeviceDiscovery(packageName, subscribeId); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -int32_t DeviceManagerStub::AuthenticateDeviceInner(MessageParcel& data, MessageParcel& reply) -{ - string packageName = data.ReadString(); - DmDeviceInfo deviceInfo; - int32_t result = GetParcelableInfo(data, deviceInfo); - if (result != ERR_NONE) { - HILOGE("GetParcelableInfo fail, result: %{public}d", result); - reply.WriteInt32(result); - return result; - } - - string extra = data.ReadString(); - HILOGI("packageName:%{public}s, extra:%{public}s", packageName.c_str(), extra.c_str()); - result = AuthenticateDevice(packageName, deviceInfo, extra); - if (!reply.WriteInt32(result)) { - HILOGE("write result failed"); - return ERR_INVALID_VALUE; - } - return ERR_NONE; -} - -bool DeviceManagerStub::EnforceInterceToken(MessageParcel& data) -{ - u16string interfaceToken = data.ReadInterfaceToken(); - u16string descriptor = DeviceManagerStub::GetDescriptor(); - return interfaceToken == descriptor; -} -} // namespace DistributedHardware -} // namespace OHOS diff --git a/services/devicemanagerservice/src/message/msg_codec.cpp b/services/devicemanagerservice/src/message/msg_codec.cpp new file mode 100644 index 000000000..e748e7721 --- /dev/null +++ b/services/devicemanagerservice/src/message/msg_codec.cpp @@ -0,0 +1,98 @@ +/* + * 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"); + } + std::shared_ptr msgResponseAuthPtr = std::make_shared(); + if (msgResponseAuthPtr->Decode(jsonObject) == 0) { + return msgResponseAuthPtr; + } + return nullptr; +} +} +} diff --git a/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp b/services/devicemanagerservice/src/message/msg_head.cpp similarity index 47% rename from interfaces/inner_kits/native_cpp/src/dm_device_info.cpp rename to services/devicemanagerservice/src/message/msg_head.cpp index b4a3bfa5e..77cc84416 100644 --- a/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp +++ b/services/devicemanagerservice/src/message/msg_head.cpp @@ -1,50 +1,52 @@ -/* - * Copyright (c) 2021 Huawei Device Co., Ltd. - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "dm_device_info.h" - -namespace OHOS { -namespace DistributedHardware { -bool DmDeviceInfo::ReadFromParcel(Parcel &parcel) -{ - deviceId = parcel.ReadString(); - deviceName = parcel.ReadString(); - deviceTypeId = (DMDeviceType)parcel.ReadUint8(); - return true; -} - -DmDeviceInfo *DmDeviceInfo::Unmarshalling(Parcel &parcel) -{ - DmDeviceInfo *info = new (std::nothrow) DmDeviceInfo(); - if (info == nullptr) { - return nullptr; - } - - if (!info->ReadFromParcel(parcel)) { - delete info; - info = nullptr; - } - return info; -} - -bool DmDeviceInfo::Marshalling(Parcel &parcel) const -{ - parcel.WriteString(deviceId); - parcel.WriteString(deviceName); - parcel.WriteUint8((uint8_t)deviceTypeId); - return true; -} -} // namespace DistributedHardware -} // namespace OHOS +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#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 new file mode 100644 index 000000000..7022d5a58 --- /dev/null +++ b/services/devicemanagerservice/src/message/msg_request_auth.cpp @@ -0,0 +1,375 @@ +/* + * 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 "msg_request_auth.h" +#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" + +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); + char localDeviceId[DEVICE_UUID_LENGTH] = {0}; + GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH); + mDeviceName_ = devReqInfo.deviceName; + mDeviceId_ = localDeviceId; + mToken_ = token; + mHostPkg_ = hostPkgName; + mTargetPkg_ = targetPkgName; + mGroupVisibility_ = groupVisibility; + mAppName_ = jsonObject[APP_NAME_KEY]; + mAppDescription_ = jsonObject[APP_DESCRIPTION_KEY]; + + std::string appIconStr = ""; + GetEncodedAppInfo(imageInfo.GetAppIcon(), imageInfo.GetAppIconLen(), appIconStr); + + std::string appThumbStr = ""; + GetEncodedAppInfo(imageInfo.GetAppThumbnail(), imageInfo.GetAppThumbnailLen(), appThumbStr); + + mAppIcon_ = appIconStr; + mAppThumbnail_ = appThumbStr; + mDeviceType_ = ToHexString(devReqInfo.deviceTypeId); + DMLOG(DM_LOG_INFO, "MsgRequestAuth construction completed"); +} + +int32_t MsgRequestAuth::GetEncodedAppInfo(const uint8_t* dataSrc, size_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; + } + size_t outLen = 0; + char *tmpBuf = (char *)calloc(sizeof(char), THUMB_MAX_LEN); + if (tmpBuf == nullptr) { + DMLOG(DM_LOG_ERROR, "getEncodedAppInfoString: malloc mem error"); + return DEVICEMANAGER_MALLOC_ERROR; + } + EncryptUtils::MbedtlsBase64Encode((uint8_t *)tmpBuf, THUMB_MAX_LEN, &outLen, dataSrc, srcLen); + if (outLen > THUMB_MAX_LEN) { + DMLOG(DM_LOG_ERROR, "encode appIcon 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"); + size_t outLen = 0; + uint8_t *buffer = (uint8_t *)calloc(sizeof(char), THUMB_MAX_LEN); + if (buffer == nullptr) { + DMLOG(DM_LOG_ERROR, "GetDecodeAppInfo: malloc mem error"); + return; + } + + int32_t ret = EncryptUtils::MbedtlsBase64Decode(buffer, THUMB_MAX_LEN, &outLen, + (const uint8_t*)appString.c_str(), strlen(appString.c_str())); + if (ret != 0) { + DMLOG(DM_LOG_ERROR, "BuildAuthenticationInfo: MbedtlsBase64Decode failed"); + 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_; + jsonObj[TAG_APP_ICON] = mAppIcon_; + jsonObj[TAG_THUMBNAIL_SIZE] = mAppThumbnail_.size(); + 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]; + msg->mAppIcon_ = json[TAG_APP_ICON]; + 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 = + (mAppThumbnail_.size() / MSG_MAX_SIZE) + ((mAppThumbnail_.size() % 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] = mAppThumbnail_.size(); + jsonObj[TAG_APP_THUMBNAIL] = StringSub(mAppThumbnail_, idx * MSG_MAX_SIZE, MSG_MAX_SIZE); + 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) { + if (DecodeFirstPackageMsg(json, msg) != DEVICEMANAGER_OK) { + return nullptr; + } + } 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 src = json[TAG_APP_THUMBNAIL]; + if (msg->mAppThumbnail_.size() < src.size() + (idx - 1) * MSG_MAX_SIZE) { + auto inValidMsg = std::make_shared(); + inValidMsg->mMsgSlice_ = FAIL; + return inValidMsg; + } + msg->mAppThumbnail_ += StringSub(src, (idx - 1) * MSG_MAX_SIZE, MSG_MAX_SIZE); + } + msg->mMsgCnt_++; + return msg; +} + +int32_t MsgRequestAuth::DecodeFirstPackageMsg(nlohmann::json &json, std::shared_ptr msg) +{ + 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)) { + DMLOG(DM_LOG_ERROR, "err json string, second time"); + return DEVICEMANAGER_FAILED; + } + 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) { + if (!json.contains(TAG_TARGET) || !json.contains(TAG_HOST)) { + DMLOG(DM_LOG_ERROR, "err json string, third time"); + return DEVICEMANAGER_FAILED; + } + msg->mTargetPkg_ = json[TAG_TARGET]; + msg->mHostPkg_ = json[TAG_HOST]; + } + msg->mAppName_ = json[TAG_APP_NAME]; + msg->mAppDescription_ = json[TAG_APP_DESCRIPTION]; + msg->mAppIcon_ = json[TAG_APP_ICON]; + SetThumbnailSize(json, msg); + SetAuthType(json, msg); + return DEVICEMANAGER_OK; +} + +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)) { + 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, mAppIcon_ 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->mThumbnailSize_ = thumbnailSlice; + DMLOG(DM_LOG_INFO, "mThumbnailSize_ is, %d", msg->mThumbnailSize_); + msg->mAppThumbnail_ = ""; + } +} + +std::string MsgRequestAuth::StringSub(std::string &thumbStr, int32_t start, int32_t length) +{ + int32_t copyLen = start + length > (int32_t)thumbStr.size() ? (thumbStr.size() - start) : length; + std::string ret; + ret.assign(thumbStr, start, copyLen); + return ret; +} + +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 new file mode 100644 index 000000000..e8e375965 --- /dev/null +++ b/services/devicemanagerservice/src/message/msg_response_auth.cpp @@ -0,0 +1,160 @@ +/* + * 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_ = ""; // TODO 从软总线的getLocalDeviceInfo里面获取的json字符串，进行解析，获取到DEVICE_ID字段 要和软总线对齐下 + 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", 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", mGroupId_.c_str()); + DMLOG(DM_LOG_INFO, "decode mGroupName_ is %s", 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_; +} + +long long 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 new file mode 100644 index 000000000..cccb5f197 --- /dev/null +++ b/services/devicemanagerservice/src/message/msg_sync_group.cpp @@ -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. + */ + +#include "msg_sync_group.h" +#include "device_manager_log.h" +#include "constants.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_; +} +} +} \ No newline at end of file diff --git a/services/devicemanagerservice/src/requestauth/auth_manager.cpp b/services/devicemanagerservice/src/requestauth/auth_manager.cpp new file mode 100644 index 000000000..ea490cc8d --- /dev/null +++ b/services/devicemanagerservice/src/requestauth/auth_manager.cpp @@ -0,0 +1,238 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "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" + +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; + 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 (!CanStartNewSession()) { + DMLOG(DM_LOG_ERROR, "previous session not completed yet"); + mPendingReqSessionPtr_->NotifyHostAppAuthResult(ERROR_DUPLICATE_REQUEST); + return; + } + auto curSessionPtr = std::make_shared(hostPkgName, devReqInfo, imageInfo, extrasJson); + 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::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); +} + +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, pinCode is :%s", GetAnonyInt32(pinCode).c_str()); + return PIN_CODE_CHECK_FAILED; + } + + if (pinToken < MIN_PIN_TOKEN || pinToken >= (MIN_PIN_TOKEN + MAX_PIN_TOKEN)) { + DMLOG(DM_LOG_ERROR, "pinToken err, pinToken is :%s", GetAnonyInt32(pinToken).c_str()); + 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_; +} +} +} diff --git a/services/devicemanagerservice/src/requestauth/request_session.cpp b/services/devicemanagerservice/src/requestauth/request_session.cpp new file mode 100644 index 000000000..cd126aa90 --- /dev/null +++ b/services/devicemanagerservice/src/requestauth/request_session.cpp @@ -0,0 +1,256 @@ +/* + * 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 { +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, +}; + +RequestSession::RequestSession(std::string &hostPkgName, const DmDeviceInfo &devReqInfo, + const DmAppImageInfo &imageInfo, std::string &extrasJson) +{ + DMLOG(DM_LOG_INFO, "RequestSession construction started"); + nlohmann::json jsonObject = nlohmann::json::parse(extrasJson, nullptr, false); + if (jsonObject.is_discarded()) { + DMLOG(DM_LOG_ERROR, "extrasJson error"); + } + + if (!jsonObject.contains(TARGET_PKG_NAME_KEY)) { + // TODO 前面检验的地方拦住 + DMLOG(DM_LOG_ERROR, "TARGET_PKG_NAME is not in extrasJson"); + } + std::string targetPkgName = jsonObject[TARGET_PKG_NAME_KEY]; + mSessionType_ = SESSION_TYPE_IS_APP_AUTH; + mDevInfo_ = devReqInfo; + mImageInfo_ = imageInfo; + DMLOG(DM_LOG_ERROR, "imageinfo appIcon:%p:%p", mImageInfo_.GetAppIcon(), imageInfo.GetAppIcon()); + mHostPkgName_ = hostPkgName; + mTargetPkgName = targetPkgName; + mStatus_ = StatusType::STATUS_INIT; + 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) { + // TODO 取消认证的流程 + return; + } +} + +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::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) { + std::string deviceId = mDevInfo_.deviceId; + if (StartFaService() != SUCCESS) { + DMLOG(DM_LOG_INFO, "RequestSession::StartFaService failed"); + return; + } + DMLOG(DM_LOG_INFO, "RequestSession::StartFaService success"); + int32_t status = (errorCode == 0) ? 0 : -1; + IpcServerListenerAdapter::GetInstance().OnAuthResult(mHostPkgName_, deviceId, mPinToken_, status, errorCode); + DMLOG(DM_LOG_INFO, "notify host result, errorcode: %d", errorCode); + } else { + DMLOG(DM_LOG_ERROR, "wrong session type: %d", errorCode); + } +} +} +} diff --git a/services/devicemanagerservice/src/requestauth/response_session.cpp b/services/devicemanagerservice/src/requestauth/response_session.cpp new file mode 100644 index 000000000..2be2b9888 --- /dev/null +++ b/services/devicemanagerservice/src/requestauth/response_session.cpp @@ -0,0 +1,294 @@ +/* + * 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 RECEIVE_MESSAGE_TIMEOUT = 3; // 3 second +// const int32_t WAIT_NEXT_PACKAGE_TIMEOUT = 3; // 3 second +// const int32_t WAIT_ENTER_PINCODE_TIMEOUT = 3; // 3 second +} + +#define PINCODE_LEN 6 + +ResponseSession::ResponseSession() { + mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; + sem_init(&mSem_, 0, 0); + //need to update +} + +long long ResponseSession::GetRequestId(void) +{ + 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 ResponseSession::OnReceiveMsg(long long channelId, std::string &message) +{ + // TODO 取消收包定时器 + int32_t ret = DecodeReqMsg(message); + if (ret != SUCCESS) { + // TODO 起收包定时器 + return; + } + + if (mMsgRequestAuthPtr_->GetMsgCnt() != mMsgRequestAuthPtr_->GetMsgSlice()) { + // TODO 解包成功，但是还有分片报文没有收完，需要继续等待下一包到来。此处，起一个3S的超时定时器。 + return; + } + + // 正常业务逻辑 + mReqDeviceId_ = mMsgRequestAuthPtr_->GetRequestDeviceId(); + mChannelId_ = channelId; + mPincode_ = GeneratePincode(); + if (StartFaService() != SUCCESS) { + // 拉起界面失败，直接回复拒绝，清理session状态 + OnUserReject(ERROR_FA_START_FAIL); + return; + } + + mSessionStatus_ = ResponseSessionStatus::SESSION_WAITTING_USER_CONFIRM; + // TODO 设置超时定时器，等待用户输入PIN码 +} + +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) +{ + authParam.direction = (int32_t)DmAbilityManager::GetInstance().GetAbilityRole(); + 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) { + uint8_t *appIcon = nullptr; + int32_t appIconLen = 0; + uint8_t *appThumbnail = nullptr; + int32_t appThumbnailLen = 0; + mMsgRequestAuthPtr_->GetDecodeAppInfo(mMsgRequestAuthPtr_->mAppIcon_, &appIcon, appIconLen); + mMsgRequestAuthPtr_->GetDecodeAppInfo(mMsgRequestAuthPtr_->mAppThumbnail_, &appThumbnail, appThumbnailLen); + authParam.imageinfo.Reset(appIcon, appIconLen, appThumbnail, appThumbnailLen); + if (appIcon != nullptr) { + free(appIcon); + appIcon = nullptr; + } + if (appThumbnail != nullptr) { + free(appThumbnail); + appThumbnail = nullptr; + } + } +} + +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 %d, requestId %d, groupId %s", + requestId, mRequestId_, groupId.c_str()); + SendResponseMessage(SESSION_REPLY_CREAT_GROUP_FAILED); + CancelDisplay(); + mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; // TODO: 是否加一个统一的Release流程, 统一进行状态清理 + 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; +} + +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()/2); + 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"); + mRequestId_ = -1; + mGroupId_ = ""; + mGroupName_ = ""; + mReqDeviceId_ = ""; + mMsgRequestAuthPtr_ = nullptr; + mChannelId_ = -1; + mPincode_ = -1; + mSessionStatus_ = ResponseSessionStatus::SESSION_INIT; +} + +void ResponseSession::CancelDisplay() +{ + nlohmann::json jsonObj; + jsonObj[CANCEL_DISPLAY_KEY] = 1; + std::string jsonObjTmp = jsonObj.dump(); + IpcServerListenerAdapter::GetInstance().OnFaCall(mMsgRequestAuthPtr_->mTargetPkg_, jsonObjTmp); +} + +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 index 17f72e881..3103b6a47 100644 --- a/services/devicemanagerservice/src/softbus/softbus_adapter.cpp +++ b/services/devicemanagerservice/src/softbus/softbus_adapter.cpp @@ -16,393 +16,327 @@ #include "softbus_adapter.h" #include -#include #include #include +#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 "device_manager_service.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 std::string DEVICE_MANAGER_PACKAGE_NAME = "com.huawei.devicemanager"; const int32_t CHECK_INTERVAL = 100000; // 100ms const int32_t SUBSCRIBE_ID_PREFIX_LEN = 16; const int32_t SUBSCRIBE_ID_MASK = 0x0000FFFF; const int32_t DISCOVER_DEVICEINFO_MAX_SIZE = 20; } +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; + } + } +} -IMPLEMENT_SINGLE_INSTANCE(SoftbusAdapter); void SoftbusAdapter::OnSoftBusDeviceOnline(NodeBasicInfo *info) { if (info == nullptr) { - HILOGE("SoftbusAdapter::OnSoftBusDeviceOnline NodeBasicInfo is nullptr"); + DMLOG(DM_LOG_ERROR, "OnSoftBusDeviceOnline NodeBasicInfo is nullptr"); return; } + DmDeviceInfo dmDeviceInfo; - std::string networkId = info->networkId; - HILOGI("device online, networkId: %{public}s", GetAnonyString(networkId).c_str()); - OnSoftBusDeviceStateChange(DmDeviceState::DEVICE_STATE_ONLINE, info); + 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 != ERR_OK) { - HILOGE("GetNodeKeyInfo failed"); + if (ret != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "GetNodeKeyInfo failed"); return; } std::string deviceId = (char *)udid; - SoftbusAdapter::GetInstance().RemoveDiscoverDeviceInfo(deviceId); + DMLOG(DM_LOG_INFO, "device online, deviceId: %s", GetAnonyString(deviceId).c_str()); + RemoveDiscoverDeviceInfo(deviceId); } void SoftbusAdapter::OnSoftbusDeviceOffline(NodeBasicInfo *info) { if (info == nullptr) { - HILOGE("SoftbusAdapter::OnSoftbusDeviceOffline NodeBasicInfo is nullptr"); + DMLOG(DM_LOG_ERROR, "OnSoftbusDeviceOffline NodeBasicInfo is nullptr"); return; } + DmDeviceInfo dmDeviceInfo; - std::string networkId = info->networkId; - HILOGI("device offline, networkId: %{public}s", GetAnonyString(networkId).c_str()); - OnSoftBusDeviceStateChange(DmDeviceState::DEVICE_STATE_OFFLINE, info); -} - -void SoftbusAdapter::OnSoftBusDeviceStateChange(DmDeviceState state, NodeBasicInfo *info) -{ - DmDeviceInfo deviceInfo; - deviceInfo.deviceId = info->networkId; - deviceInfo.deviceName = info->deviceName; - deviceInfo.deviceTypeId = (DMDeviceType)info->deviceTypeId; - - std::map> listeners = DeviceManagerService::GetInstance().GetDmListener(); - for (auto iter : listeners) { - auto packageName = iter.first; - auto remote = iter.second; - sptr dmListener = iface_cast(remote); - if (state == DmDeviceState::DEVICE_STATE_ONLINE) { - HILOGI("SoftbusAdapter::OnSoftBusDeviceStateChange listenr handle device online."); - dmListener->OnDeviceOnline(packageName, deviceInfo); - } else { - HILOGI("SoftbusAdapter::OnSoftBusDeviceStateChange listenr handle device offline."); - dmListener->OnDeviceOffline(packageName, deviceInfo); - } - } + NodeBasicInfoCopyToDmDevice(dmDeviceInfo, *info); + IpcServerListenerAdapter::GetInstance().OnDeviceStateChange(DmDeviceState::DEVICE_STATE_OFFLINE, dmDeviceInfo); } void SoftbusAdapter::OnSoftbusDeviceInfoChanged(NodeBasicInfoType type, NodeBasicInfo *info) { - HILOGI("SoftbusAdapter::OnSoftbusDeviceInfoChanged."); + 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) { - HILOGE("deviceinfo is null"); + DMLOG(DM_LOG_ERROR, "deviceinfo is null"); return; } std::string deviceId = device->devId; - HILOGI("SoftbusAdapter::OnSoftbusDeviceFound device %{public}s found.", GetAnonyString(deviceId).c_str()); + DMLOG(DM_LOG_INFO, "SoftbusAdapter::OnSoftbusDeviceFound device %s found.", GetAnonyString(deviceId).c_str()); if (IsDeviceOnLine(deviceId)) { return; } - SoftbusAdapter::GetInstance().SaveDiscoverDeviceInfo(device); - DmDeviceInfo deviceInfo; - deviceInfo.deviceId = deviceId; - deviceInfo.deviceName = device->devName; - deviceInfo.deviceTypeId = (DMDeviceType)device->devType; - - // currently, only care ddmpCapability - if (!((device->capabilityBitmap[0] >> DDMP_CAPABILITY_BITMAP) & 0x1)) { - HILOGE("capBitmap Invalid, not contain ddmpCap"); - return; - } - - auto subscribeInfos = SoftbusAdapter::GetInstance().GetsubscribeInfos(); - for (auto iter = subscribeInfos.begin(); iter != subscribeInfos.end(); iter++) { + 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(); - HILOGI("subscribe info capability:%{public}s.", info->info.capability); - if (strcmp(DM_CAPABILITY_DDMP.c_str(), info->info.capability) != 0) { - HILOGE("subscribe info capability invalid."); + 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."); } - std::string packageName = iter->first; - sptr listener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (listener == nullptr) { - HILOGI("cannot get listener for package:%{public}s.", packageName.c_str()); - continue; - } - uint16_t originId = (uint16_t)(((uint32_t)info->info.subscribeId) & SUBSCRIBE_ID_MASK); - HILOGI("call OnDeviceFound for %{public}s, originId %{public}d, deviceId %{public}s", - packageName.c_str(), originId, GetAnonyString(deviceInfo.deviceId).c_str()); - listener->OnDeviceFound(packageName, originId, deviceInfo); - } - } -} + std::string strPkgName = iter->first; + DmDeviceInfo dmDeviceInfo; -void SoftbusAdapter::OnSoftbusDiscoverFailed(int subscribeId, DiscoveryFailReason failReason) -{ - HILOGI("In, subscribeId %{public}d, failReason %{public}d", subscribeId, (int32_t)failReason); - std::string packageName; - if (!SoftbusAdapter::GetInstance().GetPackageNameBySubscribeId(subscribeId, packageName)) { - HILOGE("OnSoftbusDiscoverFailed: packageName not found"); - return; - } - sptr listener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (listener == nullptr) { - HILOGE("OnSoftbusDiscoverFailed: listener not found for packageName %{public}s", packageName.c_str()); - return; + DeviceInfoCopyToDmDevice(dmDeviceInfo, *device); + IpcServerListenerAdapter::GetInstance().OnDeviceFound(strPkgName, originId, dmDeviceInfo); + } } - uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); - listener->OnDiscoverFailed(packageName, originId, (int32_t)failReason); } -void SoftbusAdapter::OnSoftbusDiscoverySuccess(int subscribeId) +bool SoftbusAdapter::GetpkgNameBySubscribeId(int32_t adapterId, std::string &pkgName) { - HILOGI("In, subscribeId %{public}d", subscribeId); - std::string packageName; - if (!SoftbusAdapter::GetInstance().GetPackageNameBySubscribeId(subscribeId, packageName)) { - HILOGE("OnSoftbusDiscoverySuccess: packageName not found"); - return; - } - sptr listener = DeviceManagerService::GetInstance().GetDmListener(packageName); - if (listener == nullptr) { - HILOGE("OnSoftbusDiscoverySuccess: listener not found for packageName %{public}s", packageName.c_str()); - return; + 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; + } + } } - uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); - listener->OnDiscoverySuccess(packageName, originId); + return false; } -void SoftbusAdapter::OnSoftbusJoinLNNResult(ConnectionAddr *addr, const char *networkId, int32_t retCode) +void SoftbusAdapter::OnSoftbusDiscoverFailed(int32_t subscribeId, DiscoveryFailReason failReason) { - (void)addr; - if (retCode != 0) { - HILOGE("OnSoftbusJoinLNNResult: failed, retCode %{public}d", retCode); - return; - } - - if (networkId == nullptr) { - HILOGE("OnSoftbusJoinLNNResult: success, but networkId is nullptr"); + 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; } - std::string netIdStr = networkId; - HILOGI("OnSoftbusJoinLNNResult: success, networkId %{public}s, retCode %{public}d", - GetAnonyString(netIdStr).c_str(), retCode); + uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); + IpcServerListenerAdapter::GetInstance().OnDiscoverFailed(pkgName, originId, failReason); } -void SoftbusAdapter::OnSoftbusLeaveLNNResult(const char *networkId, int32_t retCode) +void SoftbusAdapter::OnSoftbusDiscoverySuccess(int32_t subscribeId) { - if (retCode != 0) { - HILOGE("OnSoftbusLeaveLNNResult: failed, retCode %{public}d", retCode); - return; - } - - if (networkId == nullptr) { - HILOGE("OnSoftbusLeaveLNNResult: success, but networkId is nullptr"); + DMLOG(DM_LOG_INFO, "In, subscribeId %d", subscribeId); + std::string pkgName; + if (!GetpkgNameBySubscribeId(subscribeId, pkgName)) { + DMLOG(DM_LOG_ERROR, "OnSoftbusDiscoverySuccess: pkgName not found"); return; } - - std::string netIdStr = networkId; - HILOGI("OnSoftbusLeaveLNNResult: success, networkId %{public}s, retCode %{public}d", - GetAnonyString(netIdStr).c_str(), retCode); -} - -int32_t SoftbusAdapter::GetSoftbusTrustDevices(const std::string &packageName, std::string &extra, - std::vector &deviceList) -{ - // extra not used yet - (void) packageName; - (void) extra; - - HILOGI("GetSoftbusTrustDevices start, packageName: %{public}s", packageName.c_str()); - NodeBasicInfo *info = nullptr; - int32_t infoNum = 0; - int32_t ret = GetAllNodeDeviceInfo(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &info, &infoNum); - if (ret != 0) { - HILOGE("GetAllNodeDeviceInfo failed with ret %{public}d", ret); - return ret; - } - - for (int32_t i = 0; i < infoNum; i++) { - NodeBasicInfo *nodeBasicInfo = info + i; - if (nodeBasicInfo == nullptr) { - HILOGE("nodeBasicInfo is empty for index %{public}d, infoNum %{public}d.", i, infoNum); - continue; - } - DmDeviceInfo deviceInfo; - deviceInfo.deviceId = nodeBasicInfo->networkId; - deviceInfo.deviceName = nodeBasicInfo->deviceName; - deviceInfo.deviceTypeId = (DMDeviceType)nodeBasicInfo->deviceTypeId; - deviceList.push_back(deviceInfo); - } - FreeNodeInfo(info); - HILOGI("success, packageName: %{public}s, deviceCount %{public}d", packageName.c_str(), deviceList.size()); - return ERR_OK; + uint16_t originId = (uint16_t)(((uint32_t)subscribeId) & SUBSCRIBE_ID_MASK); + IpcServerListenerAdapter::GetInstance().OnDiscoverySuccess(pkgName, originId); } -bool SoftbusAdapter::IsDeviceOnLine(std::string &deviceId) +bool SoftbusAdapter::GetsubscribeIdAdapter(std::string &pkgName, int16_t originId, int32_t &adapterId) { - std::vector deviceList; - std::string extra = ""; - if (GetSoftbusTrustDevices(DEVICE_MANAGER_PACKAGE_NAME, extra, deviceList) != ERR_OK) { - HILOGE("SoftbusAdapter::IsDeviceOnLine GetSoftbusTrustDevices failed"); + 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; } - for (auto iter = deviceList.begin(); iter != deviceList.end(); ++iter) { - std::string& networkId = iter->deviceId; - if (networkId == deviceId) { - HILOGI("SoftbusAdapter::IsDeviceOnLine devccie %{public}s online", GetAnonyString(deviceId).c_str()); - return true; - } - - uint8_t udid[UDID_BUF_LEN] = {0}; - int32_t ret = GetNodeKeyInfo(DEVICE_MANAGER_PACKAGE_NAME.c_str(), networkId.c_str(), - NodeDeivceInfoKey::NODE_KEY_UDID, udid, sizeof(udid)); - if (ret != ERR_OK) { - HILOGE("SoftbusAdapter::IsDeviceOnLine GetNodeKeyInfo failed"); - return false; - } - - if (strcmp((char *)udid, deviceId.c_str()) == 0) { - HILOGI("SoftbusAdapter::IsDeviceOnLine devccie %{public}s online", GetAnonyString(deviceId).c_str()); + 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; } -void SoftbusAdapter::RegSoftBusDeviceStateListener() +int32_t SoftbusAdapter::Init() { int32_t ret; int32_t retryTimes = 0; do { - ret = RegNodeDeviceStateCb(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &softbusNodeStateCb); - if (ret != ERR_OK) { + ret = RegNodeDeviceStateCb(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &softbusNodeStateCb_); + if (ret != DEVICEMANAGER_OK) { ++retryTimes; - HILOGE("RegNodeDeviceStateCb failed with ret %{public}d, retryTimes %{public}d", ret, retryTimes); + DMLOG(DM_LOG_ERROR, "RegNodeDeviceStateCb failed with ret %d, retryTimes %d", ret, retryTimes); usleep(CHECK_INTERVAL); } - } while (ret != ERR_OK); - HILOGI("RegNodeDeviceStateCb success."); + } 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::StartSoftbusDiscovery(std::string &packageName, DmSubscribeInfo &info) +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(packageName) == subscribeInfos_.end()) { - subscribeInfos_[packageName] = {}; + if (subscribeInfos_.find(pkgName) == subscribeInfos_.end()) { + subscribeInfos_[pkgName] = {}; } - auto iter = subscribeInfos_.find(packageName); + 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) { + 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->subscribeIdOrigin = info->subscribeId; subinfo->subscribeIdPrefix = subscribeIdPrefix++; - subinfo->info.subscribeId = (subinfo->subscribeIdPrefix << SUBSCRIBE_ID_PREFIX_LEN) | info.subscribeId; - subinfo->info.mode = (DiscoverMode)info.mode; - subinfo->info.medium = (ExchanageMedium)info.medium; - subinfo->info.freq = (ExchangeFreq)info.freq; - subinfo->info.isSameAccount = info.isSameAccount; - subinfo->info.isWakeRemote = info.isWakeRemote; - subinfo->info.capability = info.capability.c_str(); - subinfo->info.capabilityData = nullptr; - subinfo->info.dataLen = 0; + subinfo->info = *info; + subinfo->info.subscribeId = (subinfo->subscribeIdPrefix << SUBSCRIBE_ID_PREFIX_LEN) | info->subscribeId; } - if (vectorIter == subinfoVector.end()) { subinfoVector.push_back(subinfo); } - - HILOGI("StartDiscovery, packageName: %{public}s, subscribeId %{public}d, prefix %{public}d, origin %{public}d", - packageName.c_str(), subinfo->info.subscribeId, subinfo->subscribeIdPrefix, subinfo->subscribeIdOrigin); - int ret = StartDiscovery(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &subinfo->info, &softbusDiscoverCallback); - if (ret != ERR_OK) { - HILOGE("StartDiscovery failed with ret %{public}d.", ret); - } - return ret; -} - -bool SoftbusAdapter::GetPackageNameBySubscribeId(int32_t adapterId, std::string &packageName) -{ - for (auto iter = subscribeInfos_.begin(); iter != subscribeInfos_.end(); ++iter) { - std::vector> &subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - for (; vectorIter != subinfoVector.end(); ++vectorIter) { - if (vectorIter->get()->info.subscribeId == adapterId) { - packageName = iter->first; - return true; - } - } - } - return false; -} - -bool SoftbusAdapter::GetsubscribeIdAdapter(std::string packageName, int16_t originId, int32_t &adapterId) -{ - HILOGI("GetsubscribeIdAdapter in, packageName: %{public}s, originId:%{public}d", packageName.c_str(), - (int32_t)originId); - auto iter = subscribeInfos_.find(packageName); - if (iter == subscribeInfos_.end()) { - HILOGE("subscribeInfo not find for packageName: %{public}s", packageName.c_str()); - return false; - } - - std::vector> &subinfoVector = iter->second; - auto vectorIter = subinfoVector.begin(); - for (; vectorIter != subinfoVector.end(); ++vectorIter) { - if (vectorIter->get()->subscribeIdOrigin == originId) { - HILOGE("find adapterId:%{public}d for packageName: %{public}s, originId:%{public}d", - vectorIter->get()->info.subscribeId, packageName.c_str(), (int32_t)originId); - adapterId = vectorIter->get()->info.subscribeId; - return true; - } + 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; } - HILOGE("subscribe not find. packageName: %{public}s, originId:%{public}d", packageName.c_str(), (int32_t)originId); - return false; + return DEVICEMANAGER_OK; } -int32_t SoftbusAdapter::StopSoftbusDiscovery(std::string &packageName, uint16_t subscribeId) +int32_t SoftbusAdapter::StopDiscovery(std::string &pkgName, uint16_t subscribeId) { int32_t subscribeIdAdapter = -1; - if (!GetsubscribeIdAdapter(packageName, subscribeId, subscribeIdAdapter)) { - HILOGE("StopDiscovery failed, subscribeId not match"); - return ERR_INVALID_OPERATION; + if (!GetsubscribeIdAdapter(pkgName, subscribeId, subscribeIdAdapter)) { + DMLOG(DM_LOG_ERROR, "StopDiscovery failed, subscribeId not match"); + return DEVICEMANAGER_FAILED; } - HILOGI("StopDiscovery begin, packageName: %{public}s, subscribeId:%{public}d, subscribeIdAdapter:%{public}d", - packageName.c_str(), (int32_t)subscribeId, subscribeIdAdapter); - int ret = StopDiscovery(DEVICE_MANAGER_PACKAGE_NAME.c_str(), subscribeIdAdapter); - if (ret != ERR_OK) { - HILOGE("StopDiscovery failed with ret %{public}d", ret); + 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(packageName); + auto iter = subscribeInfos_.find(pkgName); auto subinfoVector = iter->second; auto vectorIter = subinfoVector.begin(); while (vectorIter != subinfoVector.end()) { @@ -414,57 +348,65 @@ int32_t SoftbusAdapter::StopSoftbusDiscovery(std::string &packageName, uint16_t } } if (subinfoVector.empty()) { - subscribeInfos_.erase(packageName); + subscribeInfos_.erase(pkgName); } - HILOGI("SoftbusAdapter::StopSoftbusDiscovery completed, packageName: %{public}s", packageName.c_str()); - return ERR_OK; + DMLOG(DM_LOG_INFO, "DM_StopSoftbusDiscovery completed, pkgName: %s", pkgName.c_str()); + return DEVICEMANAGER_OK; } -int32_t SoftbusAdapter::SoftbusJoinLnn(std::string devId) +bool SoftbusAdapter::IsDeviceOnLine(std::string &deviceId) { - auto iter = discoverDeviceInfoMap_.find(devId); - if (iter == discoverDeviceInfoMap_.end()) { - HILOGE("SoftbusAdapter::SoftbusJoinLnn deviceInfo not found: %{public}s", GetAnonyString(devId).c_str()); - return ERR_INVALID_OPERATION; - } + NodeBasicInfo *info = nullptr; + int32_t infoNum = 0; - DeviceInfo *deviceInfo = iter->second.get(); - if (deviceInfo->addrNum <= 0 || deviceInfo->addrNum >= CONNECTION_ADDR_MAX) { - HILOGE("deviceInfo addrNum not valid, addrNum %{public}d", deviceInfo->addrNum); - return ERR_DEVICEMANAGER_OPERATION_FAILED; + if (GetTrustDevices(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &info, &infoNum) != DEVICEMANAGER_OK) { + DMLOG(DM_LOG_ERROR, "DM_IsDeviceOnLine DM_GetSoftbusTrustDevices failed"); + return false; } - for (unsigned int i = 0; i < deviceInfo->addrNum; i++) { - // currently, only support CONNECT_ADDR_WLAN - if (deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_WLAN && - deviceInfo->addr[i].type != ConnectionAddrType::CONNECTION_ADDR_ETH) { + 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; + } - HILOGI("SoftbusAdapter::SoftbusJoinLnn call softbus JoinLNN."); - return JoinLNN(DEVICE_MANAGER_PACKAGE_NAME.c_str(), &deviceInfo->addr[i], OnSoftbusJoinLNNResult); + if (strcmp((char *)udid, deviceId.c_str()) == 0) { + DMLOG(DM_LOG_INFO, "DM_IsDeviceOnLine devccie %s online", GetAnonyString(deviceId).c_str()); + bDeviceOnline = true; + break; + } } - - return ERR_DEVICEMANAGER_OPERATION_FAILED; -} - -int32_t SoftbusAdapter::SoftbusLeaveLnn(std::string networkId) -{ - return LeaveLNN(networkId.c_str(), OnSoftbusLeaveLNNResult); + FreeNodeInfo(info); + return bDeviceOnline; } int32_t SoftbusAdapter::GetConnectionIpAddr(std::string deviceId, std::string &ipAddr) { auto iter = discoverDeviceInfoMap_.find(deviceId); if (iter == discoverDeviceInfoMap_.end()) { - HILOGE("deviceInfo not found by deviceId %{public}s", GetAnonyString(deviceId).c_str()); - return ERR_INVALID_OPERATION; + 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) { - HILOGE("deviceInfo addrNum not valid, addrNum %{public}d", deviceInfo->addrNum); - return ERR_DEVICEMANAGER_OPERATION_FAILED; + DMLOG(DM_LOG_ERROR, "deviceInfo addrNum not valid, addrNum %d", deviceInfo->addrNum); + return DEVICEMANAGER_FAILED; } for (unsigned int i = 0; i < deviceInfo->addrNum; ++i) { @@ -474,51 +416,98 @@ int32_t SoftbusAdapter::GetConnectionIpAddr(std::string deviceId, std::string &i continue; } ipAddr = deviceInfo->addr[i].info.ip.ip; - HILOGI("SoftbusAdapter::GetConnectionIpAddr get ip ok."); - return ERR_OK; + DMLOG(DM_LOG_INFO, "DM_GetConnectionIpAddr get ip ok."); + return DEVICEMANAGER_OK; } - HILOGE("failed to get ipAddr for deviceId %{public}s", GetAnonyString(deviceId).c_str()); - return ERR_DEVICEMANAGER_OPERATION_FAILED; + DMLOG(DM_LOG_ERROR, "failed to get ipAddr for deviceId %s", GetAnonyString(deviceId).c_str()); + return DEVICEMANAGER_FAILED; } -const std::map>>& SoftbusAdapter::GetsubscribeInfos() +// eth >> wlan >> ble >> br +ConnectionAddr *SoftbusAdapter::GetConnectAddrByType(DeviceInfo *deviceInfo, ConnectionAddrType type) { - return subscribeInfos_; + if (deviceInfo == nullptr) { + return nullptr; + } + for (unsigned int i = 0; i < deviceInfo->addrNum; ++i) { + if (deviceInfo->addr[i].type == type) { + return &deviceInfo->addr[i]; + } + } + return nullptr; } -void SoftbusAdapter::SaveDiscoverDeviceInfo(const DeviceInfo *deviceInfo) +ConnectionAddr *SoftbusAdapter::GetConnectAddr(std::string deviceId) { - std::shared_ptr info = std::make_shared(); - DeviceInfo *infoPtr = info.get(); - if (memcpy_s(infoPtr, sizeof(DeviceInfo), deviceInfo, sizeof(DeviceInfo)) != 0) { - HILOGE("SoftbusAdapter::SaveDiscoverDeviceInfo failed."); - return; + 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; } - std::string deviceId = deviceInfo->devId; - discoverDeviceInfoMap_[deviceId] = info; - discoverDeviceInfoVector_.push_back(info); + 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; + } - // 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); + 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::RemoveDiscoverDeviceInfo(const std::string deviceId) +void SoftbusAdapter::NodeBasicInfoCopyToDmDevice(DmDeviceInfo &dmDeviceInfo, NodeBasicInfo &nodeBasicInfo) { - 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)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); + (void)memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), nodeBasicInfo.networkId, + std::min(sizeof(dmDeviceInfo.deviceId), sizeof(nodeBasicInfo.networkId))); + (void)memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), nodeBasicInfo.deviceName, + std::min(sizeof(dmDeviceInfo.deviceName), sizeof(nodeBasicInfo.deviceName))); + dmDeviceInfo.deviceTypeId = (DMDeviceType)nodeBasicInfo.deviceTypeId; +} + +void SoftbusAdapter::DeviceInfoCopyToDmDevice(DmDeviceInfo &dmDeviceInfo, const DeviceInfo &deviceInfo) +{ + (void)memset_s(&dmDeviceInfo, sizeof(DmDeviceInfo), 0, sizeof(DmDeviceInfo)); + (void)memcpy_s(dmDeviceInfo.deviceId, sizeof(dmDeviceInfo.deviceId), deviceInfo.devId, + std::min(sizeof(dmDeviceInfo.deviceId), sizeof(deviceInfo.devId))); + (void)memcpy_s(dmDeviceInfo.deviceName, sizeof(dmDeviceInfo.deviceName), deviceInfo.devName, + std::min(sizeof(dmDeviceInfo.deviceName), sizeof(deviceInfo.devName))); + 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 +} // 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 new file mode 100644 index 000000000..8a74c2e48 --- /dev/null +++ b/services/devicemanagerservice/src/softbus/softbus_session.cpp @@ -0,0 +1,230 @@ +/* + * 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) { + DMLOG(DM_LOG_INFO, "GetPeerDeviceId success for session:%d, peerDeviceId:%s", sessionId, + GetAnonyString(peerDeviceId).c_str()); + peerDevId = peerDeviceId; + return; + } + + DMLOG(DM_LOG_ERROR, "GetPeerDeviceId failed for session:%d", sessionId); + peerDevId = ""; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/services/devicemanagerservice/src/util/anonymous_string.cpp b/services/devicemanagerservice/src/util/anonymous_string.cpp deleted file mode 100644 index 69ed71a76..000000000 --- a/services/devicemanagerservice/src/util/anonymous_string.cpp +++ /dev/null @@ -1,71 +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 "anonymous_string.h" - -#include "securec.h" - -namespace OHOS { -namespace DistributedHardware { -namespace { - const int INT32_STRING_LENGTH = 40; - const int INT32_SHORT_ID_LENGTH = 20; - const int INT32_PLAINTEXT_LENGTH = 4; - const int INT32_MIN_ID_LENGTH = 3; -} - -std::string GetAnonyString(const std::string &value) -{ - std::string res; - std::string tmpStr("******"); - int32_t strLen = value.length(); - if (strLen < INT32_MIN_ID_LENGTH) { - return tmpStr; - } - - if (strLen <= INT32_SHORT_ID_LENGTH) { - res += value[0]; - res += tmpStr; - res += value[strLen - 1]; - } else { - res.append(value, 0, INT32_PLAINTEXT_LENGTH); - res += tmpStr; - res.append(value, strLen - INT32_PLAINTEXT_LENGTH, INT32_PLAINTEXT_LENGTH); - } - - return res; -} - -std::string GetAnonyInt32(const int32_t value) -{ - char tempBuffer[INT32_STRING_LENGTH] = ""; - int32_t secRet = sprintf_s(tempBuffer, INT32_STRING_LENGTH, "%d", value); - if (secRet <= 0) { - std::string nullString(""); - return nullString; - } - int32_t length = strlen(tempBuffer); - for (int32_t i = 1; i < length - 1; i++) { - tempBuffer[i] = '*'; - } - if (length == 0x01) { - tempBuffer[0] = '*'; - } - - std::string tempSting(tempBuffer); - return tempSting; -} -} -} \ No newline at end of file -- Gitee From 777ef0acb5540f7745b9e165c5c74029c57ced53 Mon Sep 17 00:00:00 2001 From: yuqianyuan Date: Sat, 11 Sep 2021 16:19:50 +0800 Subject: [PATCH 2/2] add files Signed-off-by: yuqianyuan --- interfaces/kits/js/BUILD.gn | 6 +-- services/devicemanagerservice/BUILD.gn | 50 +++++++++---------- .../src/message/msg_codec.cpp | 1 + .../src/requestauth/response_session.cpp | 2 +- 4 files changed, 29 insertions(+), 30 deletions(-) diff --git a/interfaces/kits/js/BUILD.gn b/interfaces/kits/js/BUILD.gn index efec0aaa3..5c6777207 100644 --- a/interfaces/kits/js/BUILD.gn +++ b/interfaces/kits/js/BUILD.gn @@ -30,15 +30,15 @@ ohos_shared_library("devicemanager") { ] sources = [ - "src/native_devicemanager_js.cpp", "src/dm_native_event.cpp", - ] + "src/native_devicemanager_js.cpp", + ] deps = [ "${utils_path}:devicemanagerutils", - "//utils/native/base:utils", "//foundation/ace/napi:ace_napi", "//foundation/distributedhardware/devicemanager/interfaces/inner_kits/native_cpp:devicemanagersdk", + "//utils/native/base:utils", ] cflags_cc = build_flags diff --git a/services/devicemanagerservice/BUILD.gn b/services/devicemanagerservice/BUILD.gn index 0e6a16139..a4aeac7b8 100644 --- a/services/devicemanagerservice/BUILD.gn +++ b/services/devicemanagerservice/BUILD.gn @@ -40,10 +40,10 @@ if (defined(ohos_lite)) { "${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", + "//base/startup/syspara_lite/interfaces/innerkits/native/syspara/include", "//utils/native/lite/include", "//utils/system/safwk/native/include", "//third_party/json/include", @@ -55,21 +55,19 @@ if (defined(ohos_lite)) { "//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" + "//foundation/distributedschedule/samgr_lite/interfaces/kits/samgr", ] sources = [ "src/ability/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/ipc/ipc_server_adapter.cpp", - "src/ipc/ipc_server_listener_adapter.cpp", - "src/softbus/softbus_adapter.cpp", - "src/softbus/softbus_session.cpp", - "src/auth/hichain_connector.cpp", "src/message/msg_codec.cpp", "src/message/msg_head.cpp", "src/message/msg_request_auth.cpp", @@ -78,9 +76,11 @@ if (defined(ohos_lite)) { "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", ] - defines = [ + defines = [ "LITE_DEVICE", "HI_LOG_ENABLE", "DH_LOG_TAG=\"devicemanagerservice\"", @@ -91,19 +91,18 @@ if (defined(ohos_lite)) { deps = [ "${utils_path}:devicemanagerutils", - "${innerkits_path}/native_cpp:devicemanagersdk", + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", "//base/security/deviceauth/services:deviceauth_sdk", "//base/startup/syspara_lite/frameworks/parameter/src:sysparam", - "//utils/native/lite:utils", - "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", - "//foundation/communication/ipc_lite:liteipc_adapter", + "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", + "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", "//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", - "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", - "//foundation/aafwk/standard/services/abilitymgr:abilityms", - "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//utils/native/lite:utils", ] } } else { @@ -132,18 +131,16 @@ if (defined(ohos_lite)) { "//base/startup/syspara_lite/adapter/native/syspara/include", "//third_party/json/include", ] - + sources = [ "src/ability/dm_ability_manager.cpp", + "src/auth/hichain_connector.cpp", + "src/ipc/ipc_server_adapter.cpp", + "src/ipc/ipc_server_listener_adapter.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/ipc/ipc_server_adapter.cpp", - "src/ipc/ipc_server_listener_adapter.cpp", - "src/softbus/softbus_adapter.cpp", - "src/softbus/softbus_session.cpp", - "src/auth/hichain_connector.cpp", "src/message/msg_codec.cpp", "src/message/msg_head.cpp", "src/message/msg_request_auth.cpp", @@ -152,16 +149,17 @@ if (defined(ohos_lite)) { "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", ] deps = [ - "//utils/native/base:utils", "${utils_path}:devicemanagerutils", - "${innerkits_path}/native_cpp:devicemanagersdk", "//base/security/deviceauth/services:deviceauth_sdk", "//foundation/aafwk/standard/interfaces/innerkits/ability_manager:ability_manager", - "//foundation/aafwk/standard/services/abilitymgr:abilityms", "//foundation/aafwk/standard/interfaces/innerkits/want:want", + "//foundation/aafwk/standard/services/abilitymgr:abilityms", + "//utils/native/base:utils", ] defines = [ @@ -176,11 +174,11 @@ if (defined(ohos_lite)) { "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_L2:samgr_proxy", - "dsoftbus_standard:softbus_client", "startup_l2:syspara", ] diff --git a/services/devicemanagerservice/src/message/msg_codec.cpp b/services/devicemanagerservice/src/message/msg_codec.cpp index e748e7721..40e3b4ff0 100644 --- a/services/devicemanagerservice/src/message/msg_codec.cpp +++ b/services/devicemanagerservice/src/message/msg_codec.cpp @@ -87,6 +87,7 @@ std::shared_ptr MsgCodec::DecodeResponseAuth(std::string &jsonS 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) { diff --git a/services/devicemanagerservice/src/requestauth/response_session.cpp b/services/devicemanagerservice/src/requestauth/response_session.cpp index 2be2b9888..04dc061e7 100644 --- a/services/devicemanagerservice/src/requestauth/response_session.cpp +++ b/services/devicemanagerservice/src/requestauth/response_session.cpp @@ -218,7 +218,7 @@ void ResponseSession::OnGroupCreated(int64_t requestId, const std::string &group } // save requestId for peer to join, need to be checked in HiChain OnRequest and OnFinish(AddMemberToGroup) callback - //mRequestId = HichainConnector::GetInstance().GenRequestId(); + mRequestId = HichainConnector::GetInstance().GenRequestId(); mGroupId_ = groupId; int32_t ret = SendResponseMessage(SESSION_REPLY_ACCEPT); if(ret != SUCCESS){ -- Gitee