diff --git a/interfaces/inner_kits/native_cpp/BUILD.gn b/interfaces/inner_kits/native_cpp/BUILD.gn index 9311ca50b576dda4656f587acdb420fc600fe918..9ccdcffc83edb47da0387189a047ab4cc2b384cc 100644 --- a/interfaces/inner_kits/native_cpp/BUILD.gn +++ b/interfaces/inner_kits/native_cpp/BUILD.gn @@ -10,14 +10,39 @@ # WITHOUT 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/config/components/idl_tool/idl.gni") if (defined(ohos_lite)) { import("//build/lite/config/component/lite_component.gni") } else { import("//build/ohos.gni") } import("//foundation/distributedhardware/device_manager/device_manager.gni") - +idl_gen_interface("device_manager_interface") { + src_idl = rebase_path("IDeviceManagerClient.idl") + hitrace = "HITRACE_TAG_DEVICE_MANAGER" + log_domainid = "0xD004111" + log_tag = "distributedhardware" +} +ohos_source_set("device_manager_ipc") { + sanitize = { + debug = false + cfi = true + cfi_cross_dso = true + } + output_values = get_target_outputs(":device_manager_interface") + sources = [] + sources += filter_include(output_values, [ "*.cpp" ]) + public_configs = [ ":devicemanagersdk_config" ] + deps = [ ":device_manager_interface" ] + external_deps = [ + "c_utils:utils", + "hilog:libhilog", + "hitrace:hitrace_meter", + "ipc:ipc_core", + ] + subsystem_name = "distributedhardware" + part_name = "device_manager" +} if (defined(ohos_lite)) { if (ohos_kernel_type == "liteos_m") { static_library("devicemanagersdk") { @@ -88,6 +113,7 @@ if (defined(ohos_lite)) { "${interfaces_path}/c/ipc/include", "//foundation/distributedshedule/samgr_lite/interfaces/kits/samgr", "//foundation/systemabilitymgr/samgr/interfaces/innerkits/samgr_proxy/include", + "${target_gen_dir}", ] sources = [ @@ -107,6 +133,8 @@ if (defined(ohos_lite)) { "src/ipc/lite/ipc_client_stub.cpp", "src/ipc/lite/ipc_cmd_parser.cpp", "src/notify/device_manager_notify.cpp", + "src/dm_device_profile_info.cpp", + "src/dm_publish_info.cpp" ] defines = [ @@ -127,6 +155,7 @@ if (defined(ohos_lite)) { "//foundation/systemabilitymgr/safwk_lite:safwk_lite", "//foundation/systemabilitymgr/samgr_lite/samgr:samgr", "//third_party/bounds_checking_function:libsec_shared", + ":device_manager_ipc", ] } } @@ -146,6 +175,8 @@ if (defined(ohos_lite)) { "${devicemanager_path}/radar/include", "${utils_path}/include", "${json_path}/include", + "${target_gen_dir}", + "${devicemanager_path}/commondependency/include", ] } @@ -188,8 +219,12 @@ if (defined(ohos_lite)) { "src/ipc/standard/ipc_client_stub.cpp", "src/ipc/standard/ipc_cmd_parser.cpp", "src/notify/device_manager_notify.cpp", + "src/dm_publish_info.cpp", + "src/dm_device_profile_info.cpp", + "${utils_path}/src/dm_ipc_utils.cpp", ] + deps = [ ":device_manager_ipc" ] public_configs = [ ":devicemanagersdk_config" ] innerapi_tags = [ "platformsdk" ] @@ -201,7 +236,7 @@ if (defined(ohos_lite)) { "__CJSON_USE_INT64", ] - deps = [ "${json_path}:devicemanagerjson" ] + deps += [ "${json_path}:devicemanagerjson" ] external_deps = [ "access_token:libaccesstoken_sdk", diff --git a/interfaces/inner_kits/native_cpp/IDeviceManagerClient.idl b/interfaces/inner_kits/native_cpp/IDeviceManagerClient.idl new file mode 100644 index 0000000000000000000000000000000000000000..0458e94ba8f5e32077e6c28a0fc7f97e5de5947a --- /dev/null +++ b/interfaces/inner_kits/native_cpp/IDeviceManagerClient.idl @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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 DeviceManagerType; +sequenceable DmDeviceInfo..OHOS.DistributedHardware.DmDeviceInfoExt; +sequenceable DmDeviceInfo..OHOS.DistributedHardware.PeerTargetIdExt; +sequenceable DmDeviceInfo..OHOS.DistributedHardware.DmAccessCallerExt; +sequenceable DmDeviceInfo..OHOS.DistributedHardware.DmAccessCalleeExt; +sequenceable DmPublishInfo..OHOS.DistributedHardware.DmPublishInfoExt; +sequenceable DmDeviceProfileInfo..OHOS.DistributedHardware.DmDeviceProfileInfoExt; +sequenceable DmDeviceInfo..OHOS.DistributedHardware.DMLocalServiceInfoExt; +sequenceable DmDeviceProfileInfo..OHOS.DistributedHardware.NetworkIdQueryFilterExt; + +interface OHOS.DistributedHardware.IDeviceManagerClient { + [ipccode 2] void GetTrustedDeviceList([in] String pkgName, + [in] String extra, [in] boolean isRefresh, [out] List deviceListExt); + [ipccode 3] void GetLocalDeviceInfo([in] String pkgName, [out] DmDeviceInfoExt deviceInfoExt); + [ipccode 4] void GetUdidByNetworkId([in] String pkgName, [in] String netWorkId, [out] String udid); + [ipccode 5] void GetUuidByNetworkId([in] String pkgName, [in] String netWorkId, [out] String uuid); + [ipccode 6] void GetNetworkTypeByNetworkId([in] String pkgName, [in] String netWorkId, [out] int netWorkType); + [ipccode 7] void PublishDeviceDiscovery([in] String pkgName, [in] DmPublishInfoExt publishInfoExt); + [ipccode 8] void UnPublishDeviceDiscovery([in] String pkgName, [in] int publishId); + [ipccode 9] void AuthenticateDevice([in] String pkgName, [in] int authType, [in] String deviceId, [in] String extra); + [ipccode 10] void UnAuthenticateDevice([in] String pkgName, [in] String netWorkId); + [ipccode 11] void StopAuthenticateDevice([in] String pkgName); + [ipccode 20] void CheckCredential([in] String pkgName, [in] String reqJsonStr, [out] String returnJsonStr); + [ipccode 21] void SetUserOperation([in] String pkgName, [in] int action, [in] String params); + [ipccode 26] void RequestCredential([in] String pkgName, [in] String reqJsonStr, [out] String returnJsonStr); + [ipccode 27] void ImportCredential([in] String pkgName, [in] String reqJsonStr, [out] String returnJsonStr); + [ipccode 28] void DeleteCredential([in] String pkgName, [in] String reqJsonStr, [out] String returnJsonStr); + [ipccode 29] void RegisterCredentialCallback([in] String pkgName); + [ipccode 30] void UnRegisterCredentialCallback([in] String pkgName); + [ipccode 31] void NotifyEvent([in] String pkgName, [in] int eventId, [in] String event); + [ipccode 32] void GetDeviceInfo([in] String pkgName, [in] String networkId, [out] DmDeviceInfoExt deviceInfoExt); + [ipccode 33] void GetEncryptedUuidByNetworkId([in] String pkgName, [in] String networkId, [out] String uuid); + [ipccode 34] void GenerateEncryptedUuid([in] String pkgName, [in] String uuid, [in] String appId, [out] String encryptedUuid); + [ipccode 35] void BindDevice([in] String pkgName, [in] int bindType, [in] String deviceId, [in] String extra); + [ipccode 36] void UnBindDevice([in] String pkgName, [in] String deviceId, [in] String extra); + [ipccode 37] void RegisterUiStateCallback([in] String pkgName); + [ipccode 38] void UnRegisterUiStateCallback([in] String pkgName); + [ipccode 39] void ImportAuthCode([in] String pkgName, [in] String authCode); + [ipccode 40] void ExportAuthCode([out] String authCode); + [ipccode 41] void RegisterPinHolderCallback([in] String pkgName); + [ipccode 42] void CreatePinHolder([in] String pkgName, [in] PeerTargetIdExt targetIdExt, [in] int pinTypeInt, [in] String payload); + [ipccode 43] void DestroyPinHolder([in] String pkgName, [in] PeerTargetIdExt targetIdExt, [in] int pinType, [in] String payload); + [ipccode 49] void RegisterDiscoveryCallback([in] String pkgName, + [in] OrderedMap discoverParam, [in] OrderedMap filterOptions); + [ipccode 50] void UnRegisterDiscoveryCallback([in] String pkgName); + [ipccode 51] void StartDiscovering([in] String pkgName, + [in] OrderedMap discoverParam, [in] OrderedMap filterOptions); + [ipccode 52] void StopDiscovering([in] String pkgName, [in] OrderedMap discoverParam); + [ipccode 53] void StartAdvertising([in] String pkgName, [in] String adverParaStr); + [ipccode 54] void StopAdvertising([in] String pkgName, [in] String adverParaStr); + [ipccode 55] void BindTarget([in] String pkgName, [in] PeerTargetIdExt targetIdExt, [in] String bindParam); + [ipccode 56] void UnbindTarget([in] String pkgName, [in] PeerTargetIdExt targetIdExt, [in] String unbindParam); + [ipccode 59] void DpAclAdd([in] long accessControlId, [in] String udid, [in] int bindType); + [ipccode 60] void GetDeviceSecurityLevel([in] String pkgName, [in] String networkId,[out] int securityLevel); + [ipccode 61] boolean IsSameAccount([in] String netWorkId); + [ipccode 62] void CheckApiPermission([in] int permissionLevel); + [ipccode 63] boolean CheckAccessControl([in] DmAccessCallerExt callerExt, [in] DmAccessCalleeExt calleeExt); + [ipccode 64] boolean CheckIsSameAccount([in] DmAccessCallerExt callerExt, [in] DmAccessCalleeExt calleeExt); + [ipccode 65] void ShiftLNNGear([in] String pkgName); + [ipccode 66] void SetDnPolicy([in] String pkgName, [in] OrderedMap policy); + [ipccode 69] void GetDeviceScreenStatus([in] String pkgName, [in] String networkId, [out] int screenStatus); + [ipccode 70] void GetNetworkIdByUdid([in] String pkgName, [in] String udid, [out] String networkId); + [ipccode 73] void SyncCallbackToService([in] int dmCommonNotifyEvent, [in] String pkgName); + [ipccode 74] void GetAnonyLocalUdid([in] String pkgName, [out] String anonyUdid); + [ipccode 75] void RegisterAuthenticationType([in] String pkgName, [in] String authTypeStr); + [ipccode 80] void PutDeviceProfileInfoList([in] String pkgName, [in] List deviceProfileInfoListExt); + [ipccode 81] void GetLocalDisplayDeviceName([in] String pkgName, [in] int maxNameLength, [out] String displayName); + [ipccode 86] void GetAllTrustedDeviceList([in] String pkgName, [in] String extra, [out] List deviceListExt); + [ipccode 87] void RegisterLocalServiceInfo([in] DMLocalServiceInfoExt info); + [ipccode 88] void UnRegisterLocalServiceInfo([in] String bundleName, [in] int pinExchangeType); + [ipccode 89] void UpdateLocalServiceInfo([in] DMLocalServiceInfoExt info); + [ipccode 90] void GetLocalServiceInfoByBundleNameAndPinExchangeType([in] String bundleName, + [in] int pinExchangeType, [out] DMLocalServiceInfoExt info); + [ipccode 91] void RestoreLocalDeviceName([in] String pkgName); + [ipccode 92] void GetDeviceNetworkIdList([in] String pkgName, [in] NetworkIdQueryFilterExt queryFilter, [out] List networkIds); +} \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h index 61298898a35920ed5af1f7fe221ba5101ab64bae..31958f2d166d08e0fe04774ddbbbfff15f087b47 100644 --- a/interfaces/inner_kits/native_cpp/include/device_manager_impl.h +++ b/interfaces/inner_kits/native_cpp/include/device_manager_impl.h @@ -20,6 +20,7 @@ #if !defined(__LITEOS_M__) #include "ipc_client_manager.h" #include "ipc_client_proxy.h" +#include "idevice_manager_client.h" #endif #include @@ -456,6 +457,7 @@ private: #if !defined(__LITEOS_M__) std::shared_ptr ipcClientProxy_ = std::make_shared(std::make_shared()); + std::shared_ptr deviceManagerInterface_ = nullptr; #endif std::mutex subMapLock; std::map pkgName2SubIdMap_; diff --git a/interfaces/inner_kits/native_cpp/include/dm_device_info.h b/interfaces/inner_kits/native_cpp/include/dm_device_info.h index 243012f277a02d9da10f5888f7bdda1444b34d8c..7c66080086c32bd2bfeb2cd4cd6761fc6b94d241 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_device_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_device_info.h @@ -20,6 +20,7 @@ #include #include "dm_app_image_info.h" +#include "parcel.h" #define DM_MAX_DEVICE_ID_LEN (97) #define DM_MAX_DEVICE_NAME_LEN (129) @@ -450,6 +451,118 @@ typedef struct DMLocalServiceInfo { std::string description; std::string extraInfo; } DMLocalServiceInfo; +struct DmDeviceInfoExt : public DmDeviceInfo, public Parcelable +{ + using DmDeviceInfo::DmDeviceInfo; + + DmDeviceInfoExt(const DmDeviceInfo& devInfo) + { + memcpy(deviceId, devInfo.deviceId, DM_MAX_DEVICE_ID_LEN); + memcpy(deviceName, devInfo.deviceName, DM_MAX_DEVICE_NAME_LEN); + deviceTypeId = devInfo.deviceTypeId; + memcpy(networkId, devInfo.networkId, DM_MAX_DEVICE_ID_LEN); + range = devInfo.range; + networkType = devInfo.networkType; + authForm = devInfo.authForm; + extraData = devInfo.extraData; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DmDeviceInfoExt *Unmarshalling(Parcel &parcel); +}; + +struct PeerTargetIdExt : public PeerTargetId, public Parcelable { + + using PeerTargetId::PeerTargetId; + + PeerTargetIdExt(const PeerTargetId& peerTargetId) + { + deviceId = peerTargetId.deviceId; + brMac = peerTargetId.brMac; + bleMac = peerTargetId.bleMac; + wifiIp = peerTargetId.wifiIp; + wifiPort = peerTargetId.wifiPort; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static PeerTargetIdExt *Unmarshalling(Parcel &parcel); +}; + +struct DmAccessCallerExt : public DmAccessCaller, public Parcelable { + + using DmAccessCaller::DmAccessCaller; + + DmAccessCallerExt(const DmAccessCaller& dmAccessCaller) + { + accountId = dmAccessCaller.accountId; + pkgName = dmAccessCaller.pkgName; + networkId = dmAccessCaller.networkId; + userId = dmAccessCaller.userId; + tokenId = dmAccessCaller.tokenId; + extra = dmAccessCaller.extra; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DmAccessCallerExt *Unmarshalling(Parcel &parcel); +}; + +struct DmAccessCalleeExt : public DmAccessCallee, public Parcelable { + + using DmAccessCallee::DmAccessCallee; + + DmAccessCalleeExt(const DmAccessCallee& dmAccessCallee) + { + accountId = dmAccessCallee.accountId; + networkId = dmAccessCallee.networkId; + peerId = dmAccessCallee.peerId; + userId = dmAccessCallee.userId; + extra = dmAccessCallee.extra; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DmAccessCalleeExt *Unmarshalling(Parcel &parcel); +}; + +struct DmDeviceBasicInfoExt : public DmDeviceBasicInfo, public Parcelable +{ + using DmDeviceBasicInfo::DmDeviceBasicInfo; + + DmDeviceBasicInfoExt(const DmDeviceBasicInfo& devBasicInfo) + { + memcpy(deviceId, devBasicInfo.deviceId, DM_MAX_DEVICE_ID_LEN); + memcpy(deviceName, devBasicInfo.deviceName, DM_MAX_DEVICE_NAME_LEN); + deviceTypeId = devBasicInfo.deviceTypeId; + memcpy(networkId, devBasicInfo.networkId, DM_MAX_DEVICE_ID_LEN); + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DmDeviceBasicInfoExt *Unmarshalling(Parcel &parcel); +}; + +struct DMLocalServiceInfoExt : public DMLocalServiceInfo, public Parcelable +{ + using DMLocalServiceInfo::DMLocalServiceInfo; + + DMLocalServiceInfoExt(const DMLocalServiceInfo& devLocalServiceInfo) { + bundleName = devLocalServiceInfo.bundleName; + authBoxType = devLocalServiceInfo.authBoxType; + authType = devLocalServiceInfo.authType; + pinExchangeType = devLocalServiceInfo.pinExchangeType; + pinCode = devLocalServiceInfo.pinCode; + description = devLocalServiceInfo.description; + extraInfo = devLocalServiceInfo.extraInfo; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DMLocalServiceInfoExt *Unmarshalling(Parcel &parcel); + +}; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_DEVICE_INFO_H \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/include/dm_device_profile_info.h b/interfaces/inner_kits/native_cpp/include/dm_device_profile_info.h index b110b91761bba2e8f405a1265e8a531444a7b509..35a3cd8cc55d67dbca632d2803a8f57b2ee3cfcd 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_device_profile_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_device_profile_info.h @@ -21,6 +21,8 @@ #include #include +#include "parcel.h" + namespace OHOS { namespace DistributedHardware { typedef struct DmProductInfo { @@ -99,6 +101,61 @@ typedef struct NetworkIdQueryFilter { std::string deviceProductId = ""; std::string deviceModel = ""; } NetworkIdQueryFilter; + +struct DmDeviceProfileInfoExt : public DmDeviceProfileInfo, public Parcelable +{ + using DmDeviceProfileInfo::DmDeviceProfileInfo; + + DmDeviceProfileInfoExt(const DmDeviceProfileInfo& devProfileInfo) { + deviceId = devProfileInfo.deviceId; + deviceSn = devProfileInfo.deviceSn; + mac = devProfileInfo.mac; + model = devProfileInfo.model; + internalModel = devProfileInfo.internalModel; + deviceType = devProfileInfo.deviceType; + manufacturer = devProfileInfo.manufacturer; + deviceName = devProfileInfo.deviceName; + productId = devProfileInfo.productId; + subProductId = devProfileInfo.subProductId; + sdkVersion = devProfileInfo.sdkVersion; + bleMac = devProfileInfo.bleMac; + brMac = devProfileInfo.brMac; + sleMac = devProfileInfo.sleMac; + firmwareVersion = devProfileInfo.firmwareVersion; + hardwareVersion = devProfileInfo.hardwareVersion; + softwareVersion = devProfileInfo.softwareVersion; + protocolType = devProfileInfo.protocolType; + setupType = devProfileInfo.setupType; + wiseDeviceId = devProfileInfo.wiseDeviceId; + wiseUserId = devProfileInfo.wiseUserId; + registerTime = devProfileInfo.registerTime; + modifyTime = devProfileInfo.modifyTime; + shareTime = devProfileInfo.shareTime; + isLocalDevice = devProfileInfo.isLocalDevice; + services = devProfileInfo.services; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DmDeviceProfileInfoExt *Unmarshalling(Parcel &parcel); +}; + +struct NetworkIdQueryFilterExt : public NetworkIdQueryFilter, public Parcelable +{ + using NetworkIdQueryFilter::NetworkIdQueryFilter; + + NetworkIdQueryFilterExt(const NetworkIdQueryFilter& devNetworkIdQueryFilter) { + wiseDeviceId = devNetworkIdQueryFilter.wiseDeviceId; + onlineStatus = devNetworkIdQueryFilter.onlineStatus; + deviceType = devNetworkIdQueryFilter.deviceType; + deviceProductId = devNetworkIdQueryFilter.deviceProductId; + deviceModel = devNetworkIdQueryFilter.deviceModel; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static NetworkIdQueryFilterExt *Unmarshalling(Parcel &parcel); +}; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_DEVICE_PROFILE_INFO_H diff --git a/interfaces/inner_kits/native_cpp/include/dm_publish_info.h b/interfaces/inner_kits/native_cpp/include/dm_publish_info.h index f3e7b0b34dce5f314f1070c414f81196f9a4f325..a869f0ead2884e2a9773f812c6a12f5f8f9b3c0d 100644 --- a/interfaces/inner_kits/native_cpp/include/dm_publish_info.h +++ b/interfaces/inner_kits/native_cpp/include/dm_publish_info.h @@ -17,6 +17,7 @@ #define OHOS_DM_PUBLISH_INFO_H #include "dm_subscribe_info.h" +#include "parcel.h" namespace OHOS { namespace DistributedHardware { @@ -45,6 +46,22 @@ typedef struct { */ DmExchangeMedium medium; } DmPublishInfo; + +struct DmPublishInfoExt : public DmPublishInfo, public Parcelable { + using DmPublishInfo::DmPublishInfo; + + DmPublishInfoExt(const DmPublishInfo& publishInfo) + { + publishId = publishInfo.publishId; + mode = publishInfo.mode; + freq = publishInfo.freq; + ranging = publishInfo.ranging; + } + + virtual bool Marshalling(Parcel &parcel) const override; + + static DmPublishInfoExt *Unmarshalling(Parcel &parcel); +}; } // namespace DistributedHardware } // namespace OHOS #endif // OHOS_DM_PUBLISH_INFO_H diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp index 55f081c22e296d7aa6c216e7f3ae62d9529c342f..e5df8076c2cd572ae7ef987e49af9d8a52530dbb 100644 --- a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp +++ b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp @@ -72,6 +72,7 @@ #include "ipc_model_codec.h" #include "iservice_registry.h" #include "system_ability_definition.h" +#include "dm_ipc_utils.h" #endif namespace OHOS { namespace DistributedHardware { @@ -223,11 +224,13 @@ int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, cons } LOGD("Start, pkgName: %{public}s, extra: %{public}s", GetAnonyString(pkgName).c_str(), extra.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetExtra(extra); - int32_t ret = ipcClientProxy_->SendRequest(GET_TRUST_DEVICE_LIST, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetExtra(extra); + std::vector deviceListExt; + int32_t ret = deviceManagerInterface_->GetTrustedDeviceList(pkgName, extra, false, deviceListExt); + DmIpcUtils::ConvertToDeviceInfoVector(deviceListExt, deviceList); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", deviceList, ret, anonyLocalUdid_); @@ -235,15 +238,15 @@ int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, cons return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", - deviceList, ret, anonyLocalUdid_); - LOGI("GetTrustedDeviceList error, failed ret: %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", + // deviceList, ret, anonyLocalUdid_); + // LOGI("GetTrustedDeviceList error, failed ret: %{public}d", ret); + // return ret; + // } - deviceList = rsp->GetDeviceVec(); + // deviceList = rsp->GetDeviceVec(); LOGI("Completed, device size %{public}zu", deviceList.size()); DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", deviceList, DM_OK, anonyLocalUdid_); @@ -262,12 +265,14 @@ int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, cons LOGD("Start, pkgName: %{public}s, extra: %{public}s, isRefresh: %{public}d", GetAnonyString(pkgName).c_str(), extra.c_str(), isRefresh); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetExtra(extra); - req->SetRefresh(isRefresh); - int32_t ret = ipcClientProxy_->SendRequest(GET_TRUST_DEVICE_LIST, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetExtra(extra); + // req->SetRefresh(isRefresh); + std::vector deviceListExt; + int32_t ret = deviceManagerInterface_->GetTrustedDeviceList(pkgName, extra, isRefresh,deviceListExt); + DmIpcUtils::ConvertToDeviceInfoVector(deviceListExt, deviceList); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", deviceList, ret, anonyLocalUdid_); @@ -275,14 +280,14 @@ int32_t DeviceManagerImpl::GetTrustedDeviceList(const std::string &pkgName, cons return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", - deviceList, ret, anonyLocalUdid_); - LOGE("GetTrustedDeviceList error, failed ret: %{public}d", ret); - return ret; - } - deviceList = rsp->GetDeviceVec(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", + // deviceList, ret, anonyLocalUdid_); + // LOGE("GetTrustedDeviceList error, failed ret: %{public}d", ret); + // return ret; + // } + // deviceList = rsp->GetDeviceVec(); LOGI("Completed, device size %{public}zu", deviceList.size()); DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", deviceList, DM_OK, anonyLocalUdid_); @@ -323,11 +328,12 @@ int32_t DeviceManagerImpl::GetDeviceInfo(const std::string &pkgName, const std:: } LOGI("Start, pkgName: %{public}s networKId : %{public}s", pkgName.c_str(), GetAnonyString(networkId).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(networkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_DEVICE_INFO, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(networkId); + DmDeviceInfoExt dmDeviceInfoExt(deviceInfo); + int32_t ret = deviceManagerInterface_->GetDeviceInfo(pkgName, networkId, dmDeviceInfoExt); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportGetDeviceInfo(pkgName, "GetDeviceInfo", deviceInfo, ret, anonyLocalUdid_); @@ -335,48 +341,69 @@ int32_t DeviceManagerImpl::GetDeviceInfo(const std::string &pkgName, const std:: return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportGetDeviceInfo(pkgName, "GetDeviceInfo", - deviceInfo, ret, anonyLocalUdid_); - LOGE("DeviceManagerImpl::GetDeviceInfo error, failed ret: %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportGetDeviceInfo(pkgName, "GetDeviceInfo", + // deviceInfo, ret, anonyLocalUdid_); + // LOGE("DeviceManagerImpl::GetDeviceInfo error, failed ret: %{public}d", ret); + // return ret; + // } - deviceInfo = rsp->GetDeviceInfo(); - LOGI("Completed, networKId = %{public}s deviceName = %{public}s", GetAnonyString(req->GetNetWorkId()).c_str(), + // deviceInfo = rsp->GetDeviceInfo(); + LOGI("Completed, networKId = %{public}s deviceName = %{public}s", GetAnonyString(networkId).c_str(), GetAnonyString(deviceInfo.deviceName).c_str()); DmRadarHelper::GetInstance().ReportGetDeviceInfo(pkgName, "GetDeviceInfo", deviceInfo, DM_OK, anonyLocalUdid_); return DM_OK; } +// int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info) +// { +// LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str()); +// DmTraceStart(std::string(DM_HITRACE_GET_LOCAL_DEVICE_INFO)); +// std::shared_ptr req = std::make_shared(); +// std::shared_ptr rsp = std::make_shared(); +// req->SetPkgName(pkgName); +// int32_t ret = ipcClientProxy_->SendRequest(GET_LOCAL_DEVICE_INFO, req, rsp); +// if (ret != DM_OK) { +// DmRadarHelper::GetInstance().ReportGetLocalDevInfo(pkgName, "GetLocalDeviceInfo", +// info, ret, anonyLocalUdid_); +// LOGE("DeviceManagerImpl::GetLocalDeviceInfo error, Send Request failed ret: %{public}d", ret); +// return ERR_DM_IPC_SEND_REQUEST_FAILED; +// } + +// ret = rsp->GetErrCode(); +// if (ret != DM_OK) { +// DmRadarHelper::GetInstance().ReportGetLocalDevInfo(pkgName, "GetLocalDeviceInfo", +// info, ret, anonyLocalUdid_); +// LOGI("DeviceManagerImpl::GetLocalDeviceInfo error, failed ret: %{public}d", ret); +// SysEventWrite(std::string(GET_LOCAL_DEVICE_INFO_FAILED), DM_HISYEVENT_BEHAVIOR, +// std::string(GET_LOCAL_DEVICE_INFO_FAILED_MSG)); +// return ret; +// } + +// info = rsp->GetLocalDeviceInfo(); +// DmTraceEnd(); +// LOGI("Completed"); +// SysEventWrite(std::string(GET_LOCAL_DEVICE_INFO_SUCCESS), DM_HISYEVENT_BEHAVIOR, +// std::string(GET_LOCAL_DEVICE_INFO_SUCCESS_MSG)); +// DmRadarHelper::GetInstance().ReportGetLocalDevInfo(pkgName, "GetLocalDeviceInfo", +// info, DM_OK, anonyLocalUdid_); +// return DM_OK; +// } + int32_t DeviceManagerImpl::GetLocalDeviceInfo(const std::string &pkgName, DmDeviceInfo &info) { LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str()); DmTraceStart(std::string(DM_HITRACE_GET_LOCAL_DEVICE_INFO)); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(GET_LOCAL_DEVICE_INFO, req, rsp); + DmDeviceInfoExt dmDeviceInfoExt(info); + int32_t ret = deviceManagerInterface_->GetLocalDeviceInfo(pkgName, dmDeviceInfoExt); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportGetLocalDevInfo(pkgName, "GetLocalDeviceInfo", info, ret, anonyLocalUdid_); LOGE("DeviceManagerImpl::GetLocalDeviceInfo error, Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportGetLocalDevInfo(pkgName, "GetLocalDeviceInfo", - info, ret, anonyLocalUdid_); - LOGI("DeviceManagerImpl::GetLocalDeviceInfo error, failed ret: %{public}d", ret); - SysEventWrite(std::string(GET_LOCAL_DEVICE_INFO_FAILED), DM_HISYEVENT_BEHAVIOR, - std::string(GET_LOCAL_DEVICE_INFO_FAILED_MSG)); - return ret; - } - - info = rsp->GetLocalDeviceInfo(); DmTraceEnd(); LOGI("Completed"); SysEventWrite(std::string(GET_LOCAL_DEVICE_INFO_SUCCESS), DM_HISYEVENT_BEHAVIOR, @@ -540,22 +567,21 @@ int32_t DeviceManagerImpl::StartDiscovering(const std::string &pkgName, discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId)); std::string discParaStr = ConvertMapToJsonString(discoverParam); std::string filterOpStr = ConvertMapToJsonString(filterOptions); - - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(ComposeStr(pkgName, subscribeId)); - req->SetFirstParam(discParaStr); - req->SetSecondParam(filterOpStr); - int32_t ret = ipcClientProxy_->SendRequest(START_DISCOVERING, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(ComposeStr(pkgName, subscribeId)); + // req->SetFirstParam(discParaStr); + // req->SetSecondParam(filterOpStr); + int32_t ret = deviceManagerInterface_->StartDiscovering(pkgName, discoverParam, filterOptions); if (ret != DM_OK) { LOGE("StartDiscovering error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("StartDiscovering error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("StartDiscovering error: Failed with ret %{public}d", ret); + // return ret; + // } DmTraceEnd(); LOGI("Completed"); @@ -585,20 +611,20 @@ int32_t DeviceManagerImpl::StopDiscovering(const std::string &pkgName, discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId)); std::string discParaStr = ConvertMapToJsonString(discoverParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(ComposeStr(pkgName, subscribeId)); - req->SetFirstParam(discParaStr); - int32_t ret = ipcClientProxy_->SendRequest(STOP_DISCOVERING, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(ComposeStr(pkgName, subscribeId)); + // req->SetFirstParam(discParaStr); + int32_t ret = deviceManagerInterface_->StopDiscovering(pkgName, discoverParam); if (ret != DM_OK) { LOGE("StopDiscovering error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("StopDiscovering error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("StopDiscovering error: Failed with ret %{public}d", ret); + // return ret; + // } RemoveDiscoveryCallback(pkgNameTemp); LOGI("Completed"); return DM_OK; @@ -617,11 +643,13 @@ int32_t DeviceManagerImpl::PublishDeviceDiscovery(const std::string &pkgName, co LOGI("Start, pkgName %{public}s", pkgName.c_str()); DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishInfo.publishId, callback); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetPublishInfo(publishInfo); - int32_t ret = ipcClientProxy_->SendRequest(PUBLISH_DEVICE_DISCOVER, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetPublishInfo(publishInfo); + DmPublishInfoExt publishInfoExt; + DmIpcUtils::ConvertToPublishInfo(publishInfo, publishInfoExt); + int32_t ret = deviceManagerInterface_->PublishDeviceDiscovery(pkgName, publishInfoExt); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "PublishDeviceDiscovery", ret, anonyLocalUdid_); LOGE("PublishDeviceDiscovery error: Send Request failed ret: %{public}d", ret); @@ -629,12 +657,12 @@ int32_t DeviceManagerImpl::PublishDeviceDiscovery(const std::string &pkgName, co return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "PublishDeviceDiscovery", ret, anonyLocalUdid_); - LOGE("PublishDeviceDiscovery error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "PublishDeviceDiscovery", ret, anonyLocalUdid_); + // LOGE("PublishDeviceDiscovery error: Failed with ret %{public}d", ret); + // return ret; + // } DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "PublishDeviceDiscovery", DM_OK, anonyLocalUdid_); LOGI("Completed"); return DM_OK; @@ -650,23 +678,23 @@ int32_t DeviceManagerImpl::UnPublishDeviceDiscovery(const std::string &pkgName, } LOGI("Start, pkgName %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetPublishId(publishId); - int32_t ret = ipcClientProxy_->SendRequest(UNPUBLISH_DEVICE_DISCOVER, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetPublishId(publishId); + int32_t ret = deviceManagerInterface_->UnPublishDeviceDiscovery(pkgName, publishId); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnPublishDeviceDiscovery", ret, anonyLocalUdid_); LOGE("UnPublishDeviceDiscovery error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnPublishDeviceDiscovery", ret, anonyLocalUdid_); - LOGE("UnPublishDeviceDiscovery error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnPublishDeviceDiscovery", ret, anonyLocalUdid_); + // LOGE("UnPublishDeviceDiscovery error: Failed with ret %{public}d", ret); + // return ret; + // } DeviceManagerNotify::GetInstance().UnRegisterPublishCallback(pkgName, publishId); DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnPublishDeviceDiscovery", DM_OK, anonyLocalUdid_); @@ -695,13 +723,14 @@ int32_t DeviceManagerImpl::AuthenticateDevice(const std::string &pkgName, int32_ #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) extraJson[TOKENID] = std::to_string(OHOS::IPCSkeleton::GetSelfTokenID()); #endif - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetExtra(SafetyDump(extraJson)); - req->SetAuthType(authType); - req->SetDeviceInfo(deviceInfo); - int32_t ret = ipcClientProxy_->SendRequest(AUTHENTICATE_DEVICE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetExtra(SafetyDump(extraJson)); + // req->SetAuthType(authType); + // req->SetDeviceInfo(deviceInfo); + std::string extraSafetDump = SafetyDump(extraJson); + int32_t ret = deviceManagerInterface_->AuthenticateDevice(pkgName, authType, strDeviceId, extraSafetDump); if (ret != DM_OK) { LOGE("AuthenticateDevice error: Send Request failed ret: %{public}d", ret); SysEventWrite(std::string(DM_SEND_REQUEST_FAILED), DM_HISYEVENT_BEHAVIOR, @@ -711,11 +740,11 @@ int32_t DeviceManagerImpl::AuthenticateDevice(const std::string &pkgName, int32_ SysEventWrite(std::string(DM_SEND_REQUEST_SUCCESS), DM_HISYEVENT_BEHAVIOR, std::string(DM_SEND_REQUEST_SUCCESS_MSG)); - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("AuthenticateDevice error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("AuthenticateDevice error: Failed with ret %{public}d", ret); + // return ret; + // } DmTraceEnd(); LOGI("Completed"); return DM_OK; @@ -729,22 +758,23 @@ int32_t DeviceManagerImpl::UnAuthenticateDevice(const std::string &pkgName, cons } LOGI("Start, pkgName: %{public}s, networkId: %{public}s", pkgName.c_str(), GetAnonyString(std::string(deviceInfo.networkId)).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetDeviceInfo(deviceInfo); - int32_t ret = ipcClientProxy_->SendRequest(UNAUTHENTICATE_DEVICE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetDeviceInfo(deviceInfo); + std::string strDeviceId = deviceInfo.deviceId; + int32_t ret = deviceManagerInterface_->UnAuthenticateDevice(pkgName, strDeviceId); if (ret != DM_OK) { LOGE("UnAuthenticateDevice error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("UnAuthenticateDevice error: Failed with ret %{public}d", ret); - SysEventWrite(std::string(UNAUTHENTICATE_DEVICE_FAILED), DM_HISYEVENT_BEHAVIOR, - std::string(UNAUTHENTICATE_DEVICE_FAILED_MSG)); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("UnAuthenticateDevice error: Failed with ret %{public}d", ret); + // SysEventWrite(std::string(UNAUTHENTICATE_DEVICE_FAILED), DM_HISYEVENT_BEHAVIOR, + // std::string(UNAUTHENTICATE_DEVICE_FAILED_MSG)); + // return ret; + // } SysEventWrite(std::string(UNAUTHENTICATE_DEVICE_SUCCESS), DM_HISYEVENT_BEHAVIOR, std::string(UNAUTHENTICATE_DEVICE_SUCCESS_MSG)); @@ -761,21 +791,21 @@ int32_t DeviceManagerImpl::StopAuthenticateDevice(const std::string &pkgName) return ERR_DM_INPUT_PARA_INVALID; } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(STOP_AUTHENTICATE_DEVICE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + int32_t ret = deviceManagerInterface_->StopAuthenticateDevice(pkgName); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "StopAuthenticateDevice", ret, anonyLocalUdid_); LOGE("StopAuthenticateDevice error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "StopAuthenticateDevice", ret, anonyLocalUdid_); - LOGE("StopAuthenticateDevice error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "StopAuthenticateDevice", ret, anonyLocalUdid_); + // LOGE("StopAuthenticateDevice error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; @@ -844,23 +874,23 @@ int32_t DeviceManagerImpl::SetUserOperation(const std::string &pkgName, int32_t } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetOperation(action); - req->SetParams(params); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetOperation(action); + // req->SetParams(params); - int32_t ret = ipcClientProxy_->SendRequest(SERVER_USER_AUTH_OPERATION, req, rsp); + int32_t ret = deviceManagerInterface_->SetUserOperation(pkgName, action, params); if (ret != DM_OK) { LOGI("SetUserOperation Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CheckAuthentication Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CheckAuthentication Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -875,23 +905,23 @@ int32_t DeviceManagerImpl::GetUdidByNetworkId(const std::string &pkgName, const } LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(netWorkId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(netWorkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_UDID_BY_NETWORK, req, rsp); + int32_t ret = deviceManagerInterface_->GetUdidByNetworkId(pkgName, netWorkId, udid); if (ret != DM_OK) { LOGI("GetUdidByNetworkId Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CheckAuthentication Failed with ret %{public}d", ret); - return ret; - } - udid = rsp->GetUdid(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CheckAuthentication Failed with ret %{public}d", ret); + // return ret; + // } + // udid = rsp->GetUdid(); return DM_OK; } @@ -905,23 +935,23 @@ int32_t DeviceManagerImpl::GetUuidByNetworkId(const std::string &pkgName, const } LOGI("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(netWorkId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(netWorkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_UUID_BY_NETWORK, req, rsp); + int32_t ret = deviceManagerInterface_->GetUuidByNetworkId(pkgName, netWorkId, uuid); if (ret != DM_OK) { LOGI("GetUuidByNetworkId Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CheckAuthentication Failed with ret %{public}d", ret); - return ret; - } - uuid = rsp->GetUuid(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CheckAuthentication Failed with ret %{public}d", ret); + // return ret; + // } + // uuid = rsp->GetUuid(); return DM_OK; } @@ -1014,24 +1044,24 @@ int32_t DeviceManagerImpl::RequestCredential(const std::string &pkgName, const s std::map requestParam; requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH); requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, reqJsonStr); - std::string reqParaStr = ConvertMapToJsonString(requestParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqParaStr); + // std::string reqParaStr = ConvertMapToJsonString(requestParam); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqParaStr); - int32_t ret = ipcClientProxy_->SendRequest(REQUEST_CREDENTIAL, req, rsp); + int32_t ret = deviceManagerInterface_->RequestCredential(pkgName, reqJsonStr, returnJsonStr); if (ret != DM_OK) { LOGI("RequestCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while request credential."); - return ret; - } - returnJsonStr = rsp->GetCredentialResult(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while request credential."); + // return ret; + // } + // returnJsonStr = rsp->GetCredentialResult(); LOGI("request device credential completed."); return DM_OK; } @@ -1048,22 +1078,22 @@ int32_t DeviceManagerImpl::ImportCredential(const std::string &pkgName, const st requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH); requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, credentialInfo); std::string reqParaStr = ConvertMapToJsonString(requestParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqParaStr); - - int32_t ret = ipcClientProxy_->SendRequest(IMPORT_CREDENTIAL, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqParaStr); + std::string returnJsonStr; + int32_t ret = deviceManagerInterface_->ImportCredential(pkgName, reqParaStr, returnJsonStr); if (ret != DM_OK) { LOGI("ImportCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while import credential."); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while import credential."); + // return ret; + // } LOGI("import credential to device completed."); return DM_OK; } @@ -1080,22 +1110,22 @@ int32_t DeviceManagerImpl::DeleteCredential(const std::string &pkgName, const st requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH); requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, deleteInfo); std::string reqParaStr = ConvertMapToJsonString(requestParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqParaStr); - - int32_t ret = ipcClientProxy_->SendRequest(DELETE_CREDENTIAL, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqParaStr); + std::string returnJsonStr; + int32_t ret = deviceManagerInterface_->DeleteCredential(pkgName, reqParaStr, returnJsonStr); if (ret != DM_OK) { LOGI("DeleteCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while import credential."); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while import credential."); + // return ret; + // } LOGI("delete credential from device completed."); return DM_OK; } @@ -1110,21 +1140,21 @@ int32_t DeviceManagerImpl::RegisterCredentialCallback(const std::string &pkgName LOGI("Start, pkgName: %{public}s", pkgName.c_str()); DeviceManagerNotify::GetInstance().RegisterCredentialCallback(pkgName, callback); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(REGISTER_CREDENTIAL_CALLBACK, req, rsp); + int32_t ret = deviceManagerInterface_->RegisterCredentialCallback(pkgName); if (ret != DM_OK) { LOGI("RegisterCredentialCallback Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("RegisterCredentialCallback error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("RegisterCredentialCallback error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed, pkgName: %{public}s", pkgName.c_str()); return DM_OK; } @@ -1138,21 +1168,21 @@ int32_t DeviceManagerImpl::UnRegisterCredentialCallback(const std::string &pkgNa LOGI("Start, pkgName: %{public}s", pkgName.c_str()); DeviceManagerNotify::GetInstance().UnRegisterCredentialCallback(pkgName); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(UNREGISTER_CREDENTIAL_CALLBACK, req, rsp); + int32_t ret = deviceManagerInterface_->UnRegisterCredentialCallback(pkgName); if (ret != DM_OK) { LOGI("UnRegisterCredentialCallback Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("UnRegisterCredentialCallback Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("UnRegisterCredentialCallback Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -1172,25 +1202,25 @@ int32_t DeviceManagerImpl::NotifyEvent(const std::string &pkgName, const int32_t return ERR_DM_INPUT_PARA_INVALID; } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetEventId(eventId); - req->SetEvent(event); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetEventId(eventId); + // req->SetEvent(event); - int32_t ret = ipcClientProxy_->SendRequest(NOTIFY_EVENT, req, rsp); + int32_t ret = deviceManagerInterface_->NotifyEvent(pkgName, eventId, event); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "NotifyEvent", ret, anonyLocalUdid_); LOGI("NotifyEvent Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "NotifyEvent", ret, anonyLocalUdid_); - LOGE("NotifyEvent failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "NotifyEvent", ret, anonyLocalUdid_); + // LOGE("NotifyEvent failed with ret %{public}d", ret); + // return ret; + // } DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "NotifyEvent", DM_OK, anonyLocalUdid_); LOGI("Completed"); return DM_OK; @@ -1206,21 +1236,21 @@ int32_t DeviceManagerImpl::RequestCredential(const std::string &pkgName, std::st std::map requestParam; requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE); std::string reqParaStr = ConvertMapToJsonString(requestParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqParaStr); - int32_t ret = ipcClientProxy_->SendRequest(REQUEST_CREDENTIAL, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqParaStr); + int32_t ret = deviceManagerInterface_->RequestCredential(pkgName, reqParaStr, returnJsonStr); if (ret != DM_OK) { LOGI("RequestCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while request credential."); - return ret; - } - returnJsonStr = rsp->GetCredentialResult(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while request credential."); + // return ret; + // } + // returnJsonStr = rsp->GetCredentialResult(); LOGI("Completed."); return DM_OK; } @@ -1233,23 +1263,23 @@ int32_t DeviceManagerImpl::CheckCredential(const std::string &pkgName, const std return ERR_DM_INPUT_PARA_INVALID; } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqJsonStr); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqJsonStr); - int32_t ret = ipcClientProxy_->SendRequest(SERVER_GET_DMFA_INFO, req, rsp); + int32_t ret = deviceManagerInterface_->CheckCredential(pkgName, reqJsonStr, returnJsonStr); if (ret != DM_OK) { LOGI("CheckCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while Check credential."); - return ret; - } - returnJsonStr = rsp->GetCredentialResult(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while Check credential."); + // return ret; + // } + // returnJsonStr = rsp->GetCredentialResult(); LOGI("Completed."); return DM_OK; } @@ -1266,23 +1296,23 @@ int32_t DeviceManagerImpl::ImportCredential(const std::string &pkgName, const st requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE); requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, reqJsonStr); std::string reqParaStr = ConvertMapToJsonString(requestParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqParaStr); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqParaStr); - int32_t ret = ipcClientProxy_->SendRequest(IMPORT_CREDENTIAL, req, rsp); + int32_t ret = deviceManagerInterface_->ImportCredential(pkgName, reqJsonStr, returnJsonStr); if (ret != DM_OK) { LOGI("ImportCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while import credential."); - return ret; - } - returnJsonStr = rsp->GetCredentialResult(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while import credential."); + // return ret; + // } + // returnJsonStr = rsp->GetCredentialResult(); LOGI("Completed."); return DM_OK; } @@ -1299,23 +1329,22 @@ int32_t DeviceManagerImpl::DeleteCredential(const std::string &pkgName, const st requestParam.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE); requestParam.emplace(DM_CREDENTIAL_REQJSONSTR, reqJsonStr); std::string reqParaStr = ConvertMapToJsonString(requestParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetCredentialParam(reqParaStr); - - int32_t ret = ipcClientProxy_->SendRequest(DELETE_CREDENTIAL, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetCredentialParam(reqParaStr); + int32_t ret = deviceManagerInterface_->DeleteCredential(pkgName, reqJsonStr, returnJsonStr); if (ret != DM_OK) { LOGI("DeleteCredential Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("failed to get return errcode while import credential."); - return ret; - } - returnJsonStr = rsp->GetCredentialResult(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("failed to get return errcode while import credential."); + // return ret; + // } + // returnJsonStr = rsp->GetCredentialResult(); LOGI("Completed."); return DM_OK; } @@ -1341,23 +1370,23 @@ int32_t DeviceManagerImpl::GetEncryptedUuidByNetworkId(const std::string &pkgNam } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(networkId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(networkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_ENCRYPTED_UUID_BY_NETWOEKID, req, rsp); + int32_t ret = deviceManagerInterface_->GetEncryptedUuidByNetworkId(pkgName, networkId, uuid); if (ret != DM_OK) { LOGI("GetEncryptedUuidByNetworkId Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CheckAuthentication Failed with ret %{public}d", ret); - return ret; - } - uuid = rsp->GetUuid(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CheckAuthentication Failed with ret %{public}d", ret); + // return ret; + // } + // uuid = rsp->GetUuid(); LOGI("Complete, uuid: %{public}s", GetAnonyString(uuid).c_str()); return DM_OK; } @@ -1371,24 +1400,24 @@ int32_t DeviceManagerImpl::GenerateEncryptedUuid(const std::string &pkgName, con } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetUuid(uuid); - req->SetAppId(appId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetUuid(uuid); + // req->SetAppId(appId); - int32_t ret = ipcClientProxy_->SendRequest(GENERATE_ENCRYPTED_UUID, req, rsp); + int32_t ret = deviceManagerInterface_->GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); if (ret != DM_OK) { LOGI("GenerateEncryptedUuid Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CheckAuthentication Failed with ret %{public}d", ret); - return ret; - } - encryptedUuid = rsp->GetUuid(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CheckAuthentication Failed with ret %{public}d", ret); + // return ret; + // } + // encryptedUuid = rsp->GetUuid(); LOGI("Complete, encryptedUuid: %{public}s", GetAnonyString(encryptedUuid).c_str()); return DM_OK; } @@ -1521,23 +1550,24 @@ int32_t DeviceManagerImpl::BindDevice(const std::string &pkgName, int32_t bindTy paramJson[TOKENID] = std::to_string(OHOS::IPCSkeleton::GetSelfTokenID()); #endif DeviceManagerNotify::GetInstance().RegisterAuthenticateCallback(pkgName, deviceId, callback); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetBindParam(SafetyDump(paramJson)); - req->SetBindType(bindType); - req->SetDeviceId(deviceId); - int32_t ret = ipcClientProxy_->SendRequest(BIND_DEVICE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetBindParam(SafetyDump(paramJson)); + // req->SetBindType(bindType); + // req->SetDeviceId(deviceId); + std::string bindParamStr = SafetyDump(paramJson); + int32_t ret = deviceManagerInterface_->BindDevice(pkgName, bindType, deviceId, bindParamStr); if (ret != DM_OK) { LOGE("BindDevice error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("BindDevice error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("BindDevice error: Failed with ret %{public}d", ret); + // return ret; + // } DmTraceEnd(); LOGI("End"); return DM_OK; @@ -1551,20 +1581,20 @@ int32_t DeviceManagerImpl::UnBindDevice(const std::string &pkgName, const std::s } LOGI("Start, pkgName: %{public}s, deviceId: %{public}s", pkgName.c_str(), GetAnonyString(std::string(deviceId)).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetDeviceId(deviceId); - int32_t ret = ipcClientProxy_->SendRequest(UNBIND_DEVICE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetDeviceId(deviceId); + int32_t ret = deviceManagerInterface_->UnBindDevice(pkgName, deviceId, ""); if (ret != DM_OK) { LOGE("UnBindDevice error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("UnBindDevice error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("UnBindDevice error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("End"); return DM_OK; @@ -1579,22 +1609,22 @@ int32_t DeviceManagerImpl::UnBindDevice(const std::string &pkgName, const std::s } LOGI("Start, pkgName: %{public}s, deviceId: %{public}s", pkgName.c_str(), GetAnonyString(std::string(deviceId)).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetDeviceId(deviceId); - req->SetExtraInfo(extra); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetDeviceId(deviceId); + // req->SetExtraInfo(extra); LOGI("DeviceManagerImpl::UnBindDevice extra: %{public}s.", extra.c_str()); - int32_t ret = ipcClientProxy_->SendRequest(UNBIND_DEVICE, req, rsp); + int32_t ret = deviceManagerInterface_->UnBindDevice(pkgName, deviceId, extra); if (ret != DM_OK) { LOGE("UnBindDevice error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("UnBindDevice error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("UnBindDevice error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("End"); return DM_OK; @@ -1610,23 +1640,23 @@ int32_t DeviceManagerImpl::GetNetworkTypeByNetworkId(const std::string &pkgName, } LOGI("Start, pkgName: %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(netWorkId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(netWorkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_NETWORKTYPE_BY_NETWORK, req, rsp); + int32_t ret = deviceManagerInterface_->GetNetworkTypeByNetworkId(pkgName, netWorkId, netWorkType); if (ret != DM_OK) { LOGI("GetNetworkTypeByNetworkId Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CheckAuthentication Failed with ret %{public}d", ret); - return ret; - } - netWorkType = rsp->GetNetworkType(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CheckAuthentication Failed with ret %{public}d", ret); + // return ret; + // } + // netWorkType = rsp->GetNetworkType(); return DM_OK; } @@ -1651,22 +1681,22 @@ int32_t DeviceManagerImpl::ImportAuthCode(const std::string &pkgName, const std: } } - std::shared_ptr req = std::make_shared(); - req->SetAuthCode(authCode); - req->SetPkgName(pkgName); - std::shared_ptr rsp = std::make_shared(); + // std::shared_ptr req = std::make_shared(); + // req->SetAuthCode(authCode); + // req->SetPkgName(pkgName); + // std::shared_ptr rsp = std::make_shared(); - int32_t ret = ipcClientProxy_->SendRequest(IMPORT_AUTH_CODE, req, rsp); + int32_t ret = deviceManagerInterface_->ImportAuthCode(pkgName, authCode); if (ret != DM_OK) { LOGI("ImportAuthCode Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("ImportAuthCode Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("ImportAuthCode Failed with ret %{public}d", ret); + // return ret; + // } return DM_OK; } @@ -1674,22 +1704,22 @@ int32_t DeviceManagerImpl::ExportAuthCode(std::string &authCode) { LOGI("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); - int32_t ret = ipcClientProxy_->SendRequest(EXPORT_AUTH_CODE, req, rsp); + int32_t ret = deviceManagerInterface_->ExportAuthCode(authCode); if (ret != DM_OK) { LOGI("ExportAuthCode Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("ExportAuthCode Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("ExportAuthCode Failed with ret %{public}d", ret); + // return ret; + // } - authCode = rsp->GetAuthCode(); + // authCode = rsp->GetAuthCode(); LOGI("Success, authCode: %{public}s.", GetAnonyString(authCode).c_str()); return DM_OK; } @@ -1708,21 +1738,21 @@ int32_t DeviceManagerImpl::RegisterDiscoveryCallback(const std::string &pkgName, std::string discParaStr = ConvertMapToJsonString(discoverParam); std::string filterOpStr = ConvertMapToJsonString(filterOptions); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(ComposeStr(pkgName, subscribeId)); - req->SetFirstParam(discParaStr); - req->SetSecondParam(filterOpStr); - int32_t ret = ipcClientProxy_->SendRequest(REGISTER_DISCOVERY_CALLBACK, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(ComposeStr(pkgName, subscribeId)); + // req->SetFirstParam(discParaStr); + // req->SetSecondParam(filterOpStr); + int32_t ret = deviceManagerInterface_->RegisterDiscoveryCallback(pkgName, discoverParam, filterOptions); if (ret != DM_OK) { LOGE("RegisterDiscoveryCallback error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("RegisterDiscoveryCallback error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("RegisterDiscoveryCallback error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -1748,24 +1778,24 @@ int32_t DeviceManagerImpl::UnRegisterDiscoveryCallback(const std::string &pkgNam extraParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId)); std::string extraParaStr = ConvertMapToJsonString(extraParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(ComposeStr(pkgName, subscribeId)); - req->SetFirstParam(extraParaStr); - int32_t ret = ipcClientProxy_->SendRequest(UNREGISTER_DISCOVERY_CALLBACK, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(ComposeStr(pkgName, subscribeId)); + // req->SetFirstParam(extraParaStr); + int32_t ret = deviceManagerInterface_->UnRegisterDiscoveryCallback(pkgName); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgNameTemp, "UnRegisterDiscoveryCallback", ret, anonyLocalUdid_); LOGE("UnRegisterDiscoveryCallback error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgNameTemp, "UnRegisterDiscoveryCallback", - ret, anonyLocalUdid_); - LOGE("UnRegisterDiscoveryCallback error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgNameTemp, "UnRegisterDiscoveryCallback", + // ret, anonyLocalUdid_); + // LOGE("UnRegisterDiscoveryCallback error: Failed with ret %{public}d", ret); + // return ret; + // } RemoveDiscoveryCallback(pkgNameTemp); DmRadarHelper::GetInstance().ReportDmBehavior(pkgNameTemp, "UnRegisterDiscoveryCallback", DM_OK, anonyLocalUdid_); LOGI("Completed"); @@ -1790,20 +1820,20 @@ int32_t DeviceManagerImpl::StartAdvertising(const std::string &pkgName, } std::string adverParaStr = ConvertMapToJsonString(advertiseParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetFirstParam(adverParaStr); - int32_t ret = ipcClientProxy_->SendRequest(START_ADVERTISING, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetFirstParam(adverParaStr); + int32_t ret = deviceManagerInterface_->StartAdvertising(pkgName, adverParaStr); if (ret != DM_OK) { LOGE("StartAdvertising error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("StartAdvertising error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("StartAdvertising error: Failed with ret %{public}d", ret); + // return ret; + // } DeviceManagerNotify::GetInstance().RegisterPublishCallback(pkgName, publishId, callback); LOGI("Completed"); return DM_OK; @@ -1831,20 +1861,20 @@ int32_t DeviceManagerImpl::StopAdvertising(const std::string &pkgName, } std::string adverParaStr = ConvertMapToJsonString(advertiseParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetFirstParam(adverParaStr); - int32_t ret = ipcClientProxy_->SendRequest(STOP_ADVERTISING, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetFirstParam(adverParaStr); + int32_t ret = deviceManagerInterface_->StopAdvertising(pkgName, adverParaStr); if (ret != DM_OK) { LOGE("StopAdvertising error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("StopAdvertising error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("StopAdvertising error: Failed with ret %{public}d", ret); + // return ret; + // } DeviceManagerNotify::GetInstance().UnRegisterPublishCallback(pkgName, publishId); LOGI("Completed"); return DM_OK; @@ -1863,21 +1893,22 @@ int32_t DeviceManagerImpl::BindTarget(const std::string &pkgName, const PeerTarg #endif std::string bindParamStr = ConvertMapToJsonString(bindParam); DeviceManagerNotify::GetInstance().RegisterBindCallback(pkgName, targetId, callback); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetPeerTargetId(targetId); - req->SetBindParam(bindParamStr); - int32_t ret = ipcClientProxy_->SendRequest(BIND_TARGET, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetPeerTargetId(targetId); + // req->SetBindParam(bindParamStr); + PeerTargetIdExt targetIdExt(targetId); + int32_t ret = deviceManagerInterface_->BindTarget(pkgName, targetIdExt, bindParamStr); if (ret != DM_OK) { LOGE("BindTarget error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("BindTarget error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("BindTarget error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; @@ -1893,21 +1924,22 @@ int32_t DeviceManagerImpl::UnbindTarget(const std::string &pkgName, const PeerTa LOGI("Start, pkgName: %{public}s", pkgName.c_str()); std::string unbindParamStr = ConvertMapToJsonString(unbindParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetPeerTargetId(targetId); - req->SetBindParam(unbindParamStr); - int32_t ret = ipcClientProxy_->SendRequest(UNBIND_TARGET, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetPeerTargetId(targetId); + // req->SetBindParam(unbindParamStr); + PeerTargetIdExt targetIdExt(targetId); + int32_t ret = deviceManagerInterface_->UnbindTarget(pkgName, targetIdExt, unbindParamStr); if (ret != DM_OK) { LOGE("UnbindTarget error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("UnbindTarget error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("UnbindTarget error: Failed with ret %{public}d", ret); + // return ret; + // } DeviceManagerNotify::GetInstance().RegisterUnbindCallback(pkgName, targetId, callback); LOGI("Completed"); @@ -2040,22 +2072,22 @@ int32_t DeviceManagerImpl::RegisterPinHolderCallback(const std::string &pkgName, return ERR_DM_INPUT_PARA_INVALID; } DeviceManagerNotify::GetInstance().RegisterPinHolderCallback(pkgName, callback); - std::shared_ptr req = std::make_shared(); - req->SetPkgName(pkgName); - std::shared_ptr rsp = std::make_shared(); + // std::shared_ptr req = std::make_shared(); + // req->SetPkgName(pkgName); + // std::shared_ptr rsp = std::make_shared(); - int32_t ret = ipcClientProxy_->SendRequest(REGISTER_PIN_HOLDER_CALLBACK, req, rsp); + int32_t ret = deviceManagerInterface_->RegisterPinHolderCallback(pkgName); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "RegisterPinHolderCallback", ret, anonyLocalUdid_); LOGI("RegisterPinHolderCallback Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "RegisterPinHolderCallback", ret, anonyLocalUdid_); - LOGE("RegisterPinHolderCallback Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "RegisterPinHolderCallback", ret, anonyLocalUdid_); + // LOGE("RegisterPinHolderCallback Failed with ret %{public}d", ret); + // return ret; + // } DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "RegisterPinHolderCallback", DM_OK, anonyLocalUdid_); return DM_OK; } @@ -2070,23 +2102,24 @@ int32_t DeviceManagerImpl::CreatePinHolder(const std::string &pkgName, const Pee "%{public}zu", pkgName.c_str(), pinType, payload.length()); return ERR_DM_INPUT_PARA_INVALID; } - std::shared_ptr req = std::make_shared(); - req->SetPkgName(pkgName); - req->SetPeerTargetId(targetId); - req->SetPinType(pinType); - req->SetPayload(payload); - std::shared_ptr rsp = std::make_shared(); - - int32_t ret = ipcClientProxy_->SendRequest(CREATE_PIN_HOLDER, req, rsp); + // std::shared_ptr req = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetPeerTargetId(targetId); + // req->SetPinType(pinType); + // req->SetPayload(payload); + // std::shared_ptr rsp = std::make_shared(); + PeerTargetIdExt targetIdExt(targetId); + int32_t pinTypeInt = static_cast(pinType); + int32_t ret = deviceManagerInterface_->CreatePinHolder(pkgName, targetIdExt, pinTypeInt, payload); if (ret != DM_OK) { LOGI("CreatePinHolder Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("CreatePinHolder Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("CreatePinHolder Failed with ret %{public}d", ret); + // return ret; + // } return DM_OK; } @@ -2100,23 +2133,24 @@ int32_t DeviceManagerImpl::DestroyPinHolder(const std::string &pkgName, const Pe "%{public}zu", pkgName.c_str(), pinType, payload.length()); return ERR_DM_INPUT_PARA_INVALID; } - std::shared_ptr req = std::make_shared(); - req->SetPkgName(pkgName); - req->SetPeerTargetId(targetId); - req->SetPinType(pinType); - req->SetPayload(payload); - std::shared_ptr rsp = std::make_shared(); - - int32_t ret = ipcClientProxy_->SendRequest(DESTROY_PIN_HOLDER, req, rsp); + // std::shared_ptr req = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetPeerTargetId(targetId); + // req->SetPinType(pinType); + // req->SetPayload(payload); + // std::shared_ptr rsp = std::make_shared(); + PeerTargetIdExt targetIdExt(targetId); + int32_t pinTypeInt = static_cast(pinType); + int32_t ret = deviceManagerInterface_->DestroyPinHolder(pkgName, targetIdExt, pinTypeInt, payload); if (ret != DM_OK) { LOGI("DestroyPinHolder Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("DestroyPinHolder Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("DestroyPinHolder Failed with ret %{public}d", ret); + // return ret; + // } return DM_OK; } @@ -2127,19 +2161,19 @@ int32_t DeviceManagerImpl::DpAclAdd(const int64_t accessControlId, const std::st LOGI("DeviceManagerImpl::DpAclAdd is not identical account"); return DM_OK; } - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetStr(udid); - int32_t ret = ipcClientProxy_->SendRequest(DP_ACL_ADD, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetStr(udid); + int32_t ret = deviceManagerInterface_->DpAclAdd(accessControlId, udid, bindType); if (ret != DM_OK) { LOGE("DpAclAdd error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("DpAclAdd error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("DpAclAdd error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2157,25 +2191,25 @@ int32_t DeviceManagerImpl::GetDeviceSecurityLevel(const std::string &pkgName, co LOGI("Start: pkgName: %{public}s, networkId: %{public}s", pkgName.c_str(), GetAnonyString(networkId).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(networkId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(networkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_SECURITY_LEVEL, req, rsp); + int32_t ret = deviceManagerInterface_->GetDeviceSecurityLevel(pkgName, networkId, securityLevel); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "GetDeviceSecurityLevel", ret, anonyLocalUdid_); LOGE("GetDeviceSecurityLevel Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "GetDeviceSecurityLevel", ret, anonyLocalUdid_); - LOGE("GetDeviceSecurityLevel Failed with ret %{public}d", ret); - return ret; - } - securityLevel = rsp->GetSecurityLevel(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "GetDeviceSecurityLevel", ret, anonyLocalUdid_); + // LOGE("GetDeviceSecurityLevel Failed with ret %{public}d", ret); + // return ret; + // } + // securityLevel = rsp->GetSecurityLevel(); DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "GetDeviceSecurityLevel", DM_OK, anonyLocalUdid_); return DM_OK; } @@ -2183,20 +2217,20 @@ int32_t DeviceManagerImpl::GetDeviceSecurityLevel(const std::string &pkgName, co int32_t DeviceManagerImpl::CheckApiPermission(int32_t permissionLevel) { LOGI("PermissionLevel: %{public}d", permissionLevel); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPermissionLevel(permissionLevel); - int32_t ret = ipcClientProxy_->SendRequest(CHECK_API_PERMISSION, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPermissionLevel(permissionLevel); + int32_t ret = deviceManagerInterface_->CheckApiPermission(permissionLevel); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Check permission failed with ret: %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Check permission failed with ret: %{public}d", ret); + // return ret; + // } LOGD("The caller declare the DM permission!"); return DM_OK; } @@ -2207,15 +2241,16 @@ bool DeviceManagerImpl::IsSameAccount(const std::string &netWorkId) LOGE("DeviceManagerImpl::IsSameAccount error: netWorkId: %{public}s", GetAnonyString(netWorkId).c_str()); return false; } - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetStr(netWorkId); - int32_t ret = ipcClientProxy_->SendRequest(IS_SAME_ACCOUNT, req, rsp); - if (ret != DM_OK) { - LOGE("IsSameAccount Send Request failed ret: %{public}d", ret); - return false; - } - ret = rsp->GetErrCode(); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetStr(netWorkId); + bool result = false; + bool ret = deviceManagerInterface_->IsSameAccount(netWorkId, result); + // if (ret != DM_OK) { + // LOGE("IsSameAccount Send Request failed ret: %{public}d", ret); + // return false; + // } + // ret = rsp->GetErrCode(); if (ret != DM_OK) { LOGE("IsSameAccount Failed with ret: %{public}d", ret); return false; @@ -2226,22 +2261,25 @@ bool DeviceManagerImpl::IsSameAccount(const std::string &netWorkId) bool DeviceManagerImpl::CheckAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee) { LOGI("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetAccessCaller(caller); - req->SetAccessCallee(callee); - int32_t ret = ipcClientProxy_->SendRequest(CHECK_ACCESS_CONTROL, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetAccessCaller(caller); + // req->SetAccessCallee(callee); + DmAccessCallerExt callerExt(caller); + DmAccessCalleeExt calleeExt(callee); + bool funcResult = false; + int32_t ret = deviceManagerInterface_->CheckAccessControl(callerExt, calleeExt, funcResult); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckAccessControl", ret, anonyLocalUdid_); LOGE("CheckAccessControl Send Request failed ret: %{public}d", ret); return false; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckAccessControl", ret, anonyLocalUdid_); - LOGE("CheckAccessControl Failed with ret: %{public}d", ret); - return false; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckAccessControl", ret, anonyLocalUdid_); + // LOGE("CheckAccessControl Failed with ret: %{public}d", ret); + // return false; + // } DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckAccessControl", DM_OK, anonyLocalUdid_); return true; } @@ -2249,22 +2287,25 @@ bool DeviceManagerImpl::CheckAccessControl(const DmAccessCaller &caller, const D bool DeviceManagerImpl::CheckIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee) { LOGI("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetAccessCaller(caller); - req->SetAccessCallee(callee); - int32_t ret = ipcClientProxy_->SendRequest(CHECK_SAME_ACCOUNT, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetAccessCaller(caller); + // req->SetAccessCallee(callee); + DmAccessCallerExt callerExt(caller); + DmAccessCalleeExt calleeExt(callee); + bool funcResult = false; + int32_t ret = deviceManagerInterface_->CheckIsSameAccount(callerExt, calleeExt, funcResult); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckIsSameAccount", ret, anonyLocalUdid_); LOGE("CheckIsSameAccount Send Request failed ret: %{public}d", ret); return false; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckIsSameAccount", ret, anonyLocalUdid_); - LOGE("CheckIsSameAccount Failed with ret: %{public}d", ret); - return false; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckIsSameAccount", ret, anonyLocalUdid_); + // LOGE("CheckIsSameAccount Failed with ret: %{public}d", ret); + // return false; + // } DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckIsSameAccount", DM_OK, anonyLocalUdid_); return true; } @@ -2281,21 +2322,21 @@ int32_t DeviceManagerImpl::GetErrCode(int32_t errCode) int32_t DeviceManagerImpl::ShiftLNNGear(const std::string &pkgName) { LOGI("Start. pkgName = %{public}s", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(SHIFT_LNN_GEAR, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + int32_t ret = deviceManagerInterface_->ShiftLNNGear(pkgName); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "ShiftLNNGear", ret, anonyLocalUdid_); LOGE("ShiftLNNGear error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "ShiftLNNGear", ret, anonyLocalUdid_); - LOGE("ShiftLNNGear error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "ShiftLNNGear", ret, anonyLocalUdid_); + // LOGE("ShiftLNNGear error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "ShiftLNNGear", DM_OK, anonyLocalUdid_); return DM_OK; @@ -2311,24 +2352,24 @@ int32_t DeviceManagerImpl::SetDnPolicy(const std::string &pkgName, std::map req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetFirstParam(strategy); - int32_t ret = ipcClientProxy_->SendRequest(SET_DN_POLICY, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetFirstParam(strategy); + int32_t ret = deviceManagerInterface_->SetDnPolicy(pkgName, policy); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "SetDnPolicy", ret, anonyLocalUdid_); LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "SetDnPolicy", ret, anonyLocalUdid_); - LOGE("Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "SetDnPolicy", ret, anonyLocalUdid_); + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "SetDnPolicy", DM_OK, anonyLocalUdid_); return DM_OK; @@ -2384,23 +2425,23 @@ int32_t DeviceManagerImpl::GetDeviceScreenStatus(const std::string &pkgName, con } LOGI("Start: pkgName: %{public}s, networkId: %{public}s", pkgName.c_str(), GetAnonyString(networkId).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetNetWorkId(networkId); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetNetWorkId(networkId); - int32_t ret = ipcClientProxy_->SendRequest(GET_DEVICE_SCREEN_STATUS, req, rsp); + int32_t ret = deviceManagerInterface_->GetDeviceScreenStatus(pkgName, networkId, screenStatus); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } - screenStatus = rsp->GetScreenStatus(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } + // screenStatus = rsp->GetScreenStatus(); return DM_OK; } @@ -2414,23 +2455,23 @@ int32_t DeviceManagerImpl::GetNetworkIdByUdid(const std::string &pkgName, const } LOGD("Start, pkgName: %{public}s", GetAnonyString(pkgName).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetUdid(udid); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetUdid(udid); - int32_t ret = ipcClientProxy_->SendRequest(GET_NETWORKID_BY_UDID, req, rsp); + int32_t ret = deviceManagerInterface_->GetNetworkIdByUdid(pkgName, udid, networkId); if (ret != DM_OK) { LOGI("GetNetworkIdByUdid Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("GetNetworkIdByUdid Failed with ret %{public}d", ret); - return ret; - } - networkId = rsp->GetNetWorkId(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("GetNetworkIdByUdid Failed with ret %{public}d", ret); + // return ret; + // } + // networkId = rsp->GetNetWorkId(); return DM_OK; } @@ -2485,21 +2526,21 @@ int32_t DeviceManagerImpl::UnRegisterSinkBindCallback(const std::string &pkgName int32_t DeviceManagerImpl::GetAnonyLocalUdid(const std::string &pkgName, std::string &anonyUdid) { LOGD("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(GET_ANONY_LOCAL_UDID, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + int32_t ret = deviceManagerInterface_->GetAnonyLocalUdid(pkgName, anonyUdid); if (ret != DM_OK) { LOGI("GetAnonyLocalUdid Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("GetAnonyLocalUdid Failed with ret %{public}d", ret); - return ret; - } - anonyUdid = rsp->GetAnonyUdid(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("GetAnonyLocalUdid Failed with ret %{public}d", ret); + // return ret; + // } + // anonyUdid = rsp->GetAnonyUdid(); return DM_OK; } @@ -2524,20 +2565,21 @@ void DeviceManagerImpl::SyncCallbackToService(DmCommonNotifyEvent dmCommonNotify LOGE("Invalid dmCommonNotifyEvent: %{public}d.", dmCommonNotifyEvent); return; } - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetDmCommonNotifyEvent(static_cast(dmCommonNotifyEvent)); - int32_t ret = ipcClientProxy_->SendRequest(SYNC_CALLBACK, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetDmCommonNotifyEvent(static_cast(dmCommonNotifyEvent)); + int32_t dmCommonNotifyEventInt = static_cast(dmCommonNotifyEvent); + int32_t ret = deviceManagerInterface_->SyncCallbackToService(dmCommonNotifyEventInt, pkgName); if (ret != DM_OK) { LOGI("Send Request failed ret: %{public}d", ret); return; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return; + // } } int32_t DeviceManagerImpl::GetAllTrustedDeviceList(const std::string &pkgName, const std::string &extra, @@ -2553,11 +2595,12 @@ int32_t DeviceManagerImpl::GetAllTrustedDeviceList(const std::string &pkgName, c LOGI("Start, pkgName: %{public}s, extra: %{public}s", GetAnonyString(pkgName).c_str(), GetAnonyString(extra).c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetExtra(extra); - int32_t ret = ipcClientProxy_->SendRequest(GET_ALL_TRUST_DEVICE_LIST, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetExtra(extra); + std::vector deviceListExt; + int32_t ret = deviceManagerInterface_->GetAllTrustedDeviceList(pkgName, extra, deviceListExt); if (ret != DM_OK) { DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetAllTrustedDeviceList", deviceList, ret, anonyLocalUdid_); @@ -2565,15 +2608,15 @@ int32_t DeviceManagerImpl::GetAllTrustedDeviceList(const std::string &pkgName, c return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetAllTrustedDeviceList", - deviceList, ret, anonyLocalUdid_); - LOGE("GetAllTrustedDeviceList error, failed ret: %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetAllTrustedDeviceList", + // deviceList, ret, anonyLocalUdid_); + // LOGE("GetAllTrustedDeviceList error, failed ret: %{public}d", ret); + // return ret; + // } - deviceList = rsp->GetDeviceVec(); + // deviceList = rsp->GetDeviceVec(); LOGI("Completed, device size %{public}zu", deviceList.size()); DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetAllTrustedDeviceList", deviceList, DM_OK, anonyLocalUdid_); @@ -2608,20 +2651,20 @@ int32_t DeviceManagerImpl::RegisterAuthenticationType(const std::string &pkgName LOGI("Start"); std::string authTypeStr = ConvertMapToJsonString(authParam); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetFirstParam(authTypeStr); - int32_t ret = ipcClientProxy_->SendRequest(REG_AUTHENTICATION_TYPE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetFirstParam(authTypeStr); + int32_t ret = deviceManagerInterface_->RegisterAuthenticationType(pkgName, authTypeStr); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2690,20 +2733,21 @@ int32_t DeviceManagerImpl::PutDeviceProfileInfoList(const std::string &pkgName, const std::vector &deviceProfileInfoList) { LOGI("In pkgName:%{public}s,", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetDeviceProfileInfoList(deviceProfileInfoList); - int32_t ret = ipcClientProxy_->SendRequest(PUT_DEVICE_PROFILE_INFO_LIST, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetDeviceProfileInfoList(deviceProfileInfoList); + std::vector deviceProfileInfoListExt; + int32_t ret = deviceManagerInterface_->PutDeviceProfileInfoList(pkgName, deviceProfileInfoListExt); if (ret != DM_OK) { LOGE("error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2712,21 +2756,21 @@ int32_t DeviceManagerImpl::GetLocalDisplayDeviceName(const std::string &pkgName, std::string &displayName) { LOGI("In pkgName:%{public}s,", pkgName.c_str()); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - req->SetMaxNameLength(maxNameLength); - int32_t ret = ipcClientProxy_->SendRequest(GET_LOCAL_DISPLAY_DEVICE_NAME, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + // req->SetMaxNameLength(maxNameLength); + int32_t ret = deviceManagerInterface_->GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); if (ret != DM_OK) { return ERR_DM_IPC_SEND_REQUEST_FAILED; LOGE("error: Send Request failed ret: %{public}d", ret); } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("error: Failed with ret %{public}d", ret); - return ret; - } - displayName = rsp->GetDisplayName(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("error: Failed with ret %{public}d", ret); + // return ret; + // } + // displayName = rsp->GetDisplayName(); LOGI("Completed"); return DM_OK; } @@ -2734,19 +2778,19 @@ int32_t DeviceManagerImpl::GetLocalDisplayDeviceName(const std::string &pkgName, int32_t DeviceManagerImpl::RegisterLocalServiceInfo(const DMLocalServiceInfo &info) { LOGI("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetLocalServiceInfo(info); - int32_t ret = ipcClientProxy_->SendRequest(REG_LOCALSERVICE_INFO, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetLocalServiceInfo(info); + int32_t ret = deviceManagerInterface_->RegisterLocalServiceInfo(info); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2754,20 +2798,20 @@ int32_t DeviceManagerImpl::RegisterLocalServiceInfo(const DMLocalServiceInfo &in int32_t DeviceManagerImpl::UnRegisterLocalServiceInfo(const std::string &bundleName, int32_t pinExchangeType) { LOGI("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetFirstParam(bundleName); - req->SetInt32Param(pinExchangeType); - int32_t ret = ipcClientProxy_->SendRequest(UNREG_LOCALSERVICE_INFO, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetFirstParam(bundleName); + // req->SetInt32Param(pinExchangeType); + int32_t ret = deviceManagerInterface_->UnRegisterLocalServiceInfo(bundleName, pinExchangeType); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2775,19 +2819,19 @@ int32_t DeviceManagerImpl::UnRegisterLocalServiceInfo(const std::string &bundleN int32_t DeviceManagerImpl::UpdateLocalServiceInfo(const DMLocalServiceInfo &info) { LOGI("Start"); - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetLocalServiceInfo(info); - int32_t ret = ipcClientProxy_->SendRequest(UPDATE_LOCALSERVICE_INFO, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetLocalServiceInfo(info); + int32_t ret = deviceManagerInterface_->UpdateLocalServiceInfo(info); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2795,21 +2839,22 @@ int32_t DeviceManagerImpl::UpdateLocalServiceInfo(const DMLocalServiceInfo &info int32_t DeviceManagerImpl::GetLocalServiceInfoByBundleNameAndPinExchangeType( const std::string &bundleName, int32_t pinExchangeType, DMLocalServiceInfo &info) { - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetFirstParam(bundleName); - req->SetInt32Param(pinExchangeType); - int32_t ret = ipcClientProxy_->SendRequest(GET_SERVICEINFO_BYBUNDLENAME_PINEXCHANGETYPE, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetFirstParam(bundleName); + // req->SetInt32Param(pinExchangeType); + DMLocalServiceInfoExt dmLocalServiceInfoExt(info); + int32_t ret = deviceManagerInterface_->GetLocalServiceInfoByBundleNameAndPinExchangeType(bundleName, pinExchangeType, dmLocalServiceInfoExt); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } - info = rsp->GetLocalServiceInfo(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } + // info = rsp->GetLocalServiceInfo(); LOGI("Completed"); return DM_OK; } @@ -2888,19 +2933,19 @@ int32_t DeviceManagerImpl::RestoreLocalDeviceName(const std::string &pkgName) LOGE("param invalid, pkgName : %{public}s", pkgName.c_str()); return ERR_DM_INPUT_PARA_INVALID; } - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(pkgName); - int32_t ret = ipcClientProxy_->SendRequest(RESTORE_LOCAL_DEVICE_NAME, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(pkgName); + int32_t ret = deviceManagerInterface_->RestoreLocalDeviceName(pkgName); if (ret != DM_OK) { LOGE("error: Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("error: Failed with ret %{public}d", ret); - return ret; - } + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("error: Failed with ret %{public}d", ret); + // return ret; + // } LOGI("Completed"); return DM_OK; } @@ -2908,21 +2953,22 @@ int32_t DeviceManagerImpl::RestoreLocalDeviceName(const std::string &pkgName) int32_t DeviceManagerImpl::GetDeviceNetworkIdList(const std::string &bundleName, const NetworkIdQueryFilter &queryFilter, std::vector &networkIds) { - std::shared_ptr req = std::make_shared(); - std::shared_ptr rsp = std::make_shared(); - req->SetPkgName(bundleName); - req->SetQueryFilter(queryFilter); - int32_t ret = ipcClientProxy_->SendRequest(GET_DEVICE_NETWORK_ID_LIST, req, rsp); + // std::shared_ptr req = std::make_shared(); + // std::shared_ptr rsp = std::make_shared(); + // req->SetPkgName(bundleName); + // req->SetQueryFilter(queryFilter); + NetworkIdQueryFilterExt networkIdQueryFilterExt(queryFilter); + int32_t ret = deviceManagerInterface_->GetDeviceNetworkIdList(bundleName, networkIdQueryFilterExt, networkIds); if (ret != DM_OK) { LOGE("Send Request failed ret: %{public}d", ret); return ERR_DM_IPC_SEND_REQUEST_FAILED; } - ret = rsp->GetErrCode(); - if (ret != DM_OK) { - LOGE("Failed with ret %{public}d", ret); - return ret; - } - networkIds = rsp->GetNetworkIds(); + // ret = rsp->GetErrCode(); + // if (ret != DM_OK) { + // LOGE("Failed with ret %{public}d", ret); + // return ret; + // } + // networkIds = rsp->GetNetworkIds(); LOGI("Completed"); return DM_OK; } diff --git a/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp b/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp index c80cbb4a4b72f9f5ce1096228e4d3b16335f732d..0bf7bcefd17d976fb90648e7c3c6c7bec2de96ac 100644 --- a/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp +++ b/interfaces/inner_kits/native_cpp/src/dm_device_info.cpp @@ -13,6 +13,15 @@ * limitations under the License. */ +#include +#include +#include + +#include "dm_device_info.h" + +#include "dm_log.h" +#include "dm_constants.h" + namespace OHOS { namespace DistributedHardware { const char* DEVICE_TYPE_UNKNOWN_STRING = "UNKNOWN"; @@ -25,5 +34,205 @@ const char* DEVICE_TYPE_WIFICAMERA_STRING = "WiFiCamera"; const char* DEVICE_TYPE_PC_STRING = "PC"; const char* DEVICE_TYPE_SMART_DISPLAY_STRING = "SMART_DISPLAY"; const char* DEVICE_TYPE_2IN1_STRING = "2IN1"; + +bool DmDeviceInfoExt::Marshalling(Parcel &parcel) const +{ + bool bRet = true; + std::string deviceIdStr(deviceId); + bRet = (bRet && parcel.WriteString(deviceIdStr)); + std::string deviceNameStr(deviceName); + bRet = (bRet && parcel.WriteString(deviceNameStr)); + bRet = (bRet && parcel.WriteUint16(deviceTypeId)); + std::string networkIdStr(networkId); + bRet = (bRet && parcel.WriteString(networkIdStr)); + bRet = (bRet && parcel.WriteInt32(range)); + bRet = (bRet && parcel.WriteInt32(networkType)); + bRet = (bRet && parcel.WriteInt32(static_cast(authForm))); + bRet = (bRet && parcel.WriteString(extraData)); + return bRet; +} + +DmDeviceInfoExt *DmDeviceInfoExt::Unmarshalling(Parcel &parcel) +{ + DmDeviceInfoExt *deviceInfoExt = new (std::nothrow) DmDeviceInfoExt(); + if (deviceInfoExt == nullptr) { + LOGE("Create DmDeviceInfoExt failed"); + return nullptr; + } + std::string deviceIdStr = parcel.ReadString(); + if (strcpy_s(deviceInfoExt->deviceId, deviceIdStr.size() + 1, deviceIdStr.c_str()) != DM_OK) { + LOGE("strcpy_s deviceId failed!"); + delete deviceInfoExt; + return nullptr; + } + std::string deviceNameStr = parcel.ReadString(); + if (strcpy_s(deviceInfoExt->deviceName, deviceNameStr.size() + 1, deviceNameStr.c_str()) != DM_OK) { + LOGE("strcpy_s deviceName failed!"); + delete deviceInfoExt; + return nullptr; + } + deviceInfoExt->deviceTypeId = parcel.ReadUint16(); + std::string networkIdStr = parcel.ReadString(); + if (strcpy_s(deviceInfoExt->networkId, networkIdStr.size() + 1, networkIdStr.c_str()) != DM_OK) { + LOGE("strcpy_s networkId failed!"); + delete deviceInfoExt; + return nullptr; + } + deviceInfoExt->range = parcel.ReadInt32(); + deviceInfoExt->networkType = parcel.ReadInt32(); + deviceInfoExt->authForm = static_cast(parcel.ReadInt32()); + deviceInfoExt->extraData = parcel.ReadString(); + return deviceInfoExt; +} + +bool PeerTargetIdExt::Marshalling(Parcel &parcel) const +{ + bool bRet = true; + bRet = (bRet && parcel.WriteString(deviceId)); + bRet = (bRet && parcel.WriteString(brMac)); + bRet = (bRet && parcel.WriteString(bleMac)); + bRet = (bRet && parcel.WriteString(wifiIp)); + bRet = (bRet && parcel.WriteUint16(wifiPort)); + return bRet; +} + +PeerTargetIdExt *PeerTargetIdExt::Unmarshalling(Parcel &parcel) +{ + PeerTargetIdExt *targetIdExt = new (std::nothrow) PeerTargetIdExt(); + if (targetIdExt == nullptr) { + LOGE("Create PeerTargetIdExt failed"); + return nullptr; + } + targetIdExt->deviceId = parcel.ReadString(); + targetIdExt->brMac = parcel.ReadString(); + targetIdExt->bleMac = parcel.ReadString(); + targetIdExt->wifiIp = parcel.ReadString(); + targetIdExt->wifiPort = parcel.ReadUint16(); + return targetIdExt; +} + +bool DmAccessCallerExt::Marshalling(Parcel &parcel) const +{ + bool bRet = true; + bRet = (bRet && parcel.WriteString(accountId)); + bRet = (bRet && parcel.WriteString(pkgName)); + bRet = (bRet && parcel.WriteString(networkId)); + bRet = (bRet && parcel.WriteInt32(userId)); + bRet = (bRet && parcel.WriteUint64(tokenId)); + bRet = (bRet && parcel.WriteString(extra)); + return bRet; +} + +DmAccessCallerExt *DmAccessCallerExt::Unmarshalling(Parcel &parcel) +{ + DmAccessCallerExt *callerExt = new (std::nothrow) DmAccessCallerExt(); + if (callerExt == nullptr) { + LOGE("Create DmAccessCallerExt failed"); + return nullptr; + } + callerExt->accountId = parcel.ReadString(); + callerExt->pkgName = parcel.ReadString(); + callerExt->networkId = parcel.ReadString(); + callerExt->userId = parcel.ReadInt32(); + callerExt->tokenId = parcel.ReadUint64(); + callerExt->extra = parcel.ReadString(); + return callerExt; +} + +bool DmAccessCalleeExt::Marshalling(Parcel &parcel) const +{ + bool bRet = true; + bRet = (bRet && parcel.WriteString(accountId)); + bRet = (bRet && parcel.WriteString(networkId)); + bRet = (bRet && parcel.WriteString(peerId)); + bRet = (bRet && parcel.WriteInt32(userId)); + bRet = (bRet && parcel.WriteString(extra)); + return bRet; +} + +DmAccessCalleeExt *DmAccessCalleeExt::Unmarshalling(Parcel &parcel) +{ + DmAccessCalleeExt *calleeExt = new (std::nothrow) DmAccessCalleeExt(); + if (calleeExt == nullptr) { + LOGE("Create DmAccessCallerExt failed"); + return nullptr; + } + calleeExt->accountId = parcel.ReadString(); + calleeExt->networkId = parcel.ReadString(); + calleeExt->peerId = parcel.ReadString(); + calleeExt->userId = parcel.ReadInt32(); + calleeExt->extra = parcel.ReadString(); + + return calleeExt; +} + +bool DmDeviceBasicInfoExt::Marshalling(Parcel &parcel) const +{ + bool bRet = true; + std::string deviceIdStr(deviceId); + bRet = (bRet && parcel.WriteString(deviceIdStr)); + std::string deviceNameStr(deviceName); + bRet = (bRet && parcel.WriteString(deviceNameStr)); + bRet = (bRet && parcel.WriteUint16(deviceTypeId)); + std::string networkIdStr(networkId); + bRet = (bRet && parcel.WriteString(networkIdStr)); + return bRet; +} + +DmDeviceBasicInfoExt *DmDeviceBasicInfoExt::Unmarshalling(Parcel &parcel) +{ + DmDeviceBasicInfoExt *deviceBasicInfoExt = new (std::nothrow) DmDeviceBasicInfoExt(); + if (deviceBasicInfoExt == nullptr) { + LOGE("Create DmDeviceBasicInfoExt failed"); + return nullptr; + } + std::string deviceIdStr = parcel.ReadString(); + if (strcpy_s(deviceBasicInfoExt->deviceId, deviceIdStr.size() + 1, deviceIdStr.c_str()) != DM_OK) { + LOGE("strcpy_s deviceId failed!"); + return nullptr; + } + std::string deviceNameStr = parcel.ReadString(); + if (strcpy_s(deviceBasicInfoExt->deviceName, deviceNameStr.size() + 1, deviceNameStr.c_str()) != DM_OK) { + LOGE("strcpy_s deviceName failed!"); + return nullptr; + } + deviceBasicInfoExt->deviceTypeId = parcel.ReadUint16(); + std::string networkIdStr = parcel.ReadString(); + if (strcpy_s(deviceBasicInfoExt->networkId, networkIdStr.size() + 1, networkIdStr.c_str()) != DM_OK) { + LOGE("strcpy_s networkId failed!"); + return nullptr; + } + return deviceBasicInfoExt; +} + +bool DMLocalServiceInfoExt::Marshalling(Parcel &parcel) const +{ + bool bRet = true; + bRet = (bRet && parcel.WriteString(bundleName)); + bRet = (bRet && parcel.WriteInt32(authBoxType)); + bRet = (bRet && parcel.WriteInt32(authType)); + bRet = (bRet && parcel.WriteInt32(pinExchangeType)); + bRet = (bRet && parcel.WriteString(pinCode)); + bRet = (bRet && parcel.WriteString(description)); + bRet = (bRet && parcel.WriteString(extraInfo)); + return bRet; +} + +DMLocalServiceInfoExt *DMLocalServiceInfoExt::Unmarshalling(Parcel &parcel) +{ + DMLocalServiceInfoExt *localServiceinfoExt = new (std::nothrow) DMLocalServiceInfoExt(); + if (localServiceinfoExt == nullptr) { + LOGE("Create DMLocalServiceInfoExt failed"); + return nullptr; + } + localServiceinfoExt->bundleName = parcel.ReadString(); + localServiceinfoExt->authBoxType = parcel.ReadInt32(); + localServiceinfoExt->authType = parcel.ReadInt32(); + localServiceinfoExt->pinExchangeType = parcel.ReadInt32(); + localServiceinfoExt->pinCode = parcel.ReadString(); + localServiceinfoExt->description = parcel.ReadString(); + localServiceinfoExt->extraInfo = parcel.ReadString(); + return localServiceinfoExt; +} } // namespace DistributedHardware } // namespace OHOS \ No newline at end of file diff --git a/interfaces/inner_kits/native_cpp/src/dm_device_profile_info.cpp b/interfaces/inner_kits/native_cpp/src/dm_device_profile_info.cpp new file mode 100644 index 0000000000000000000000000000000000000000..55f44e7b38c41d705cddc9c15e128153c8e55d08 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/dm_device_profile_info.cpp @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + #include + #include + #include + + #include "dm_device_profile_info.h" + #include "dm_log.h" + + namespace OHOS { + namespace DistributedHardware { + bool DmDeviceProfileInfoExt::Marshalling(Parcel &parcel) const + { + bool bRet = true; + bRet = (bRet && parcel.WriteString(deviceId)); + bRet = (bRet && parcel.WriteString(deviceSn)); + bRet = (bRet && parcel.WriteString(mac)); + bRet = (bRet && parcel.WriteString(model)); + bRet = (bRet && parcel.WriteString(internalModel)); + bRet = (bRet && parcel.WriteString(deviceType)); + bRet = (bRet && parcel.WriteString(manufacturer)); + bRet = (bRet && parcel.WriteString(deviceName)); + bRet = (bRet && parcel.WriteString(productId)); + bRet = (bRet && parcel.WriteString(subProductId)); + bRet = (bRet && parcel.WriteString(sdkVersion)); + bRet = (bRet && parcel.WriteString(bleMac)); + bRet = (bRet && parcel.WriteString(brMac)); + bRet = (bRet && parcel.WriteString(sleMac)); + bRet = (bRet && parcel.WriteString(firmwareVersion)); + bRet = (bRet && parcel.WriteString(hardwareVersion)); + bRet = (bRet && parcel.WriteString(softwareVersion)); + bRet = (bRet && parcel.WriteInt32(protocolType)); + bRet = (bRet && parcel.WriteInt32(setupType)); + bRet = (bRet && parcel.WriteString(wiseDeviceId)); + bRet = (bRet && parcel.WriteString(wiseUserId)); + bRet = (bRet && parcel.WriteString(registerTime)); + bRet = (bRet && parcel.WriteString(modifyTime)); + bRet = (bRet && parcel.WriteString(shareTime)); + bRet = (bRet && parcel.WriteBool(isLocalDevice)); + + return bRet; + } + + DmDeviceProfileInfoExt *DmDeviceProfileInfoExt::Unmarshalling(Parcel &parcel) + { + DmDeviceProfileInfoExt *profileInfoExt = new (std::nothrow) DmDeviceProfileInfoExt(); + if (profileInfoExt == nullptr) { + LOGE("Create DmDeviceProfileInfoExt failed"); + return nullptr; + } + profileInfoExt->deviceId = parcel.ReadString(); + profileInfoExt->deviceSn = parcel.ReadString(); + profileInfoExt->mac = parcel.ReadString(); + profileInfoExt->model = parcel.ReadString(); + profileInfoExt->internalModel = parcel.ReadString(); + profileInfoExt->deviceType = parcel.ReadString(); + profileInfoExt->manufacturer = parcel.ReadString(); + profileInfoExt->deviceName = parcel.ReadString(); + profileInfoExt->productId = parcel.ReadString(); + profileInfoExt->subProductId = parcel.ReadString(); + profileInfoExt->sdkVersion = parcel.ReadString(); + profileInfoExt->bleMac = parcel.ReadString(); + profileInfoExt->brMac = parcel.ReadString(); + profileInfoExt->sleMac = parcel.ReadString(); + profileInfoExt->firmwareVersion = parcel.ReadString(); + profileInfoExt->hardwareVersion = parcel.ReadString(); + profileInfoExt->softwareVersion = parcel.ReadString(); + profileInfoExt->protocolType = parcel.ReadInt32(); + profileInfoExt->setupType = parcel.ReadInt32(); + profileInfoExt->wiseDeviceId = parcel.ReadString(); + profileInfoExt->wiseUserId = parcel.ReadString(); + profileInfoExt->registerTime = parcel.ReadString(); + profileInfoExt->modifyTime = parcel.ReadString(); + profileInfoExt->shareTime = parcel.ReadString(); + profileInfoExt->isLocalDevice = parcel.ReadBool(); + + return profileInfoExt; + } + + bool NetworkIdQueryFilterExt::Marshalling(Parcel &parcel) const + { + bool bRet = true; + bRet = (bRet && parcel.WriteString(wiseDeviceId)); + bRet = (bRet && parcel.WriteInt32(onlineStatus)); + bRet = (bRet && parcel.WriteString(deviceType)); + bRet = (bRet && parcel.WriteString(deviceProductId)); + bRet = (bRet && parcel.WriteString(deviceModel)); + return bRet; + } + + NetworkIdQueryFilterExt *NetworkIdQueryFilterExt::Unmarshalling(Parcel &parcel) + { + NetworkIdQueryFilterExt *networkIdQueryExt = new (std::nothrow) NetworkIdQueryFilterExt(); + if (networkIdQueryExt == nullptr) { + LOGE("Create NetworkIdQueryFilterExt failed"); + return nullptr; + } + networkIdQueryExt->wiseDeviceId = parcel.ReadString(); + networkIdQueryExt->onlineStatus = parcel.ReadInt32(); + networkIdQueryExt->deviceType = parcel.ReadString(); + networkIdQueryExt->deviceProductId = parcel.ReadString(); + networkIdQueryExt->deviceModel = parcel.ReadString(); + return networkIdQueryExt; + } + } // namespace DistributedHardware + } // namespace OHOS diff --git a/interfaces/inner_kits/native_cpp/src/dm_publish_info.cpp b/interfaces/inner_kits/native_cpp/src/dm_publish_info.cpp new file mode 100644 index 0000000000000000000000000000000000000000..81f45f4ec5398f5ff5f96dc7752717636db683d0 --- /dev/null +++ b/interfaces/inner_kits/native_cpp/src/dm_publish_info.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + #include + #include + #include + + #include "dm_publish_info.h" + #include "dm_log.h" + + namespace OHOS { + namespace DistributedHardware { + bool DmPublishInfoExt::Marshalling(Parcel &parcel) const + { + bool bRet = true; + bRet = (bRet && parcel.WriteInt32(publishId)); + bRet = (bRet && parcel.WriteInt32(mode)); + bRet = (bRet && parcel.WriteInt32(freq)); + bRet = (bRet && parcel.WriteBool(ranging)); + return bRet; + } + + DmPublishInfoExt *DmPublishInfoExt::Unmarshalling(Parcel &parcel) + { + DmPublishInfoExt *publishInfo = new (std::nothrow) DmPublishInfoExt(); + if (publishInfo == nullptr) { + LOGE("Create DmPublishInfo failed"); + return nullptr; + } + publishInfo->publishId = parcel.ReadInt32(); + publishInfo->mode = static_cast(parcel.ReadInt32()); + publishInfo->freq = static_cast(parcel.ReadInt32()); + publishInfo->ranging = parcel.ReadBool(); + return publishInfo; + } + } // namespace DistributedHardware + } // namespace OHOS diff --git a/services/implementation/include/device_manager_service_impl.h b/services/implementation/include/device_manager_service_impl.h index 423e5be0f97b24201ee09d1fd99478b97be22ffb..7da1dce7fc3f41999ad9efb16fd7d9df60e81fb0 100644 --- a/services/implementation/include/device_manager_service_impl.h +++ b/services/implementation/include/device_manager_service_impl.h @@ -50,7 +50,7 @@ public: int32_t UnBindDevice(const std::string &pkgName, const std::string &udid, int32_t bindLevel, const std::string &extra); - int32_t SetUserOperation(std::string &pkgName, int32_t action, const std::string ¶ms); + int32_t SetUserOperation(const std::string &pkgName, int32_t action, const std::string ¶ms); void HandleDeviceStatusChange(DmDeviceState devState, DmDeviceInfo &devInfo); diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp index 12ad2f7fd1c914bfadfc2d17b64aa1b3aacac9c7..f6b034e0caa61bd8ae84c17a0014dd41b7d8c04a 100644 --- a/services/implementation/src/device_manager_service_impl.cpp +++ b/services/implementation/src/device_manager_service_impl.cpp @@ -149,7 +149,7 @@ int32_t DeviceManagerServiceImpl::UnBindDevice(const std::string &pkgName, const return authMgr_->UnBindDevice(pkgName, udid, bindLevel, extra); } -int32_t DeviceManagerServiceImpl::SetUserOperation(std::string &pkgName, int32_t action, +int32_t DeviceManagerServiceImpl::SetUserOperation(const std::string &pkgName, int32_t action, const std::string ¶ms) { if (pkgName.empty() || params.empty()) { diff --git a/services/service/BUILD.gn b/services/service/BUILD.gn index d76727825051b4345a1232d41bf2a27350eee210..a6e8e739bc696a24e931da03430642612885a625 100644 --- a/services/service/BUILD.gn +++ b/services/service/BUILD.gn @@ -151,6 +151,7 @@ if (defined(ohos_lite)) { "${innerkits_path}/native_cpp/include", "${servicesimpl_path}/include/dependency/deviceprofile", "${softbuscache_parh}/include", + "${utils_path}/include", "${utils_path}/include/appInfo/standard", "${utils_path}/include/crypto", "${utils_path}/include/kvadapter", @@ -211,6 +212,7 @@ if (defined(ohos_lite)) { "src/discovery/discovery_filter.cpp", "src/discovery/discovery_manager.cpp", "src/hichain/hichain_listener.cpp", + "src/ipc/standard/device_manager_client_service.cpp", "src/ipc/standard/ipc_cmd_parser.cpp", "src/ipc/standard/ipc_server_client_proxy.cpp", "src/ipc/standard/ipc_server_listener.cpp", @@ -229,6 +231,7 @@ if (defined(ohos_lite)) { "src/relationshipsyncmgr/relationship_sync_mgr.cpp", "src/softbus/mine_softbus_listener.cpp", "src/softbus/softbus_listener.cpp", + "${utils_path}/src/dm_ipc_utils.cpp", ] public_configs = [ ":devicemanagerservice_config" ] diff --git a/services/service/include/device_manager_service.h b/services/service/include/device_manager_service.h index 8b40da361de4cc8b9c948e410a4e99f8a483bb4d..9c75b81a3daa52fb56ddf34fb6aafe390630d752 100644 --- a/services/service/include/device_manager_service.h +++ b/services/service/include/device_manager_service.h @@ -99,7 +99,7 @@ public: int32_t UnBindDevice(const std::string &pkgName, const std::string &udidHash, const std::string &extra); - int32_t SetUserOperation(std::string &pkgName, int32_t action, const std::string ¶ms); + int32_t SetUserOperation(const std::string &pkgName, int32_t action, const std::string ¶ms); void HandleDeviceStatusChange(DmDeviceState devState, DmDeviceInfo &devInfo); @@ -198,7 +198,7 @@ public: void HandleUserStop(int32_t stopUserId, const std::string &stopEventUdid, const std::vector &acceptEventUdids); #endif - int32_t SetDnPolicy(const std::string &pkgName, std::map &policy); + int32_t SetDnPolicy(const std::string &pkgName, const std::map &policy); void ClearDiscoveryCache(const ProcessInfo &processInfo); void HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo); int32_t GetDeviceScreenStatus(const std::string &pkgName, const std::string &networkId, diff --git a/services/service/include/idevice_manager_service_impl.h b/services/service/include/idevice_manager_service_impl.h index 7d2e349069b9cd300cc5c2419109c5377b114cc3..83151e75f7ad99908e68aadf28f662dcdf107588 100644 --- a/services/service/include/idevice_manager_service_impl.h +++ b/services/service/include/idevice_manager_service_impl.h @@ -67,7 +67,7 @@ public: * @tc.desc: Se tUser Operation of device manager service impl * @tc.type: FUNC */ - virtual int32_t SetUserOperation(std::string &pkgName, int32_t action, const std::string ¶ms) = 0; + virtual int32_t SetUserOperation(const std::string &pkgName, int32_t action, const std::string ¶ms) = 0; /** * @tc.name: IDeviceManagerServiceImpl::HandleDeviceStatusChange diff --git a/services/service/include/ipc/standard/device_manager_client_service.h b/services/service/include/ipc/standard/device_manager_client_service.h new file mode 100644 index 0000000000000000000000000000000000000000..928b898be71556da873a49159ca2ee7c6fd6502c --- /dev/null +++ b/services/service/include/ipc/standard/device_manager_client_service.h @@ -0,0 +1,337 @@ +/* + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OHOS_DM_IPC_DEVICE_MANAGER_SERVICE_H +#define OHOS_DM_IPC_DEVICE_MANAGER_SERVICE_H + +#include +#include +#include +#include +#include +#include +#include + +#include "ipc_remote_broker.h" +#include "ipc_req.h" +#include "ipc_rsp.h" +#include "iremote_stub.h" +#include "idevice_manager_client.h" +#include "dm_device_info.h" +#include "dm_single_instance.h" + +namespace OHOS { +namespace DistributedHardware { +enum class ServiceRunningState { STATE_NOT_START, STATE_RUNNING }; + +class AppDeathRecipient : public IRemoteObject::DeathRecipient { +public: + /** + * @tc.name: AppDeathRecipient::OnRemoteDied + * @tc.desc: OnRemoteDied function of the App DeathRecipient + * @tc.type: FUNC + */ + void OnRemoteDied(const wptr &remote) override; + AppDeathRecipient() = default; + ~AppDeathRecipient() override = default; +}; + +class DeviceManagerClientService : public DeviceManagerClientStub { + DM_DECLARE_SINGLE_INSTANCE_BASE(DeviceManagerClientService); + // -------------------------------IPC Service Method-------------------------------- + virtual ErrCode GetTrustedDeviceList( + const std::string& pkgName, + const std::string& extra, + bool isRefresh, + std::vector& deviceListExt) override; + + virtual ErrCode GetLocalDeviceInfo( + const std::string& pkgName, + DmDeviceInfoExt& deviceInfoExt) override; + + virtual ErrCode GetUdidByNetworkId( + const std::string& pkgName, + const std::string& netWorkId, + std::string& udid) override; + + virtual ErrCode GetUuidByNetworkId( + const std::string& pkgName, + const std::string& netWorkId, + std::string& uuid) override; + + virtual ErrCode GetNetworkTypeByNetworkId( + const std::string& pkgName, + const std::string& netWorkId, + int32_t& netWorkType) override; + + virtual ErrCode PublishDeviceDiscovery( + const std::string& pkgName, + const DmPublishInfoExt& publishInfoExt) override; + + virtual ErrCode UnPublishDeviceDiscovery( + const std::string& pkgName, + int32_t publishId) override; + + virtual ErrCode AuthenticateDevice( + const std::string& pkgName, + int32_t authType, + const std::string& deviceId, + const std::string& extra) override; + + virtual ErrCode UnAuthenticateDevice( + const std::string& pkgName, + const std::string &netWorkId) override; + + virtual ErrCode StopAuthenticateDevice( + const std::string& pkgName) override; + + virtual ErrCode CheckCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) override; + + virtual ErrCode SetUserOperation( + const std::string& pkgName, + int32_t action, + const std::string& params) override; + + virtual ErrCode RequestCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) override; + + virtual ErrCode ImportCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) override; + + virtual ErrCode DeleteCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) override; + + virtual ErrCode RegisterCredentialCallback( + const std::string& pkgName) override; + + virtual ErrCode UnRegisterCredentialCallback( + const std::string& pkgName) override; + + virtual ErrCode NotifyEvent( + const std::string& pkgName, + int32_t eventId, + const std::string& event) override; + + virtual ErrCode GetDeviceInfo( + const std::string& pkgName, + const std::string& networkId, + DmDeviceInfoExt& deviceInfoExt) override; + + virtual ErrCode GetEncryptedUuidByNetworkId( + const std::string& pkgName, + const std::string& networkId, + std::string& uuid) override; + + virtual ErrCode GenerateEncryptedUuid( + const std::string& pkgName, + const std::string& uuid, + const std::string& appId, + std::string& encryptedUuid) override; + + virtual ErrCode BindDevice( + const std::string& pkgName, + int32_t bindType, + const std::string& deviceId, + const std::string& extra) override; + + virtual ErrCode UnBindDevice( + const std::string& pkgName, + const std::string& deviceId, + const std::string& extra) override; + + virtual ErrCode RegisterUiStateCallback( + const std::string& pkgName) override; + + virtual ErrCode UnRegisterUiStateCallback( + const std::string& pkgName) override; + + virtual ErrCode ImportAuthCode( + const std::string& pkgName, + const std::string& authCode) override; + + virtual ErrCode ExportAuthCode( + std::string& authCode) override; + + virtual ErrCode RegisterPinHolderCallback( + const std::string& pkgName) override; + + virtual ErrCode CreatePinHolder( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + int32_t pinTypeInt, + const std::string& payload) override; + + virtual ErrCode DestroyPinHolder( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + int32_t pinType, + const std::string& payload) override; + + virtual ErrCode RegisterDiscoveryCallback( + const std::string& pkgName, + const std::map& discoverParam, + const std::map& filterOptions) override; + + virtual ErrCode UnRegisterDiscoveryCallback( + const std::string& pkgName) override; + + virtual ErrCode StartDiscovering( + const std::string& pkgName, + const std::map& discoverParam, + const std::map& filterOptions) override; + + virtual ErrCode StopDiscovering( + const std::string& pkgName, + const std::map& discoverParam) override; + + virtual ErrCode StartAdvertising( + const std::string& pkgName, + const std::string& adverParaStr) override; + + virtual ErrCode StopAdvertising( + const std::string& pkgName, + const std::string& adverParaStr) override; + + virtual ErrCode BindTarget( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + const std::string& bindParam) override; + + virtual ErrCode UnbindTarget( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + const std::string& unbindParam) override; + + virtual ErrCode DpAclAdd( + int64_t accessControlId, + const std::string& udid, + int32_t bindType) override; + + virtual ErrCode GetDeviceSecurityLevel( + const std::string& pkgName, + const std::string& networkId, + int32_t& securityLevel) override; + + virtual ErrCode IsSameAccount( + const std::string& netWorkId, + bool& funcResult) override; + + virtual ErrCode CheckApiPermission( + int32_t permissionLevel) override; + + virtual ErrCode CheckAccessControl( + const DmAccessCallerExt& callerExt, + const DmAccessCalleeExt& calleeExt, + bool& funcResult) override; + + virtual ErrCode CheckIsSameAccount( + const DmAccessCallerExt& callerExt, + const DmAccessCalleeExt& calleeExt, + bool& funcResult) override; + + virtual ErrCode ShiftLNNGear( + const std::string& pkgName) override; + + virtual ErrCode SetDnPolicy( + const std::string& pkgName, + const std::map& policy) override; + + virtual ErrCode GetDeviceScreenStatus( + const std::string& pkgName, + const std::string& networkId, + int32_t& screenStatus) override; + + virtual ErrCode GetNetworkIdByUdid( + const std::string& pkgName, + const std::string& udid, + std::string& networkId) override; + + virtual ErrCode SyncCallbackToService( + int32_t dmCommonNotifyEvent, + const std::string& pkgName) override; + + virtual ErrCode GetAnonyLocalUdid( + const std::string& pkgName, + std::string& anonyUdid) override; + + virtual ErrCode RegisterAuthenticationType( + const std::string& pkgName, + const std::string& authTypeStr) override; + + virtual ErrCode PutDeviceProfileInfoList( + const std::string& pkgName, + const std::vector& deviceProfileInfoListExt) override; + + virtual ErrCode GetLocalDisplayDeviceName( + const std::string& pkgName, + int32_t maxNameLength, + std::string& displayName) override; + + virtual ErrCode GetAllTrustedDeviceList( + const std::string& pkgName, + const std::string& extra, + std::vector& deviceListExt) override; + + virtual ErrCode RegisterLocalServiceInfo( + const DMLocalServiceInfoExt& info) override; + + virtual ErrCode UnRegisterLocalServiceInfo( + const std::string& bundleName, + int32_t pinExchangeType) override; + + virtual ErrCode UpdateLocalServiceInfo( + const DMLocalServiceInfoExt& info) override; + + virtual ErrCode GetLocalServiceInfoByBundleNameAndPinExchangeType( + const std::string& bundleName, + int32_t pinExchangeType, + DMLocalServiceInfoExt& info) override; + + virtual ErrCode RestoreLocalDeviceName( + const std::string& pkgName) override; + + virtual ErrCode GetDeviceNetworkIdList( + const std::string& bundleName, + const NetworkIdQueryFilterExt& queryFilter, + std::vector& networkIds) override; + + +private: + DeviceManagerClientService(); + ~DeviceManagerClientService() override = default; + bool Init(); + void AddSystemSA(const std::string &pkgName); + void RemoveSystemSA(const std::string &pkgName); + +private: + bool registerToService_; + ServiceRunningState state_; + mutable std::mutex listenerLock_; + std::map> appRecipient_; + std::map> dmListener_; + std::set systemSA_; +}; +} // namespace DistributedHardware +} // namespace OHOS +#endif // OHOS_DM_IPC_SERVER_STUB_H diff --git a/services/service/src/device_manager_service.cpp b/services/service/src/device_manager_service.cpp index 4aedfa71ed0e7a35e5e362cb4beb0b4a822810cb..7d473d7e6990a3960687bb0484e49eb24058dccf 100644 --- a/services/service/src/device_manager_service.cpp +++ b/services/service/src/device_manager_service.cpp @@ -803,7 +803,7 @@ int32_t DeviceManagerService::UnBindDevice(const std::string &pkgName, const std return DM_OK; } -int32_t DeviceManagerService::SetUserOperation(std::string &pkgName, int32_t action, const std::string ¶ms) +int32_t DeviceManagerService::SetUserOperation(const std::string &pkgName, int32_t action, const std::string ¶ms) { if (!PermissionManager::GetInstance().CheckPermission()) { LOGE("The caller: %{public}s does not have permission to call SetUserOperation.", pkgName.c_str()); @@ -1476,6 +1476,7 @@ int32_t DeviceManagerService::StopAdvertising(const std::string &pkgName, } CHECK_NULL_RETURN(advertiseMgr_, ERR_DM_POINT_NULL); return advertiseMgr_->StopAdvertising(pkgName, publishId); + } int32_t DeviceManagerService::BindTarget(const std::string &pkgName, const PeerTargetId &targetId, @@ -1520,6 +1521,7 @@ int32_t DeviceManagerService::BindTarget(const std::string &pkgName, const PeerT } LOGI("BindTarget unstardard begin."); return dmServiceImplExtResident_->BindTargetExt(pkgName, targetId, bindParam); + } int32_t DeviceManagerService::UnbindTarget(const std::string &pkgName, const PeerTargetId &targetId, @@ -1560,6 +1562,7 @@ int32_t DeviceManagerService::UnbindTarget(const std::string &pkgName, const Pee unbindParamWithUdid.insert(std::pair(UN_BIND_PARAM_UDID_KEY, udid)); } return dmServiceImplExtResident_->UnbindTargetExt(pkgName, targetId, unbindParamWithUdid); + } #if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) @@ -2315,7 +2318,7 @@ void DeviceManagerService::HandleDeviceNotTrust(const std::string &msg) return; } -int32_t DeviceManagerService::SetDnPolicy(const std::string &pkgName, std::map &policy) +int32_t DeviceManagerService::SetDnPolicy(const std::string &pkgName, const std::map &policy) { if (!PermissionManager::GetInstance().CheckPermission()) { LOGE("The caller does not have permission to call"); diff --git a/services/service/src/ipc/standard/device_manager_client_service.cpp b/services/service/src/ipc/standard/device_manager_client_service.cpp new file mode 100644 index 0000000000000000000000000000000000000000..70d08b68449246098249748f81ac062f3fcd7d24 --- /dev/null +++ b/services/service/src/ipc/standard/device_manager_client_service.cpp @@ -0,0 +1,940 @@ +/* + * Copyright (c) 2022-2024 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT 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_client_stub.h" +#include "device_manager_client_service.h" +#include "device_manager_service.h" +#include "if_system_ability_manager.h" +#include "ipc_cmd_register.h" +#include "ipc_skeleton.h" +#include "ipc_types.h" +#include "iservice_registry.h" +#include "dm_ipc_utils.h" +#include "dm_radar_helper.h" +#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE)) +#endif +#ifdef SUPPORT_MEMMGR +#include "mem_mgr_client.h" +#include "mem_mgr_proxy.h" +#endif // SUPPORT_MEMMGR + +#include "string_ex.h" +#include "system_ability_definition.h" +#include "device_manager_ipc_interface_code.h" +#include "dm_constants.h" +#include "dm_device_info.h" +#include "dm_log.h" +namespace OHOS { +namespace DistributedHardware { +// -------------------------------IPC Service Method-------------------------------- +ErrCode DeviceManagerClientService::GetTrustedDeviceList( + const std::string& pkgName, + const std::string& extra, + bool isRefresh, + std::vector& deviceListExt) +{ + std::vector deviceList; + DeviceManagerService service; + std::string anonyLocalUdid_; + int32_t result = service.GetTrustedDeviceList(pkgName, extra, deviceList); + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportGetTrustDeviceList(pkgName, "GetTrustedDeviceList", + deviceList, result, anonyLocalUdid_); + LOGI("GetTrustedDeviceList error, failed ret: %{public}d", result); + return result; + } + DmIpcUtils::ConvertToDeviceInfoExtVector(deviceList, deviceListExt); + return result; +} + +ErrCode DeviceManagerClientService::GetLocalDeviceInfo( + const std::string& pkgName, + DmDeviceInfoExt& deviceInfoExt) +{ + (void) pkgName; + DmDeviceInfo localDeviceInfo; + DeviceManagerService service; + std::string anonyLocalUdid_; + int32_t result = service.GetLocalDeviceInfo(localDeviceInfo); + if (result != DM_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportGetLocalDevInfo(pkgName, "GetLocalDeviceInfo", + localDeviceInfo, result, anonyLocalUdid_); + LOGE("DeviceManagerImpl::GetLocalDeviceInfo error, Send Request failed ret: %{public}d", result); + return ERR_DM_IPC_SEND_REQUEST_FAILED; + } + DmIpcUtils::ConvertToDeviceInfo(deviceInfoExt, localDeviceInfo); + return result; +} + +ErrCode DeviceManagerClientService::GetUdidByNetworkId( + const std::string& pkgName, + const std::string& netWorkId, + std::string& udid) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.GetUdidByNetworkId(pkgName, netWorkId, udid); + if (result != ERR_OK) { + LOGE("CheckAuthentication Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetUuidByNetworkId( + const std::string& pkgName, + const std::string& netWorkId, + std::string& uuid) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.GetUuidByNetworkId(pkgName, netWorkId, uuid); + if (result != ERR_OK) { + LOGE("CheckAuthentication Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetNetworkTypeByNetworkId( + const std::string& pkgName, + const std::string& netWorkId, + int32_t& netWorkType) +{ + netWorkType = -1; + DeviceManagerService service; + int32_t result = service.GetNetworkTypeByNetworkId(pkgName, netWorkId, netWorkType); + if (result != ERR_OK) { + LOGE("CheckAuthentication Failed with ret %{public}d", result); + } + return ERR_OK; +} + +ErrCode DeviceManagerClientService::PublishDeviceDiscovery( + const std::string &pkgName, + const DmPublishInfoExt &publishInfoExt) +{ + DmPublishInfo publishInfo; + DmIpcUtils utils; + utils.ConvertToPublishInfo(publishInfoExt, publishInfo); + DeviceManagerService service; + std::string anonyLocalUdid_; + int32_t result = service.PublishDeviceDiscovery(pkgName, publishInfo); + if (result != ERR_OK) + { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "PublishDeviceDiscovery", result, anonyLocalUdid_); + LOGE("PublishDeviceDiscovery error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnPublishDeviceDiscovery( + const std::string& pkgName, + int32_t publishId) +{ + DeviceManagerService service; + std::string anonyLocalUdid_; + int32_t result = service.UnPublishDeviceDiscovery(pkgName, publishId); + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnPublishDeviceDiscovery", result, anonyLocalUdid_); + LOGE("UnPublishDeviceDiscovery error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::AuthenticateDevice( + const std::string& pkgName, + int32_t authType, + const std::string& deviceId, + const std::string& extra) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.AuthenticateDevice(pkgName, authType, deviceId, extra); + if (result != ERR_OK) { + LOGE("AuthenticateDevice error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnAuthenticateDevice( + const std::string& pkgName, + const std::string &netWorkId) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.UnAuthenticateDevice(pkgName, netWorkId); + if (result != ERR_OK) { + LOGE("UnAuthenticateDevice error: Failed with ret %{public}d", result); + // SysEventWrite(std::string(UNAUTHENTICATE_DEVICE_FAILED), DM_HISYEVENT_BEHAVIOR, + // std::string(UNAUTHENTICATE_DEVICE_FAILED_MSG)); + } + return result; +} + +ErrCode DeviceManagerClientService::StopAuthenticateDevice( + const std::string& pkgName) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + std::string anonyLocalUdid_; + result = service.StopAuthenticateDevice(pkgName); + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "StopAuthenticateDevice", result, anonyLocalUdid_); + LOGE("StopAuthenticateDevice error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::CheckCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) +{ + DeviceManagerService service; + int32_t result = service.CheckCredential(pkgName, reqJsonStr, returnJsonStr); + if (result != ERR_OK) { + LOGE("failed to get return errcode while Check credential."); + } + return result; +} + +ErrCode DeviceManagerClientService::SetUserOperation( + const std::string& pkgName, + int32_t action, + const std::string& params) +{ + DeviceManagerService service; + int32_t result = service.SetUserOperation(pkgName, action, params); + if (result != ERR_OK) { + LOGE("CheckAuthentication Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::RequestCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) +{ + std::map requestParam; + ParseMapFromJsonString(reqJsonStr, requestParam); + int32_t result = ERR_DM_FAILED; + DeviceManagerService service; + if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_OH) { + result = service.RequestCredential(requestParam[DM_CREDENTIAL_REQJSONSTR], + returnJsonStr); + } + if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_MINE) { + result = service.MineRequestCredential(pkgName, returnJsonStr); + } + if (result != ERR_OK) { + LOGE("failed to get return errcode while request credential."); + } + return result; +} + +ErrCode DeviceManagerClientService::ImportCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) +{ + std::map requestParam; + ParseMapFromJsonString(reqJsonStr, requestParam); + std::map outputResult; + int32_t result = ERR_DM_FAILED; + std::string returnJsonStrTemp; + DeviceManagerService service; + if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_OH) { + result = service.ImportCredential(pkgName, requestParam[DM_CREDENTIAL_REQJSONSTR]); + outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH); + } + if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_MINE) { + result = service.ImportCredential(pkgName, requestParam[DM_CREDENTIAL_REQJSONSTR], + returnJsonStrTemp); + outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE); + outputResult.emplace(DM_CREDENTIAL_RETURNJSONSTR, returnJsonStrTemp); + } + if (result == ERR_OK && !returnJsonStrTemp.empty()) { + returnJsonStr = ConvertMapToJsonString(outputResult); + } + if (result != ERR_OK) { + LOGE("failed to get return errcode while import credential."); + } + return result; +} + +ErrCode DeviceManagerClientService::DeleteCredential( + const std::string& pkgName, + const std::string& reqJsonStr, + std::string& returnJsonStr) +{ + std::map requestParam; + ParseMapFromJsonString(reqJsonStr, requestParam); + std::map outputResult; + std::string returnJsonStrTemp; + int32_t result = ERR_DM_FAILED; + DeviceManagerService service; + if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_OH) { + result = service.DeleteCredential(pkgName, requestParam[DM_CREDENTIAL_REQJSONSTR]); + outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH); + } + if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_MINE) { + result = service.DeleteCredential(pkgName, requestParam[DM_CREDENTIAL_REQJSONSTR], + returnJsonStrTemp); + outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE); + outputResult.emplace(DM_CREDENTIAL_RETURNJSONSTR, returnJsonStrTemp); + } + if (result == ERR_OK && !returnJsonStrTemp.empty()) { + returnJsonStr = ConvertMapToJsonString(outputResult); + } + if (result != ERR_OK) { + LOGE("failed to get return errcode while delete credential."); + } + return result; +} + +ErrCode DeviceManagerClientService::RegisterCredentialCallback( + const std::string& pkgName) +{ + int result = ERR_OK; + DeviceManagerService service; + result = service.RegisterCredentialCallback(pkgName); + if (result != ERR_OK) { + LOGE("RegisterCredentialCallback error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnRegisterCredentialCallback( + const std::string& pkgName) +{ + DeviceManagerService service; + int result = service.UnRegisterCredentialCallback(pkgName); + if (result != ERR_OK) { + LOGE("UnRegisterCredentialCallback Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::NotifyEvent( + const std::string& pkgName, + int32_t eventId, + const std::string& event) +{ + DeviceManagerService service; + int32_t result = service.NotifyEvent(pkgName, eventId, event); + std::string anonyLocalUdid_; + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "NotifyEvent", result, anonyLocalUdid_); + LOGE("NotifyEvent failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetDeviceInfo( + const std::string& pkgName, + const std::string& networkId, + DmDeviceInfoExt& deviceInfoExt) +{ + DmDeviceInfo deviceInfo; + DeviceManagerService service; + int32_t result = service.GetDeviceInfo(networkId, deviceInfo); + std::string anonyLocalUdid_; + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportGetDeviceInfo(pkgName, "GetDeviceInfo", + deviceInfo, result, anonyLocalUdid_); + LOGE("DeviceManagerImpl::GetDeviceInfo error, failed ret: %{public}d", result); + return result; + } + return result; +} + +ErrCode DeviceManagerClientService::GetEncryptedUuidByNetworkId( + const std::string& pkgName, + const std::string& networkId, + std::string& uuid) +{ + DeviceManagerService service; + int32_t result = service.GetEncryptedUuidByNetworkId(pkgName, networkId, uuid); + if (result != ERR_OK) { + LOGE("CheckAuthentication Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GenerateEncryptedUuid( + const std::string& pkgName, + const std::string& uuid, + const std::string& appId, + std::string& encryptedUuid) +{ + DeviceManagerService service; + int32_t result = service.GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid); + if (result != ERR_OK) { + LOGE("CheckAuthentication Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::BindDevice( + const std::string& pkgName, + int32_t bindType, + const std::string& deviceId, + const std::string& extra) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.BindDevice(pkgName, bindType, deviceId, extra); + if (result != ERR_OK) { + LOGE("BindDevice error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnBindDevice( + const std::string& pkgName, + const std::string& deviceId, + const std::string& extra) +{ + int32_t result; + DeviceManagerService service; + if (extra == "") { + result = service.UnBindDevice(pkgName, deviceId); + } else { + result = service.UnBindDevice(pkgName, deviceId, extra); + } + if (result != ERR_OK) { + LOGE("UnBindDevice error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::RegisterUiStateCallback( + const std::string& pkgName) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.RegisterUiStateCallback(pkgName); + std::string anonyLocalUdid_; + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "RegisterUiStateCallback", result, anonyLocalUdid_); + LOGE("RegisterUiStateCallback Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnRegisterUiStateCallback( + const std::string& pkgName) +{ + int32_t result = ERR_OK; + DeviceManagerService service; + result = service.UnRegisterUiStateCallback(pkgName); + std::string anonyLocalUdid_; + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnRegisterUiStateCallback", result, anonyLocalUdid_); + LOGE("UnRegisterUiStateCallback Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::ImportAuthCode( + const std::string& pkgName, + const std::string& authCode) +{ + DeviceManagerService service; + int32_t result = service.ImportAuthCode(pkgName, authCode); + if (result != ERR_OK) { + LOGE("ImportAuthCode Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::ExportAuthCode( + std::string& authCode) +{ + DeviceManagerService service; + int32_t result = service.ExportAuthCode(authCode); + if (result != ERR_OK) { + LOGE("ExportAuthCode Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::RegisterPinHolderCallback( + const std::string& pkgName) +{ + DeviceManagerService service; + int32_t result = service.RegisterPinHolderCallback(pkgName); + std::string anonyLocalUdid_; + if (result != DM_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "RegisterPinHolderCallback", result, anonyLocalUdid_); + LOGE("RegisterPinHolderCallback Failed with ret %{public}d", result); + } + return ERR_OK; +} + +ErrCode DeviceManagerClientService::CreatePinHolder( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + int32_t pinTypeInt, + const std::string& payload) +{ + PeerTargetId targetId; + DmIpcUtils utils; + utils.ConvertToPeerTargetId(targetIdExt, targetId); + DmPinType pinType = static_cast(pinTypeInt); + DeviceManagerService service; + int32_t result = service.CreatePinHolder(pkgName, targetId, pinType, payload); + if (result != ERR_OK) { + LOGE("CreatePinHolder Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::DestroyPinHolder( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + int32_t pinTypeInt, + const std::string& payload) +{ + PeerTargetId targetId; + DmIpcUtils utils; + utils.ConvertToPeerTargetId(targetIdExt, targetId); + DmPinType pinType = static_cast(pinTypeInt); + DeviceManagerService service; + int32_t result = service.DestroyPinHolder(pkgName, targetId, pinType, payload); + return ERR_OK; +} + +ErrCode DeviceManagerClientService::RegisterDiscoveryCallback( + const std::string& pkgName, + const std::map& discoverParam, + const std::map& filterOptions) +{ + DeviceManagerService service; + int32_t result = service.EnableDiscoveryListener(pkgName, discoverParam, filterOptions); + if (result != ERR_OK) { + LOGE("RegisterDiscoveryCallback error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnRegisterDiscoveryCallback( + const std::string& pkgName) +{ + // int32_t result = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam); + // if (result != ERR_OK) { + // // DmRadarHelper::GetInstance().ReportDmBehavior(pkgNameTemp, "UnRegisterDiscoveryCallback", + // // result, anonyLocalUdid_); + // LOGE("UnRegisterDiscoveryCallback error: Failed with ret %{public}d", result); + // } + return DM_OK; +} + +ErrCode DeviceManagerClientService::StartDiscovering( + const std::string& pkgName, + const std::map& discoverParam, + const std::map& filterOptions) +{ + DeviceManagerService service; + int32_t result = service.StartDiscovering(pkgName, discoverParam, filterOptions); + if (result != ERR_OK) { + LOGE("StartDiscovering error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::StopDiscovering( + const std::string& pkgName, + const std::map& discoverParam) +{ + DeviceManagerService service; + int32_t result = service.StopDiscovering(pkgName, discoverParam); + if (result != ERR_OK) { + LOGE("StopDiscovering error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::StartAdvertising( + const std::string& pkgName, + const std::string& adverParaStr) +{ + std::map advertiseParam; + ParseMapFromJsonString(adverParaStr, advertiseParam); + DeviceManagerService service; + int32_t result = service.StartAdvertising(pkgName, advertiseParam); + if (result != ERR_OK) { + LOGE("StartAdvertising error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::StopAdvertising( + const std::string& pkgName, + const std::string& adverParaStr) +{ + std::map adverParam; + ParseMapFromJsonString(adverParaStr, adverParam); + DeviceManagerService service; + int32_t result = service.StopAdvertising(pkgName, adverParam); + if (result != ERR_OK) { + LOGE("StopAdvertising error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::BindTarget( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + const std::string& bindParaStr) +{ + PeerTargetId targetId; + DmIpcUtils::ConvertToPeerTargetId(targetIdExt, targetId); + std::map bindParam; + ParseMapFromJsonString(bindParaStr, bindParam); + DeviceManagerService service; + int32_t result = service.BindTarget(pkgName, targetId, bindParam); + if (result != ERR_OK) { + LOGE("BindTarget error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnbindTarget( + const std::string& pkgName, + const PeerTargetIdExt& targetIdExt, + const std::string& unbindParaStr) +{ + PeerTargetId targetId; + DmIpcUtils::ConvertToPeerTargetId(targetIdExt, targetId); + std::map unbindParam; + ParseMapFromJsonString(unbindParaStr, unbindParam); + DeviceManagerService service; + int32_t result = service.UnbindTarget(pkgName, targetId, unbindParam); + if (result != ERR_OK) { + LOGE("UnbindTarget error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::DpAclAdd( + int64_t accessControlId, + const std::string& udid, + int32_t bindType) +{ + DeviceManagerService service; + int32_t result = service.DpAclAdd(udid); + if (result != ERR_OK) { + LOGE("DpAclAdd error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetDeviceSecurityLevel( + const std::string& pkgName, + const std::string& networkId, + int32_t& securityLevel) +{ + securityLevel = -1; + DeviceManagerService service; + int32_t result = service.GetDeviceSecurityLevel(pkgName, networkId, securityLevel); + std::string anonyLocalUdid_; + if (result != DM_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "GetDeviceSecurityLevel", result, anonyLocalUdid_); + LOGE("GetDeviceSecurityLevel Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::IsSameAccount( + const std::string& netWorkId, bool& funcResult) +{ + DeviceManagerService service; + int32_t result = service.IsSameAccount(netWorkId); + if (result != ERR_OK) { + LOGE("IsSameAccount Failed with ret: %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::CheckApiPermission( + int32_t permissionLevel) +{ + DeviceManagerService service; + int32_t result = service.CheckApiPermission(permissionLevel); + if (result != ERR_OK) { + LOGE("Check permission failed with ret: %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::CheckAccessControl( + const DmAccessCallerExt& callerExt, + const DmAccessCalleeExt& calleeExt, + bool& funcResult) +{ + DmAccessCaller caller; + DmAccessCallee callee; + DmIpcUtils::ConvertToDmAccessCaller(callerExt, caller); + DmIpcUtils::ConvertToDmAccessCallee(calleeExt, callee); + DeviceManagerService service; + int32_t result = service.CheckAccessControl(caller, callee); + funcResult = result == 1 ? true : false; + if (result != ERR_OK) { + //DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckAccessControl", result, anonyLocalUdid_); + LOGE("CheckAccessControl Failed with ret: %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::CheckIsSameAccount( + const DmAccessCallerExt& callerExt, + const DmAccessCalleeExt& calleeExt, + bool& funcResult) +{ + DmAccessCaller caller; + DmAccessCallee callee; + DmIpcUtils::ConvertToDmAccessCaller(callerExt, caller); + DmIpcUtils::ConvertToDmAccessCallee(calleeExt, callee); + DeviceManagerService service; + int32_t result = service.CheckIsSameAccount(caller, callee); + funcResult = result == 1 ? true : false; + if (result != ERR_OK) { + // DmRadarHelper::GetInstance().ReportDmBehavior(caller.pkgName, "CheckIsSameAccount", result, anonyLocalUdid_); + LOGE("CheckIsSameAccount Failed with ret: %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::ShiftLNNGear( + const std::string& pkgName) +{ + DeviceManagerService service; + int32_t result = service.ShiftLNNGear(pkgName, pkgName, true, true); + if (result != ERR_OK) { + //DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "ShiftLNNGear", result, anonyLocalUdid_); + LOGE("ShiftLNNGear error: Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::SetDnPolicy( + const std::string& pkgName, + const std::map& policy) +{ + DeviceManagerService service; + int32_t result = service.SetDnPolicy(pkgName, policy); + std::string anonyLocalUdid_; + if (result != ERR_OK) { + service.GetAnonyLocalUdid(pkgName, anonyLocalUdid_); + DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "SetDnPolicy", result, anonyLocalUdid_); + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetDeviceScreenStatus( + const std::string& pkgName, + const std::string& networkId, + int32_t& screenStatus) +{ + screenStatus = -1; + DeviceManagerService service; + int32_t result = service.GetDeviceScreenStatus(pkgName, networkId, screenStatus); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetNetworkIdByUdid( + const std::string& pkgName, + const std::string& udid, + std::string& netWorkId) +{ + DeviceManagerService service; + int32_t result = service.GetNetworkIdByUdid(pkgName, udid, netWorkId); + if (result != ERR_OK) { + LOGE("GetNetworkIdByUdid Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::SyncCallbackToService( + int32_t dmCommonNotifyEvent, + const std::string& pkgName) +{ + // ProcessInfo processInfo; + // processInfo.pkgName = pkgName; + // MultipleUserConnector::GetCallerUserId(processInfo.userId); + // int32_t result = DeviceManagerServiceNotify::GetInstance().RegisterCallBack(dmCommonNotifyEvent, processInfo); + // if (dmCommonNotifyEvent == static_cast(DmCommonNotifyEvent::REG_DEVICE_STATE)) { + // DeviceManagerService::GetInstance().RegDevStateCallbackToService(pkgName); + // } + // if (result != ERR_OK) { + // LOGE("Failed with ret %{public}d", result); + // } + return DM_OK; +} + +ErrCode DeviceManagerClientService::GetAnonyLocalUdid( + const std::string& pkgName, + std::string& anonyUdid) +{ + DeviceManagerService service; + int32_t result = service.GetAnonyLocalUdid(pkgName, anonyUdid); + if (result != ERR_OK) { + LOGE("GetAnonyLocalUdid Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::RegisterAuthenticationType( + const std::string& pkgName, + const std::string& authTypeStr) +{ + // int32_t result = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam); + // if (result != ERR_OK) { + // LOGE("Failed with ret %{public}d", result); + // } + //return result; + return DM_OK; +} + +ErrCode DeviceManagerClientService::PutDeviceProfileInfoList( + const std::string& pkgName, + const std::vector& deviceProfileInfoListExt) +{ + DeviceManagerService service; + std::vector deviceProfileInfoList; + int32_t result = service.PutDeviceProfileInfoList(pkgName, deviceProfileInfoList); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetLocalDisplayDeviceName( + const std::string& pkgName, + int32_t maxNameLength, + std::string& displayName) +{ + DeviceManagerService service; + int32_t result = service.GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetAllTrustedDeviceList( + const std::string& pkgName, + const std::string& extra, + std::vector& deviceListExt) +{ + std::vector deviceList; + DeviceManagerService service; + int32_t result = service.GetAllTrustedDeviceList(pkgName, extra, deviceList); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::RegisterLocalServiceInfo( + const DMLocalServiceInfoExt& info) +{ + DeviceManagerService service; + int32_t result = service.RegisterLocalServiceInfo(info); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UnRegisterLocalServiceInfo( + const std::string &bundleName, int32_t pinExchangeType) +{ + DeviceManagerService service; + int32_t result = service.UnRegisterLocalServiceInfo(bundleName,pinExchangeType); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::UpdateLocalServiceInfo( + const DMLocalServiceInfoExt& info) +{ + DMLocalServiceInfoExt serviceInfo; + DmIpcUtils::ConvertToDMLocalServiceInfo(info, serviceInfo); + DeviceManagerService service; + int32_t result = service.UpdateLocalServiceInfo(info); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::GetLocalServiceInfoByBundleNameAndPinExchangeType( + const std::string &bundleName, int32_t pinExchangeType, DMLocalServiceInfoExt &info) +{ + DMLocalServiceInfoExt serviceInfo; + DmIpcUtils::ConvertToDMLocalServiceInfo(info, serviceInfo); + DeviceManagerService service; + int32_t result = service.GetLocalServiceInfoByBundleNameAndPinExchangeType(bundleName, pinExchangeType,info); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} + +ErrCode DeviceManagerClientService::RestoreLocalDeviceName( + const std::string &pkgName) +{ + DeviceManagerService service; + int32_t result = service.RestoreLocalDeviceName(pkgName); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return DM_OK; +} +ErrCode DeviceManagerClientService::GetDeviceNetworkIdList( + const std::string &bundleName, + const NetworkIdQueryFilterExt &queryFilter, + std::vector &networkIds) +{ + DeviceManagerService service; + NetworkIdQueryFilter networkIdQueryFilter; + DmIpcUtils::ConvertToNetworkIdQueryFilter(queryFilter, networkIdQueryFilter); + int32_t result = service.GetDeviceNetworkIdList(bundleName,networkIdQueryFilter,networkIds); + if (result != ERR_OK) { + LOGE("Failed with ret %{public}d", result); + } + return result; +} +} // namespace DistributedHardware +} // namespace OHOS diff --git a/utils/BUILD.gn b/utils/BUILD.gn index 56deeecf30144aba62be4cfc9899687d362442b6..0e28a89a47980ee1a80a0f4f8a8cc92a8674ed75 100644 --- a/utils/BUILD.gn +++ b/utils/BUILD.gn @@ -132,6 +132,8 @@ if (defined(ohos_lite)) { "src/kvadapter/kv_adapter.cpp", "src/kvadapter/kv_adapter_manager.cpp", "src/timer/dm_timer.cpp", + "src/dm_ipc_utils.cpp", + "${innerkits_path}/native_cpp/src/dm_device_info.cpp", ] if (support_jsapi) { diff --git a/utils/include/dm_ipc_utils.h b/utils/include/dm_ipc_utils.h new file mode 100644 index 0000000000000000000000000000000000000000..4b53c34675b67fa54ad2ad68da03f120f290a96d --- /dev/null +++ b/utils/include/dm_ipc_utils.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#ifndef OHOS_DM_IPC_UTILS_H +#define OHOS_DM_IPC_UTILS_H + +#include +#include "dm_device_info.h" +#include "dm_publish_info.h" +#include "dm_device_profile_info.h" +namespace OHOS { +namespace DistributedHardware { + +class DmIpcUtils { +public: + static void ConvertToDeviceInfoVector(const std::vector& extVector, std::vector& baseVector); + static void ConvertToDeviceInfoExtVector(const std::vector& baseVector, std::vector& extVector); + static void ConvertToPublishInfo(const DmPublishInfoExt& ext, DmPublishInfo& base); + static void ConvertToDeviceInfo(const DmDeviceInfoExt& ext, DmDeviceInfo& base); + static void ConvertToPeerTargetId(const PeerTargetIdExt& ext, PeerTargetId& base); + static void ConvertToDmAccessCaller(const DmAccessCallerExt& ext, DmAccessCaller& base); + static void ConvertToDmAccessCallee(const DmAccessCalleeExt& ext, DmAccessCallee& base); + static void ConvertToDmDeviceProfileInfoVector(const std::vector& deviceProfileInfoListExt, + std::vector &deviceProfileInfoList); + static void ConverToDMServiceInfoVector(std::vector& serviceInfoExt, + std::vector &serviceInfos); + static void ConvertToDMLocalServiceInfo(const DMLocalServiceInfoExt& ext, DMLocalServiceInfo& base); + static void ConvertToNetworkIdQueryFilter(const NetworkIdQueryFilterExt& ext, NetworkIdQueryFilter& base); +}; + +} // namespace DistributedHardware +} // namespace OHOS + +#endif // OHOS_DM_IPC_UTILS_H \ No newline at end of file diff --git a/utils/src/dm_ipc_utils.cpp b/utils/src/dm_ipc_utils.cpp new file mode 100644 index 0000000000000000000000000000000000000000..669242db5984e1537dd702e1c063347ab610edd0 --- /dev/null +++ b/utils/src/dm_ipc_utils.cpp @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "dm_ipc_utils.h" + +namespace OHOS { +namespace DistributedHardware { + +void DmIpcUtils::ConvertToDeviceInfoVector(const std::vector& extVector, std::vector& baseVector) +{ + baseVector.clear(); + baseVector.reserve(extVector.size()); // 预留空间以避免多次分配内存 + + for (const auto& ext : extVector) { + DmDeviceInfo base; + memcpy(base.deviceId, ext.deviceId, DM_MAX_DEVICE_ID_LEN); + memcpy(base.deviceName, ext.deviceName, DM_MAX_DEVICE_NAME_LEN); + base.deviceTypeId = ext.deviceTypeId; + memcpy(base.networkId, ext.networkId, DM_MAX_DEVICE_ID_LEN); + base.range = ext.range; + base.networkType = ext.networkType; + base.authForm = ext.authForm; + base.extraData = ext.extraData; + baseVector.push_back(base); + } +} + +void DmIpcUtils::ConvertToDeviceInfoExtVector(const std::vector& baseVector, std::vector& extVector) +{ + extVector.clear(); + extVector.reserve(baseVector.size()); // 预留空间以避免多次分配内存 + + for (const auto& base : baseVector) { + DmDeviceInfoExt ext; + memcpy(ext.deviceId, base.deviceId, DM_MAX_DEVICE_ID_LEN); + memcpy(ext.deviceName, base.deviceName, DM_MAX_DEVICE_NAME_LEN); + ext.deviceTypeId = base.deviceTypeId; + memcpy(ext.networkId, base.networkId, DM_MAX_DEVICE_ID_LEN); + ext.range = base.range; + ext.networkType = base.networkType; + ext.authForm = base.authForm; + ext.extraData = base.extraData; + extVector.push_back(ext); + } +} + +void DmIpcUtils::ConvertToPublishInfo(const DmPublishInfoExt& ext, DmPublishInfo& base) +{ + base.publishId = ext.publishId; + base.mode = ext.mode; + base.freq = ext.freq; + base.ranging = ext.ranging; +} + +void DmIpcUtils::ConvertToDeviceInfo(const DmDeviceInfoExt& ext, DmDeviceInfo& base) +{ + memcpy(base.deviceId, ext.deviceId, DM_MAX_DEVICE_ID_LEN); + memcpy(base.deviceName, ext.deviceName, DM_MAX_DEVICE_NAME_LEN); + base.deviceTypeId = ext.deviceTypeId; + memcpy(base.networkId, ext.networkId, DM_MAX_DEVICE_ID_LEN); + base.range = ext.range; + base.networkType = ext.networkType; + base.authForm = ext.authForm; + base.extraData = ext.extraData; +} + +void DmIpcUtils::ConvertToPeerTargetId(const PeerTargetIdExt& ext, PeerTargetId& base) +{ + base.deviceId = ext.deviceId; + base.brMac = ext.brMac; + base.bleMac = ext.bleMac; + base.wifiIp = ext.wifiIp; + base.wifiPort = ext.wifiPort; +} + +void DmIpcUtils::ConvertToDmAccessCaller(const DmAccessCallerExt& ext, DmAccessCaller& base) +{ + base.accountId = ext.accountId; + base.pkgName = ext.pkgName; + base.networkId = ext.networkId; + base.userId = ext.userId; + base.tokenId = ext.tokenId; + base.extra = ext.extra; +} + +void DmIpcUtils::ConvertToDmAccessCallee(const DmAccessCalleeExt& ext, DmAccessCallee& base) +{ + base.accountId = ext.accountId; + base.networkId = ext.networkId; + base.peerId = ext.peerId; + base.userId = ext.userId; + base.extra = ext.extra; +} + +void DmIpcUtils::ConvertToDmDeviceProfileInfoVector(const std::vector& deviceProfileInfoListExt, + std::vector &deviceProfileInfoList) +{ + deviceProfileInfoList.clear(); + deviceProfileInfoList.reserve(deviceProfileInfoListExt.size()); + for (const auto& ext : deviceProfileInfoListExt) { + DmDeviceProfileInfo base; + base.deviceId = ext.deviceId; + base.deviceSn = ext.deviceSn; + base.mac = ext.mac; + base.model = ext.model; + base.internalModel = ext.internalModel; + base.deviceType = ext.deviceType; + base.manufacturer = ext.manufacturer; + base.deviceName = ext.deviceName; + base.productId = ext.productId; + base.subProductId = ext.subProductId; + base.sdkVersion = ext.sdkVersion; + base.bleMac = ext.bleMac; + base.brMac = ext.brMac; + base.sleMac = ext.sleMac; + base.firmwareVersion = ext.firmwareVersion; + base.hardwareVersion = ext.hardwareVersion; + base.softwareVersion = ext.softwareVersion; + base.protocolType = ext.protocolType; + base.setupType = ext.setupType; + base.wiseDeviceId = ext.wiseDeviceId; + base.wiseUserId = ext.wiseUserId; + base.registerTime = ext.registerTime; + base.modifyTime = ext.modifyTime; + base.shareTime = ext.shareTime; + base.isLocalDevice = ext.isLocalDevice; + } +} + +void DmIpcUtils::ConverToDMServiceInfoVector(std::vector& serviceInfoExt, + std::vector &serviceInfos) +{ + serviceInfos.clear(); + serviceInfos.reserve(serviceInfoExt.size()); + for (const auto& ext : serviceInfoExt) { + DMLocalServiceInfo base; + base.bundleName = ext.bundleName; + base.authBoxType = ext.authBoxType; + base.authType = ext.authType; + base.pinExchangeType = ext.pinExchangeType; + base.pinCode = ext.pinCode; + base.description = ext.description; + base.extraInfo = ext.extraInfo; + } +} + +void DmIpcUtils::ConvertToDMLocalServiceInfo(const DMLocalServiceInfoExt& ext, DMLocalServiceInfo& base) +{ + + base.bundleName = ext.bundleName; + base.authBoxType = ext.authBoxType; + base.authType = ext.authType; + base.pinExchangeType = ext.pinExchangeType; + base.pinCode = ext.pinCode; + base.description = ext.description; + base.extraInfo = ext.extraInfo; +} + +void DmIpcUtils::ConvertToNetworkIdQueryFilter(const NetworkIdQueryFilterExt& ext, NetworkIdQueryFilter& base) +{ + base.wiseDeviceId = ext.wiseDeviceId; + base.onlineStatus = ext.onlineStatus; + base.deviceType = ext.deviceType; + base.deviceProductId = ext.deviceProductId; + base.deviceModel = ext.deviceModel; +} +} // namespace DistributedHardware +} // namespace OHOS \ No newline at end of file