openharmony/distributedhardware_device_manager
1
0
Fork 0
mirror of https://gitee.com/openharmony/distributedhardware_device_manager synced 2024-11-23 08:19:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

适配多用户

Browse Source 
Signed-off-by: liuzhongming <liuzhongming2@huawei.com>
This commit is contained in:
liuzhongming 2024-11-17 10:20:11 +08:00
parent cd7634ed58
commit 9ee845a198
118 changed files with 4631 additions and 2519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
common/include/device_manager_ipc_interface_code.h
View File

@ -29,9 +29,6 @@ enum DMIpcCmdInterfaceCode {
GET_UDID_BY_NETWORK,
GET_UUID_BY_NETWORK,
GET_NETWORKTYPE_BY_NETWORK,
START_DEVICE_DISCOVER,
START_DEVICE_DISCOVERY,
STOP_DEVICE_DISCOVER,
PUBLISH_DEVICE_DISCOVER,
UNPUBLISH_DEVICE_DISCOVER,
AUTHENTICATE_DEVICE,

64
common/include/dm_anonymous.h
View File

@ -18,15 +18,20 @@
#include <map>
#include <string>
#include "dm_device_info.h"
#include "nlohmann/json.hpp"
#include <unordered_map>
#include "dm_device_info.h"
namespace OHOS {
namespace DistributedHardware {
namespace {
const std::string PRINT_LIST_SPLIT = ", ";
const int32_t LIST_SPLIT_LEN = 2;
}
std::string GetAnonyString(const std::string &value);
std::string GetAnonyStringList(const std::vector<std::string> &values);
std::string GetAnonyInt32(const int32_t value);
std::string GetAnonyInt32List(const std::vector<int32_t> &values);
bool IsNumberString(const std::string &inputString);
bool IsString(const nlohmann::json &jsonObj, const std::string &key);
bool IsInt32(const nlohmann::json &jsonObj, const std::string &key);
@ -43,6 +48,59 @@ int64_t StringToInt64(const std::string &str, int32_t base);
void VersionSplitToInt(const std::string &str, const char split, std::vector<int32_t> &numVec);
bool CompareVecNum(const std::vector<int32_t> &srcVecNum, const std::vector<int32_t> &sinkVecNum);
bool CompareVersion(const std::string &remoteVersion, const std::string &oldVersion);
std::string ComposeStr(const std::string &pkgName, uint16_t subscribeId);
std::string GetCallerPkgName(const std::string &pkgName);
uint16_t GetSubscribeId(const std::string &pkgName);
template <class T>
std::string GetAnonyInteger(const T value)
{
std::string tempString = std::to_string(value);
size_t length = tempString.length();
if (length == 0x01) {
tempString[0] = '*';
return tempString;
}
for (size_t i = 1; i < length - 1; i++) {
tempString[i] = '*';
}
return tempString;
}
template <class T>
std::string GetAnonyIntegerList(const std::vector<T> &values)
{
std::string temp = "[ ";
bool flag = false;
for (auto const &v : values) {
temp += GetAnonyInteger(v) + PRINT_LIST_SPLIT;
flag = true;
}
if (flag) {
temp.erase(temp.length() - LIST_SPLIT_LEN);
}
temp += " ]";
return temp;
}
template <class T>
std::string GetIntegerList(const std::vector<T> &values)
{
std::string temp = "[ ";
bool flag = false;
for (auto const &v : values) {
temp += std::to_string(v) + PRINT_LIST_SPLIT;
flag = true;
}
if (flag) {
temp.erase(temp.length() - LIST_SPLIT_LEN);
}
temp += " ]";
return temp;
}
bool IsIdLengthValid(const std::string &inputID);
bool IsMessageLengthValid(const std::string &inputMessage);
bool IsValueExist(const std::multimap<std::string, int32_t> unorderedmap, const std::string &udid, int32_t userId);
} // namespace DistributedHardware
} // namespace OHOS
#endif // OHOS_DM_ANONYMOUS_H

1
common/include/dm_constants.h
View File

@ -133,6 +133,7 @@ constexpr const char* DM_ITF_VER = "1.1";
constexpr const char* DM_PKG_NAME = "ohos.distributedhardware.devicemanager";
constexpr const char* DM_SESSION_NAME = "ohos.distributedhardware.devicemanager.resident";
constexpr const char* DM_PIN_HOLDER_SESSION_NAME = "ohos.distributedhardware.devicemanager.pinholder";
constexpr const char* DM_SYNC_USERID_SESSION_NAME = "ohos.distributedhardware.devicemanager.syncuserid";
constexpr const char* DM_CAPABILITY_OSD = "osdCapability";
constexpr const char* DM_CAPABILITY_APPROACH = "approach";
constexpr const char* DM_CAPABILITY_TOUCH = "touch";

13
common/include/ipc/model/ipc_req.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* 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
@ -19,6 +19,7 @@
#include <string>
#include "ipc_def.h"
#include "dm_device_info.h"
namespace OHOS {
namespace DistributedHardware {
@ -36,8 +37,18 @@ public:
pkgName_ = pkgName;
}
const ProcessInfo GetProcessInfo() const
{
return processInfo_;
}
void SetProcessInfo(const ProcessInfo &processInfo)
{
processInfo_ = processInfo;
}
private:
std::string pkgName_;
ProcessInfo processInfo_;
};
} // namespace DistributedHardware
} // namespace OHOS

73
common/include/ipc/model/ipc_start_discover_req.h
View File

@ -1,73 +0,0 @@
/*
* 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.
*/
#ifndef OHOS_DM_IPC_START_DISCOVER_REQ_H
#define OHOS_DM_IPC_START_DISCOVER_REQ_H
#include "ipc_req.h"
namespace OHOS {
namespace DistributedHardware {
class IpcStartDevDiscoveryByIdReq : public IpcReq {
DECLARE_IPC_MODEL(IpcStartDevDiscoveryByIdReq);
public:
/**
* @tc.name: IpcStartDiscoveryReq::GetSubscribeInfo
* @tc.desc: Ipc Start Discovery Request Get SubscribeInfo
* @tc.type: FUNC
*/
const uint16_t &GetSubscribeId() const
{
return subscribeId_;
}
/**
* @tc.name: IpcStartDiscoveryReq::SetSubscribeInfo
* @tc.desc: Ipc Start Discovery Request Set SubscribeInfo
* @tc.type: FUNC
*/
void SetSubscribeId(const uint16_t &subscribeId)
{
subscribeId_ = subscribeId;
}
/**
* @tc.name: IpcStartDiscoveryReq::GetExtra
* @tc.desc: Ipc Start Discovery Request Get Extra
* @tc.type: FUNC
*/
const std::string &GetFilterOption() const
{
return filterOptions_;
}
/**
* @tc.name: IpcStartDiscoveryReq::SetExtra
* @tc.desc: Ipc Start Discovery Request Set Extra
* @tc.type: FUNC
*/
void SetFilterOption(const std::string &filterOptions)
{
filterOptions_ = filterOptions;
}
private:
std::string filterOptions_;
uint16_t subscribeId_ { 0 };
};
} // namespace DistributedHardware
} // namespace OHOS
#endif // OHOS_DM_IPC_START_DISCOVER_REQ_H

74
common/include/ipc/model/ipc_start_discovery_req.h
View File

@ -1,74 +0,0 @@
/*
* 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_START_DISCOVERY_REQ_H
#define OHOS_DM_IPC_START_DISCOVERY_REQ_H
#include "dm_subscribe_info.h"
#include "ipc_req.h"
namespace OHOS {
namespace DistributedHardware {
class IpcStartDiscoveryReq : public IpcReq {
DECLARE_IPC_MODEL(IpcStartDiscoveryReq);
public:
/**
* @tc.name: IpcStartDiscoveryReq::GetSubscribeInfo
* @tc.desc: Ipc Start Discovery Request Get SubscribeInfo
* @tc.type: FUNC
*/
const DmSubscribeInfo &GetSubscribeInfo() const
{
return subscribeInfo_;
}
/**
* @tc.name: IpcStartDiscoveryReq::SetSubscribeInfo
* @tc.desc: Ipc Start Discovery Request Set SubscribeInfo
* @tc.type: FUNC
*/
void SetSubscribeInfo(const DmSubscribeInfo &subscribeInfo)
{
subscribeInfo_ = subscribeInfo;
}
/**
* @tc.name: IpcStartDiscoveryReq::GetExtra
* @tc.desc: Ipc Start Discovery Request Get Extra
* @tc.type: FUNC
*/
const std::string &GetExtra() const
{
return extra_;
}
/**
* @tc.name: IpcStartDiscoveryReq::SetExtra
* @tc.desc: Ipc Start Discovery Request Set Extra
* @tc.type: FUNC
*/
void SetExtra(const std::string &extra)
{
extra_ = extra;
}
private:
std::string extra_;
DmSubscribeInfo subscribeInfo_;
};
} // namespace DistributedHardware
} // namespace OHOS
#endif // OHOS_DM_IPC_START_DISCOVERY_REQ_H

54
common/include/ipc/model/ipc_stop_discovery_req.h
View File

@ -1,54 +0,0 @@
/*
* 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_STOP_DISCOVERY_REQ_H
#define OHOS_DM_IPC_STOP_DISCOVERY_REQ_H
#include <cstdint>
#include "ipc_req.h"
namespace OHOS {
namespace DistributedHardware {
class IpcStopDiscoveryReq : public IpcReq {
DECLARE_IPC_MODEL(IpcStopDiscoveryReq);
public:
/**
* @tc.name: IpcStopDiscoveryReq::GetSubscribeId
* @tc.desc: Ipc stop discovery request get subscription id
* @tc.type: FUNC
*/
uint16_t GetSubscribeId() const
{
return subscribeId_;
}
/**
* @tc.name: IpcStopDiscoveryReq::SetSubscribeId
* @tc.desc: Ipc stop discovery request set subscription id
* @tc.type: FUNC
*/
void SetSubscribeId(uint16_t subscribeId)
{
subscribeId_ = subscribeId;
}
private:
uint16_t subscribeId_ { 0 };
};
} // namespace DistributedHardware
} // namespace OHOS
#endif // OHOS_DM_IPC_STOP_DISCOVERY_REQ_H

80
common/src/dm_anonymous.cpp
View File

@ -22,6 +22,7 @@ namespace {
constexpr uint32_t MAX_MESSAGE_LEN = 40 * 1024 * 1024;
constexpr uint32_t MAX_MAP_LEN = 1000;
constexpr uint32_t MAX_INT_LEN = 20;
constexpr uint32_t MAX_ID_LEN = 256;
}
std::string GetAnonyString(const std::string &value)
@ -50,6 +51,15 @@ std::string GetAnonyString(const std::string &value)
return res;
}
std::string GetAnonyStringList(const std::vector<std::string> &values)
{
std::string temp = "";
for (auto const &v : values) {
temp += GetAnonyString(v) + ", ";
}
return temp;
}
std::string GetAnonyInt32(const int32_t value)
{
std::string tempString = std::to_string(value);
@ -64,6 +74,15 @@ std::string GetAnonyInt32(const int32_t value)
return tempString;
}
std::string GetAnonyInt32List(const std::vector<int32_t> &values)
{
std::string temp = "";
for (auto const &v : values) {
temp += GetAnonyInt32(v) + ", ";
}
return temp;
}
bool IsNumberString(const std::string &inputString)
{
LOGI("IsNumberString for DeviceManagerNapi");
@ -265,5 +284,66 @@ bool CompareVersion(const std::string &remoteVersion, const std::string &oldVers
VersionSplitToInt(oldVersion, '.', oldVersionVec);
return CompareVecNum(remoteVersionVec, oldVersionVec);
}
std::string ComposeStr(const std::string &pkgName, uint16_t subscribeId)
{
std::string strTemp = pkgName + "#" + std::to_string(subscribeId);
return strTemp;
}
std::string GetCallerPkgName(const std::string &pkgName)
{
std::istringstream stream(pkgName);
std::string item = "";
getline(stream, item, '#');
return item;
}
uint16_t GetSubscribeId(const std::string &pkgName)
{
std::vector<std::string> strVec;
size_t subIdIndex = 1;
size_t start = 0;
size_t end = pkgName.find("#");
while (end != std::string::npos) {
strVec.push_back(pkgName.substr(start, end - start));
start = end + 1;
end = pkgName.find("#", start);
}
strVec.push_back(pkgName.substr(start));
if (strVec.size() >= subIdIndex + 1) {
return std::atoi(strVec.at(subIdIndex).c_str());
}
return 0;
}
bool IsIdLengthValid(const std::string &inputID)
{
if (inputID.empty() || inputID.length() > MAX_ID_LEN) {
LOGE("On parameter length error, maybe empty or beyond MAX_ID_LEN!");
return false;
}
return true;
}
bool IsMessageLengthValid(const std::string &inputMessage)
{
if (inputMessage.empty() || inputMessage.length() > MAX_MESSAGE_LEN) {
LOGE("On parameter error, maybe empty or beyond MAX_MESSAGE_LEN!");
return false;
}
return true;
}
bool IsValueExist(const std::multimap<std::string, int32_t> unorderedmap, const std::string &udid, int32_t userId)
{
for (const auto &item : unorderedmap) {
if (item.first == udid && item.second == userId) {
return true;
}
}
return false;
}
} // namespace DistributedHardware
} // namespace OHOS

2
common/src/dm_error_message.cpp
View File

@ -25,7 +25,7 @@ typedef struct ERROR_INFO {
} ERROR_INFO;
ERROR_INFO g_errorMessages[] = {
{ERR_DM_FAILED, "dm process execution failed."},
{ERR_DM_FAILED, "dm process execution failed..."},
{ERR_DM_TIME_OUT, "dm process execution timeout."},
{ERR_DM_NOT_INIT, "dm service is not initialized, please try again later."},
{ERR_DM_INIT_FAILED, "dm service initialize failed."},

41
commondependency/include/deviceprofile_connector.h
View File

@ -45,6 +45,7 @@ constexpr uint32_t ACTIVE = 1;
typedef struct DmDiscoveryInfo {
std::string pkgname;
std::string localDeviceId;
int32_t userId;
std::string remoteDeviceIdHash;
} DmDiscoveryInfo;
@ -78,7 +79,7 @@ typedef struct DmAccessee {
typedef struct DmOfflineParam {
uint32_t bindType;
std::vector<std::string> pkgNameVec;
std::vector<OHOS::DistributedHardware::ProcessInfo> processVec;
int32_t leftAclNumber;
} DmOfflineParam;
@ -95,22 +96,25 @@ class DeviceProfileConnector : public IDeviceProfileConnector {
public:
std::vector<DistributedDeviceProfile::AccessControlProfile> GetAccessControlProfile();
std::vector<DistributedDeviceProfile::AccessControlProfile> GetAccessControlProfileByUserId(int32_t userId);
uint32_t CheckBindType(std::string trustDeviceId, std::string requestDeviceId);
std::vector<DistributedDeviceProfile::AccessControlProfile> GetAclProfileByDeviceIdAndUserId(
const std::string &deviceId, int32_t userId);
uint32_t CheckBindType(std::string peerUdid, std::string localUdid);
int32_t PutAccessControlList(DmAclInfo aclInfo, DmAccesser dmAccesser, DmAccessee dmAccessee);
int32_t UpdateAccessControlList(int32_t userId, std::string &oldAccountId, std::string &newAccountId);
std::unordered_map<std::string, DmAuthForm> GetAppTrustDeviceList(const std::string &pkgName,
const std::string &deviceId);
DmOfflineParam GetOfflineParamFromAcl(std::string trustDeviceId, std::string requestDeviceId);
std::vector<int32_t> GetBindTypeByPkgName(std::string pkgName, std::string requestDeviceId,
std::string trustUdid);
std::vector<int32_t> SyncAclByBindType(std::string pkgName, std::vector<int32_t> bindTypeVec,
std::string localDeviceId, std::string targetDeviceId);
int32_t GetDeviceAclParam(DmDiscoveryInfo discoveryInfo, bool &isOnline, int32_t &authForm);
void DeleteAclForAccountLogOut(const std::string &localUdid, int32_t userId, const std::string &remoteUdid);
void DeleteAclForUserRemoved(int32_t userId);
int32_t DeleteAclForAccountLogOut(const std::string &localUdid, int32_t localUserId,
const std::string &peerUdid, int32_t peerUserId);
void DeleteAclForUserRemoved(std::string localUdid, int32_t userId);
DmOfflineParam DeleteAccessControlList(const std::string &pkgName, const std::string &localDeviceId,
const std::string &remoteDeviceId, int32_t bindLevel);
std::vector<std::string> GetPkgNameFromAcl(std::string &localDeviceId, std::string &targetDeviceId);
std::vector<OHOS::DistributedHardware::ProcessInfo> GetProcessInfoFromAclByUserId(const std::string &localDeviceId,
const std::string &targetDeviceId, int32_t userId);
bool CheckIdenticalAccount(int32_t userId, const std::string &accountId);
bool CheckSrcDevIdInAclForDevBind(const std::string &pkgName, const std::string &deviceId);
bool CheckSinkDevIdInAclForDevBind(const std::string &pkgName, const std::string &deviceId);
@ -127,15 +131,30 @@ public:
void DeleteAccessControlList(const std::string &udid);
int32_t GetBindLevel(const std::string &pkgName, const std::string &localUdid,
const std::string &udid, uint64_t &tokenId);
std::map<std::string, int32_t> GetDeviceIdAndBindType(int32_t userId, const std::string &accountId,
std::map<std::string, int32_t> GetDeviceIdAndBindLevel(std::vector<int32_t> userIds, const std::string &localUdid);
std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t userId, const std::string &accountId,
const std::string &localUdid);
int32_t HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
const std::string &remoteUdid, const std::string &localUdid);
int32_t HandleDevUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, const std::string &localUdid);
std::string HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId,
const std::string &localUdid);
OHOS::DistributedHardware::ProcessInfo HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid,
int32_t tokenId, const std::string &localUdid);
std::vector<DistributedDeviceProfile::AccessControlProfile> GetAllAccessControlProfile();
void DeleteAccessControlById(int64_t accessControlId);
int32_t HandleUserSwitched(const std::string &localUdid, int32_t currentUserId, int32_t beforeUserId);
void HandleSyncForegroundUserIdEvent(const std::vector<int32_t> &remoteUserIds, const std::string &remoteUdid,
const std::vector<int32_t> &localUserIds, std::string &localUdid);
std::vector<ProcessInfo> GetOfflineProcessInfo(std::string &localUdid, const std::vector<int32_t> &localUserIds,
const std::string &remoteUdid, const std::vector<int32_t> &remoteUserIds);
std::map<int32_t, int32_t> GetUserIdAndBindLevel(const std::string &localUdid, const std::string &peerUdid);
void UpdatePeerUserId(std::string &localUdid, const std::vector<int32_t> &localUserIds,
const std::string &remoteUdid, const std::vector<int32_t> &remoteFrontUserIds,
const std::vector<int32_t> &remoteBackUserIds);
std::multimap<std::string, int32_t> GetDevIdAndUserIdByActHash(const std::string &localUdid,
const std::string &peerUdid, int32_t peerUserId, const std::string &peerAccountHash);
std::multimap<std::string, int32_t> GetDeviceIdAndUserId(const std::string &localUdid, int32_t localUserId);
void HandleSyncBackgroundUserIdEvent(const std::vector<int32_t> &remoteUserIds, const std::string &remoteUdid,
const std::vector<int32_t> &localUserIds, std::string &localUdid);
private:
int32_t HandleDmAuthForm(DistributedDeviceProfile::AccessControlProfile profiles, DmDiscoveryInfo discoveryInfo);
@ -158,7 +177,9 @@ private:
void DeleteServiceBindLevel(DmOfflineParam &offlineParam, const std::string &pkgName,
const std::vector<DistributedDeviceProfile::AccessControlProfile> &profiles, const std::string &localUdid,
const std::string &remoteUdid);
void UpdateBindType(const std::string &udid, int32_t bindType, std::map<std::string, int32_t> &deviceMap);
void UpdateBindType(const std::string &udid, int32_t compareParam, std::map<std::string, int32_t> &deviceMap);
std::vector<DistributedDeviceProfile::AccessControlProfile> GetAclProfileByUserId(const std::string &localUdid,
int32_t userId, const std::string &remoteUdid);
};
extern "C" IDeviceProfileConnector *CreateDpConnectorInstance();

22
commondependency/include/multiple_user_connector.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* 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
@ -20,6 +20,7 @@
#include <map>
#include <mutex>
#include <string>
#include <vector>
namespace OHOS {
namespace DistributedHardware {
typedef struct DMAccountInfo {
@ -51,11 +52,19 @@ public:
/**
* @tc.name: MultipleUserConnector::GetOhosAccountId
* @tc.desc: Get Current AccountId of the Multiple User Connector
* @tc.desc: Get Current AccountId of current user
* @tc.type: FUNC
*/
static std::string GetOhosAccountId(void);
/**
* @brief Get the Ohos Account Id By Userid
*
* @param userId the user id in which account login
* @return std::string the account id
*/
static std::string GetOhosAccountIdByUserId(int32_t userId);
/**
* @tc.name: MultipleUserConnector::SetSwitchOldAccountId
* @tc.desc: Set Switch Old UserId of the Multiple User Connector
@ -94,6 +103,13 @@ public:
static void SetAccountInfo(int32_t userId, DMAccountInfo dmAccountInfo);
static DMAccountInfo GetAccountInfoByUserId(int32_t userId);
static void DeleteAccountInfoByUserId(int32_t userId);
static void GetTokenIdAndForegroundUserId(uint32_t &tokenId, int32_t &userId);
static void GetCallerUserId(int32_t &userId);
static int32_t GetForegroundUserIds(std::vector<int32_t> &userVec);
static int32_t GetFirstForegroundUserId(void);
static int32_t GetBackgroundUserIds(std::vector<int32_t> &userIdVec);
static int32_t GetAllUserIds(std::vector<int32_t> &userIdVec);
private:
static int32_t oldUserId_;
static std::string accountId_;

659
commondependency/src/deviceprofile_connector.cpp
View File

@ -49,12 +49,42 @@ std::vector<AccessControlProfile> DeviceProfileConnector::GetAccessControlProfil
return profiles;
}
std::vector<AccessControlProfile> DeviceProfileConnector::GetAclProfileByDeviceIdAndUserId(const std::string &deviceId,
int32_t userId)
{
std::vector<AccessControlProfile> profiles;
std::vector<AccessControlProfile> aclProfileVec;
std::map<std::string, std::string> queryParams;
queryParams[USERID] = std::to_string(userId);
if (DistributedDeviceProfileClient::GetInstance().GetAccessControlProfile(queryParams, profiles) != DM_OK) {
LOGE("DP GetAccessControlProfile failed.");
}
for (auto &item : profiles) {
if ((item.GetAccesser().GetAccesserDeviceId() == deviceId &&
item.GetAccesser().GetAccesserUserId() == userId) ||
(item.GetAccessee().GetAccesseeDeviceId() == deviceId &&
item.GetAccessee().GetAccesseeUserId() == userId)) {
aclProfileVec.push_back(item);
}
}
return aclProfileVec;
}
std::unordered_map<std::string, DmAuthForm> DeviceProfileConnector::GetAppTrustDeviceList(const std::string &pkgName,
const std::string &deviceId)
{
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
std::unordered_map<std::string, DmAuthForm> deviceIdMap;
int32_t userId = MultipleUserConnector::GetFirstForegroundUserId();
std::vector<AccessControlProfile> profiles = GetAclProfileByDeviceIdAndUserId(deviceId, userId);
std::vector<AccessControlProfile> profilesFilter = {};
for (auto &item : profiles) {
if ((item.GetAccesser().GetAccesserUserId() == userId && item.GetAccesser().GetAccesserDeviceId() == deviceId)
|| (item.GetAccessee().GetAccesseeUserId() == userId &&
item.GetAccessee().GetAccesseeDeviceId() == deviceId)) {
profilesFilter.push_back(item);
}
}
std::unordered_map<std::string, DmAuthForm> deviceIdMap;
for (auto &item : profilesFilter) {
std::string trustDeviceId = item.GetTrustDeviceId();
if (trustDeviceId == deviceId || item.GetStatus() != ACTIVE) {
continue;
@ -87,18 +117,19 @@ std::unordered_map<std::string, DmAuthForm> DeviceProfileConnector::GetAppTrustD
int32_t DeviceProfileConnector::GetDeviceAclParam(DmDiscoveryInfo discoveryInfo, bool &isOnline, int32_t &authForm)
{
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
if (profiles.size() == 0) {
return DM_OK;
}
std::vector<AccessControlProfile> profiles = GetAccessControlProfileByUserId(discoveryInfo.userId);
std::vector<int32_t> bindTypes;
for (auto &item : profiles) {
char deviceIdHash[DM_MAX_DEVICE_ID_LEN] = {0};
if (Crypto::GetUdidHash(item.GetTrustDeviceId(), reinterpret_cast<uint8_t *>(deviceIdHash)) != DM_OK) {
LOGE("get deviceIdHash by deviceId: %{public}s failed.", GetAnonyString(deviceIdHash).c_str());
return ERR_DM_FAILED;
continue;
}
if (static_cast<std::string>(deviceIdHash) != discoveryInfo.remoteDeviceIdHash || item.GetStatus() != ACTIVE) {
if (static_cast<std::string>(deviceIdHash) != discoveryInfo.remoteDeviceIdHash ||
(discoveryInfo.localDeviceId == item.GetAccesser().GetAccesserDeviceId() &&
discoveryInfo.userId != item.GetAccesser().GetAccesserUserId()) ||
(discoveryInfo.localDeviceId == item.GetAccessee().GetAccesseeDeviceId() &&
discoveryInfo.userId != item.GetAccessee().GetAccesseeUserId())) {
continue;
}
int32_t bindType = HandleDmAuthForm(item, discoveryInfo);
@ -162,17 +193,17 @@ int32_t DeviceProfileConnector::HandleDmAuthForm(AccessControlProfile profiles,
return DmAuthForm::INVALID_TYPE;
}
uint32_t DeviceProfileConnector::CheckBindType(std::string trustDeviceId, std::string requestDeviceId)
uint32_t DeviceProfileConnector::CheckBindType(std::string peerUdid, std::string localUdid)
{
LOGI("Start.");
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
LOGI("AccessControlProfile size is %{public}zu", profiles.size());
std::vector<AccessControlProfile> filterProfiles = GetAclProfileByUserId(localUdid,
MultipleUserConnector::GetFirstForegroundUserId(), peerUdid);
LOGI("filterProfiles size is %{public}zu", filterProfiles.size());
uint32_t highestPriority = INVALIED_TYPE;
for (auto &item : profiles) {
if (trustDeviceId != item.GetTrustDeviceId() || item.GetStatus() != ACTIVE) {
for (auto &item : filterProfiles) {
if (peerUdid != item.GetTrustDeviceId()) {
continue;
}
uint32_t priority = static_cast<uint32_t>(GetAuthForm(item, trustDeviceId, requestDeviceId));
uint32_t priority = static_cast<uint32_t>(GetAuthForm(item, peerUdid, localUdid));
if (priority > highestPriority) {
highestPriority = priority;
}
@ -194,22 +225,18 @@ int32_t DeviceProfileConnector::GetAuthForm(DistributedDeviceProfile::AccessCont
case DM_POINT_TO_POINT:
if (profiles.GetBindLevel() == DEVICE) {
priority = DEVICE_PEER_TO_PEER_TYPE;
} else if (profiles.GetBindLevel() == APP && profiles.GetAccesser().GetAccesserDeviceId() == reqDev &&
profiles.GetAccessee().GetAccesseeDeviceId() == trustDev) {
} else if (profiles.GetBindLevel() == APP) {
priority = APP_PEER_TO_PEER_TYPE;
} else if (profiles.GetBindLevel() == APP && profiles.GetAccessee().GetAccesseeDeviceId() == reqDev &&
profiles.GetAccesser().GetAccesserDeviceId() == trustDev) {
} else if (profiles.GetBindLevel() == APP) {
priority = APP_PEER_TO_PEER_TYPE;
}
break;
case DM_ACROSS_ACCOUNT:
if (profiles.GetBindLevel() == DEVICE) {
priority = DEVICE_ACROSS_ACCOUNT_TYPE;
} else if (profiles.GetBindLevel() == APP && profiles.GetAccesser().GetAccesserDeviceId() == reqDev &&
profiles.GetAccessee().GetAccesseeDeviceId() == trustDev) {
} else if (profiles.GetBindLevel() == APP) {
priority = APP_ACROSS_ACCOUNT_TYPE;
} else if (profiles.GetBindLevel() == APP && profiles.GetAccessee().GetAccesseeDeviceId() == reqDev &&
profiles.GetAccesser().GetAccesserDeviceId() == trustDev) {
} else if (profiles.GetBindLevel() == APP) {
priority = APP_ACROSS_ACCOUNT_TYPE;
}
break;
@ -224,7 +251,8 @@ std::vector<int32_t> DeviceProfileConnector::GetBindTypeByPkgName(std::string pk
std::string trustUdid)
{
LOGI("Start.");
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
std::vector<AccessControlProfile> profiles =
GetAccessControlProfileByUserId(MultipleUserConnector::GetFirstForegroundUserId());
LOGI("AccessControlProfile size is %{public}zu", profiles.size());
std::vector<int32_t> bindTypeVec;
for (auto &item : profiles) {
@ -339,7 +367,8 @@ void DeviceProfileConnector::ProcessBindType(AccessControlProfile profiles, DmDi
std::vector<int32_t> DeviceProfileConnector::SyncAclByBindType(std::string pkgName, std::vector<int32_t> bindTypeVec,
std::string localDeviceId, std::string targetDeviceId)
{
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
std::vector<AccessControlProfile> profiles =
GetAccessControlProfileByUserId(MultipleUserConnector::GetFirstForegroundUserId());
LOGI("AccessControlProfile size is %{public}zu", profiles.size());
std::vector<int32_t> sinkBindType;
std::vector<int32_t> bindType;
@ -361,61 +390,23 @@ std::vector<int32_t> DeviceProfileConnector::SyncAclByBindType(std::string pkgNa
return bindType;
}
std::vector<std::string> DeviceProfileConnector::GetPkgNameFromAcl(std::string &localDeviceId,
std::string &targetDeviceId)
std::vector<OHOS::DistributedHardware::ProcessInfo> DeviceProfileConnector::GetProcessInfoFromAclByUserId(
const std::string &localDeviceId, const std::string &targetDeviceId, int32_t userId)
{
LOGI("Start.");
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
LOGI("AccessControlProfile size is %{public}zu", profiles.size());
std::vector<std::string> pkgNameVec;
for (auto &item : profiles) {
std::vector<AccessControlProfile> filterProfiles = GetAclProfileByUserId(localDeviceId,
userId, targetDeviceId);
LOGI("filterProfiles size is %{public}zu", filterProfiles.size());
std::vector<OHOS::DistributedHardware::ProcessInfo> processInfoVec;
for (auto &item : filterProfiles) {
if (item.GetTrustDeviceId() != targetDeviceId || item.GetStatus() != ACTIVE) {
continue;
}
if ((item.GetAccesser().GetAccesserDeviceId() == localDeviceId &&
item.GetAccessee().GetAccesseeDeviceId() == targetDeviceId) ||
(item.GetAccesser().GetAccesserDeviceId() == targetDeviceId &&
item.GetAccessee().GetAccesseeDeviceId() == localDeviceId)) {
pkgNameVec.push_back(item.GetAccesser().GetAccesserBundleName());
}
OHOS::DistributedHardware::ProcessInfo processInfo;
processInfo.pkgName = item.GetAccesser().GetAccesserBundleName();
processInfo.userId = item.GetAccesser().GetAccesserUserId();
processInfoVec.push_back(processInfo);
}
return pkgNameVec;
}
DmOfflineParam DeviceProfileConnector::GetOfflineParamFromAcl(std::string trustDeviceId, std::string requestDeviceId)
{
LOGI("TrustDeviceId = %{public}s and requestDeviceId = %{public}s",
GetAnonyString(trustDeviceId).c_str(), GetAnonyString(requestDeviceId).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
LOGI("AccessControlProfile size is %{public}zu", profiles.size());
DmOfflineParam offlineParam;
offlineParam.leftAclNumber = 0;
offlineParam.bindType = INVALIED_TYPE;
for (auto &item : profiles) {
if (item.GetTrustDeviceId() != trustDeviceId || item.GetStatus() != ACTIVE) {
continue;
}
offlineParam.leftAclNumber++;
uint32_t priority = INVALIED_TYPE;
if (item.GetBindType() == DM_IDENTICAL_ACCOUNT) {
priority = IDENTICAL_ACCOUNT_TYPE;
} else if (item.GetBindLevel() == DEVICE && item.GetAuthenticationType() == ALLOW_AUTH_ALWAYS) {
priority = DEVICE_PEER_TO_PEER_TYPE;
} else if (item.GetBindLevel() == DEVICE && item.GetAuthenticationType() == ALLOW_AUTH_ONCE) {
priority = DEVICE_PEER_TO_PEER_TYPE;
offlineParam.pkgNameVec.push_back(item.GetAccesser().GetAccesserBundleName());
} else if ((item.GetAccesser().GetAccesserDeviceId() == requestDeviceId &&
item.GetAccessee().GetAccesseeDeviceId() == trustDeviceId) ||
(item.GetAccesser().GetAccesserDeviceId() == trustDeviceId &&
item.GetAccessee().GetAccesseeDeviceId() == requestDeviceId)) {
priority = APP_PEER_TO_PEER_TYPE;
offlineParam.pkgNameVec.push_back(item.GetAccesser().GetAccesserBundleName());
}
if (priority > offlineParam.bindType) {
offlineParam.bindType = priority;
}
}
return offlineParam;
return processInfoVec;
}
int32_t DeviceProfileConnector::PutAccessControlList(DmAclInfo aclInfo, DmAccesser dmAccesser, DmAccessee dmAccessee)
@ -450,25 +441,48 @@ int32_t DeviceProfileConnector::PutAccessControlList(DmAclInfo aclInfo, DmAccess
return ret;
}
void DeviceProfileConnector::DeleteAclForAccountLogOut(const std::string &localUdid, int32_t userId,
const std::string &remoteUdid)
int32_t DeviceProfileConnector::DeleteAclForAccountLogOut(const std::string &localUdid, int32_t localUserId,
const std::string &peerUdid, int32_t peerUserId)
{
LOGI("localUdid %{public}s, userId %{public}d, remoteUdid %{public}s.", GetAnonyString(localUdid).c_str(), userId,
GetAnonyString(remoteUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfileByUserId(userId);
LOGI("localUdid %{public}s, localUserId %{public}d, peerUdid %{public}s, peerUserId %{public}d.",
GetAnonyString(localUdid).c_str(), localUserId, GetAnonyString(peerUdid).c_str(), peerUserId);
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
bool notifyOffline = false;
for (const auto &item : profiles) {
if (item.GetTrustDeviceId() == remoteUdid) {
if (item.GetTrustDeviceId() != peerUdid) {
continue;
}
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserId = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserId = item.GetAccessee().GetAccesseeUserId();
if (accesserUdid == localUdid && accesserUserId == localUserId &&
accesseeUdid == peerUdid && accesseeUserId == peerUserId) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
notifyOffline = (item.GetStatus() == ACTIVE);
continue;
}
if (accesserUdid == peerUdid && accesserUserId == peerUserId &&
accesseeUdid == localUdid && accesseeUserId == localUserId) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
notifyOffline = (item.GetStatus() == ACTIVE);
continue;
}
}
return notifyOffline;
}
void DeviceProfileConnector::DeleteAclForUserRemoved(int32_t userId)
void DeviceProfileConnector::DeleteAclForUserRemoved(std::string localUdid, int32_t userId)
{
LOGI("DeleteAclForUserRemoved userId %{public}d.", userId);
LOGI("localUdid %{public}s, userId %{public}d.", GetAnonyString(localUdid).c_str(), userId);
std::vector<AccessControlProfile> profiles = GetAccessControlProfileByUserId(userId);
for (const auto &item : profiles) {
if (item.GetAccesser().GetAccesserUserId() == userId || item.GetAccessee().GetAccesseeUserId() == userId) {
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserId = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserId = item.GetAccessee().GetAccesseeUserId();
if ((accesserUdid == localUdid && accesserUserId == userId) ||
(accesseeUdid == localUdid && accesseeUserId == userId)) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
}
}
@ -539,6 +553,10 @@ void DeviceProfileConnector::DeleteAppBindLevel(DmOfflineParam &offlineParam, co
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
deleteNums++;
offlineParam.bindType = APP;
ProcessInfo processInfo;
processInfo.pkgName = item.GetAccesser().GetAccesserBundleName();
processInfo.userId = item.GetAccesser().GetAccesserUserId();
offlineParam.processVec.push_back(processInfo);
LOGI("Src delete acl pkgName %{public}s, bindType %{public}d, localUdid %{public}s, remoteUdid %{public}s",
pkgName.c_str(), item.GetBindType(), GetAnonyString(localUdid).c_str(),
GetAnonyString(remoteUdid).c_str());
@ -550,6 +568,10 @@ void DeviceProfileConnector::DeleteAppBindLevel(DmOfflineParam &offlineParam, co
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
deleteNums++;
offlineParam.bindType = APP;
ProcessInfo processInfo;
processInfo.pkgName = item.GetAccessee().GetAccesseeBundleName();
processInfo.userId = item.GetAccessee().GetAccesseeUserId();
offlineParam.processVec.push_back(processInfo);
LOGI("Sink delete acl pkgName %{public}s, bindType %{public}d, localUdid %{public}s, remoteUdid %{public}s",
pkgName.c_str(), item.GetBindType(), GetAnonyString(localUdid).c_str(),
GetAnonyString(remoteUdid).c_str());
@ -653,24 +675,6 @@ int32_t DeviceProfileConnector::UpdateAccessControlList(int32_t userId, std::str
return DM_OK;
}
bool DeviceProfileConnector::CheckIdenticalAccount(int32_t userId, const std::string &accountId)
{
LOGI("Start");
std::vector<AccessControlProfile> profiles;
std::map<std::string, std::string> queryParams;
queryParams[USERID] = std::to_string(userId);
queryParams[ACCOUNTID] = accountId;
if (DistributedDeviceProfileClient::GetInstance().GetAccessControlProfile(queryParams, profiles) != DM_OK) {
LOGE("DP GetAccessControlProfile failed.");
}
for (auto &item : profiles) {
if (item.GetBindType() == DM_IDENTICAL_ACCOUNT && item.GetStatus() == ACTIVE) {
return true;
}
}
return false;
}
bool DeviceProfileConnector::CheckSrcDevIdInAclForDevBind(const std::string &pkgName, const std::string &deviceId)
{
LOGI("Start");
@ -756,13 +760,48 @@ int32_t DeviceProfileConnector::IsSameAccount(const std::string &udid)
return ERR_DM_FAILED;
}
std::vector<AccessControlProfile> GetACLByDeviceIdAndUserId(std::vector<AccessControlProfile> profiles,
const DmAccessCaller &caller, const std::string &srcUdid, const DmAccessCallee &callee, const std::string &sinkUdid)
{
std::vector<AccessControlProfile> profilesFilter;
for (auto &item : profiles) {
if (item.GetAccesser().GetAccesserUserId() == caller.userId
&& item.GetAccesser().GetAccesserDeviceId() == srcUdid
&& item.GetAccessee().GetAccesseeDeviceId() == sinkUdid) {
profilesFilter.push_back(item);
continue;
}
if (item.GetAccesser().GetAccesserUserId() == callee.userId
&& item.GetAccesser().GetAccesserDeviceId() == sinkUdid
&& item.GetAccessee().GetAccesseeDeviceId() == srcUdid) {
profilesFilter.push_back(item);
continue;
}
if (item.GetAccessee().GetAccesseeUserId() == caller.userId
&& item.GetAccessee().GetAccesseeDeviceId() == srcUdid
&& item.GetAccesser().GetAccesserDeviceId() == sinkUdid) {
profilesFilter.push_back(item);
continue;
}
if (item.GetAccessee().GetAccesseeUserId() == callee.userId
&& item.GetAccessee().GetAccesseeDeviceId() == sinkUdid
&& item.GetAccesser().GetAccesserDeviceId() == srcUdid) {
profilesFilter.push_back(item);
continue;
}
}
return profilesFilter;
}
int32_t DeviceProfileConnector::CheckAccessControl(const DmAccessCaller &caller, const std::string &srcUdid,
const DmAccessCallee &callee, const std::string &sinkUdid)
{
LOGI("PkgName %{public}s, srcUdid %{public}s, sinkUdid %{public}s",
caller.pkgName.c_str(), GetAnonyString(srcUdid).c_str(), GetAnonyString(sinkUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
for (auto &item : profiles) {
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::vector<AccessControlProfile> profilesFilter
= GetACLByDeviceIdAndUserId(profiles, caller, srcUdid, callee, sinkUdid);
for (auto &item : profilesFilter) {
if (item.GetStatus() != ACTIVE || (item.GetTrustDeviceId() != sinkUdid &&
item.GetTrustDeviceId() != srcUdid)) {
continue;
@ -774,6 +813,24 @@ int32_t DeviceProfileConnector::CheckAccessControl(const DmAccessCaller &caller,
return ERR_DM_FAILED;
}
bool DeviceProfileConnector::CheckIdenticalAccount(int32_t userId, const std::string &accountId)
{
LOGI("Start");
std::vector<AccessControlProfile> profiles;
std::map<std::string, std::string> queryParams;
queryParams[USERID] = std::to_string(userId);
queryParams[ACCOUNTID] = accountId;
if (DistributedDeviceProfileClient::GetInstance().GetAccessControlProfile(queryParams, profiles) != DM_OK) {
LOGE("DP GetAccessControlProfile failed.");
}
for (auto &item : profiles) {
if (item.GetBindType() == DM_IDENTICAL_ACCOUNT && item.GetStatus() == ACTIVE) {
return true;
}
}
return false;
}
bool DeviceProfileConnector::SingleUserProcess(const DistributedDeviceProfile::AccessControlProfile &profile,
const DmAccessCaller &caller, const DmAccessCallee &callee)
{
@ -813,8 +870,10 @@ int32_t DeviceProfileConnector::CheckIsSameAccount(const DmAccessCaller &caller,
{
LOGI("DeviceProfileConnector::CheckIsSameAccount pkgName %{public}s, srcUdid %{public}s, sinkUdid %{public}s",
caller.pkgName.c_str(), GetAnonyString(srcUdid).c_str(), GetAnonyString(sinkUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
for (auto &item : profiles) {
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::vector<AccessControlProfile> profilesFilter
= GetACLByDeviceIdAndUserId(profiles, caller, srcUdid, callee, sinkUdid);
for (auto &item : profilesFilter) {
if (item.GetStatus() != ACTIVE || (item.GetTrustDeviceId() != sinkUdid &&
item.GetTrustDeviceId() != srcUdid)) {
continue;
@ -858,56 +917,94 @@ int32_t DeviceProfileConnector::GetBindLevel(const std::string &pkgName, const s
return bindLevel;
}
std::map<std::string, int32_t> DeviceProfileConnector::GetDeviceIdAndBindType(int32_t userId,
const std::string &accountId, const std::string &localUdid)
std::map<std::string, int32_t> DeviceProfileConnector::GetDeviceIdAndBindLevel(std::vector<int32_t> userIds,
const std::string &localUdid)
{
LOGI("userId %{public}d, accountId %{public}s.", userId, GetAnonyString(accountId).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfileByUserId(userId);
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::map<std::string, int32_t> deviceIdMap;
for (const auto &item : profiles) {
if (item.GetAccesser().GetAccesserUserId() == userId &&
item.GetAccesser().GetAccesserAccountId() == accountId &&
if (find(userIds.begin(), userIds.end(), item.GetAccesser().GetAccesserUserId()) != userIds.end() &&
item.GetAccesser().GetAccesserDeviceId() == localUdid) {
LOGI("Account logout localUdid %{public}s is src.", GetAnonyString(localUdid).c_str());
UpdateBindType(item.GetTrustDeviceId(), item.GetBindType(), deviceIdMap);
LOGI("Get Device Bind type localUdid %{public}s is src.", GetAnonyString(localUdid).c_str());
UpdateBindType(item.GetTrustDeviceId(), item.GetBindLevel(), deviceIdMap);
continue;
}
if (item.GetAccessee().GetAccesseeUserId() == userId &&
item.GetAccessee().GetAccesseeAccountId() == accountId &&
if (find(userIds.begin(), userIds.end(), item.GetAccessee().GetAccesseeUserId()) != userIds.end() &&
item.GetAccessee().GetAccesseeDeviceId() == localUdid) {
LOGI("Account logout localUdid %{public}s is sink.", GetAnonyString(localUdid).c_str());
UpdateBindType(item.GetTrustDeviceId(), item.GetBindType(), deviceIdMap);
LOGI("Get Device Bind type localUdid %{public}s is sink.", GetAnonyString(localUdid).c_str());
UpdateBindType(item.GetTrustDeviceId(), item.GetBindLevel(), deviceIdMap);
continue;
}
}
return deviceIdMap;
}
void DeviceProfileConnector::UpdateBindType(const std::string &udid, int32_t bindType,
std::multimap<std::string, int32_t> DeviceProfileConnector::GetDeviceIdAndUserId(int32_t userId,
const std::string &accountId, const std::string &localUdid)
{
LOGI("localUdid %{public}s, userId %{public}d, accountId %{public}s.", GetAnonyString(localUdid).c_str(),
userId, GetAnonyString(accountId).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::multimap<std::string, int32_t> deviceIdMap;
for (const auto &item : profiles) {
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserId = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserId = item.GetAccessee().GetAccesseeUserId();
if (accesserUdid == localUdid && accesserUserId == userId && item.GetBindType() == DM_IDENTICAL_ACCOUNT) {
LOGI("Account logout trust udid %{public}s userid %{public}d is src.",
GetAnonyString(accesseeUdid).c_str(), accesseeUserId);
deviceIdMap.insert(std::pair<std::string, int32_t>(accesseeUdid, accesseeUserId));
continue;
}
if (accesseeUdid == localUdid && accesseeUserId == userId && item.GetBindType() == DM_IDENTICAL_ACCOUNT) {
LOGI("Account logout trust udid %{public}s userid %{public}d is sink.",
GetAnonyString(accesserUdid).c_str(), accesserUserId);
deviceIdMap.insert(std::pair<std::string, int32_t>(accesserUdid, accesserUserId));
continue;
}
}
return deviceIdMap;
}
void DeviceProfileConnector::UpdateBindType(const std::string &udid, int32_t compareParam,
std::map<std::string, int32_t> &deviceMap)
{
LOGI("BindType %{public}d.", bindType);
LOGI("BindType %{public}d.", compareParam);
if (deviceMap.find(udid) == deviceMap.end()) {
deviceMap[udid] = bindType;
deviceMap[udid] = compareParam;
} else {
deviceMap[udid] = std::min(deviceMap[udid], bindType);
deviceMap[udid] = std::min(deviceMap[udid], compareParam);
}
}
int32_t DeviceProfileConnector::HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
const std::string &remoteUdid, const std::string &localUdid)
int32_t DeviceProfileConnector::HandleAccountLogoutEvent(int32_t remoteUserId,
const std::string &remoteAccountHash, const std::string &remoteUdid, const std::string &localUdid)
{
LOGI("RemoteUserId %{public}d, remoteAccountHash %{public}s, remoteUdid %{public}s, localUdid %{public}s.",
remoteUserId, GetAnonyString(remoteAccountHash).c_str(), GetAnonyString(remoteUdid).c_str(),
GetAnonyString(localUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
std::vector<AccessControlProfile> profiles = GetAccessControlProfileByUserId(remoteUserId);
std::map<int32_t, int32_t> uaerIdAndBindType;
int32_t bindType = DM_INVALIED_BINDTYPE;
for (const auto &item : profiles) {
if (item.GetTrustDeviceId() != remoteUdid) {
continue;
}
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
bindType = DM_IDENTICAL_ACCOUNT;
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserId = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserId = item.GetAccessee().GetAccesseeUserId();
if (accesserUdid == localUdid && accesseeUdid == remoteUdid && accesseeUserId == remoteUserId) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
bindType = DM_IDENTICAL_ACCOUNT;
continue;
}
if (accesseeUdid == localUdid && accesserUdid == remoteUdid && accesserUserId == remoteUserId) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
bindType = DM_IDENTICAL_ACCOUNT;
continue;
}
}
return bindType;
}
@ -945,13 +1042,13 @@ int32_t DeviceProfileConnector::HandleDevUnBindEvent(int32_t remoteUserId, const
return bindType;
}
std::string DeviceProfileConnector::HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid,
int32_t tokenId, const std::string &localUdid)
OHOS::DistributedHardware::ProcessInfo DeviceProfileConnector::HandleAppUnBindEvent(int32_t remoteUserId,
const std::string &remoteUdid, int32_t tokenId, const std::string &localUdid)
{
LOGI("RemoteUserId %{public}d, remoteUdid %{public}s, tokenId %{public}d, localUdid %{public}s.",
remoteUserId, GetAnonyString(remoteUdid).c_str(), tokenId, GetAnonyString(localUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAccessControlProfile();
std::string pkgName = "";
ProcessInfo processInfo;
for (const auto &item : profiles) {
if (item.GetTrustDeviceId() != remoteUdid || item.GetBindType() == DM_IDENTICAL_ACCOUNT ||
item.GetBindLevel() != APP) {
@ -963,7 +1060,8 @@ std::string DeviceProfileConnector::HandleAppUnBindEvent(int32_t remoteUserId, c
item.GetAccessee().GetAccesseeDeviceId() == localUdid) {
LOGI("Src device unbind.");
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
pkgName = item.GetAccesser().GetAccesserBundleName();
processInfo.pkgName = item.GetAccessee().GetAccesseeBundleName();
processInfo.userId = item.GetAccessee().GetAccesseeUserId();
continue;
}
if (item.GetAccessee().GetAccesseeUserId() == remoteUserId &&
@ -972,11 +1070,12 @@ std::string DeviceProfileConnector::HandleAppUnBindEvent(int32_t remoteUserId, c
item.GetAccesser().GetAccesserDeviceId() == localUdid) {
LOGI("Sink device unbind.");
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
pkgName = item.GetAccessee().GetAccesseeBundleName();
processInfo.pkgName = item.GetAccesser().GetAccesserBundleName();
processInfo.userId = item.GetAccesser().GetAccesserUserId();
continue;
}
}
return pkgName;
return processInfo;
}
std::vector<AccessControlProfile> DeviceProfileConnector::GetAllAccessControlProfile()
@ -993,6 +1092,300 @@ void DeviceProfileConnector::DeleteAccessControlById(int64_t accessControlId)
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(accessControlId);
}
int32_t DeviceProfileConnector::HandleUserSwitched(const std::string &localUdid, int32_t currentUserId,
int32_t beforeUserId)
{
LOGI("Start.");
std::vector<AccessControlProfile> profiles = GetAccessControlProfileByUserId(beforeUserId);
LOGI("to inactive ACL size is %{public}zu", profiles.size());
for (auto &item : profiles) {
if ((item.GetAccesser().GetAccesserDeviceId() == localUdid &&
item.GetAccesser().GetAccesserUserId() == beforeUserId) ||
(item.GetAccessee().GetAccesseeDeviceId() == localUdid &&
item.GetAccessee().GetAccesseeUserId() == beforeUserId)) {
item.SetStatus(INACTIVE);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
continue;
}
if ((item.GetAccesser().GetAccesserDeviceId() == localUdid &&
item.GetAccesser().GetAccesserUserId() == currentUserId) || (
item.GetAccessee().GetAccesseeDeviceId() == localUdid &&
item.GetAccessee().GetAccesseeUserId() == currentUserId)) {
item.SetStatus(ACTIVE);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
continue;
}
}
return DM_OK;
}
std::vector<AccessControlProfile> DeviceProfileConnector::GetAclProfileByUserId(const std::string &localUdid,
int32_t userId, const std::string &remoteUdid)
{
LOGI("localUdid %{public}s, localUserId %{public}d, remoteUdid %{public}s.", GetAnonyString(localUdid).c_str(),
userId, GetAnonyString(remoteUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::vector<AccessControlProfile> profilesTemp;
for (const auto &item : profiles) {
if (item.GetAccesser().GetAccesserDeviceId() == localUdid &&
item.GetAccesser().GetAccesserUserId() == userId &&
item.GetAccessee().GetAccesseeDeviceId() == remoteUdid) {
profilesTemp.push_back(item);
} else if (item.GetAccessee().GetAccesseeDeviceId() == localUdid &&
item.GetAccessee().GetAccesseeUserId() == userId &&
item.GetAccesser().GetAccesserDeviceId() == remoteUdid) {
profilesTemp.push_back(item);
}
}
return profilesTemp;
}
void DeviceProfileConnector::HandleSyncForegroundUserIdEvent(const std::vector<int32_t> &remoteUserIds,
const std::string &remoteUdid, const std::vector<int32_t> &localUserIds, std::string &localUdid)
{
LOGI("localUdid %{public}s, remoteUdid %{public}s.", GetAnonyString(localUdid).c_str(),
GetAnonyString(remoteUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
for (auto &item : profiles) {
if (item.GetAccesser().GetAccesserDeviceId() == localUdid &&
item.GetAccessee().GetAccesseeDeviceId() == remoteUdid &&
find(localUserIds.begin(), localUserIds.end(),
item.GetAccesser().GetAccesserUserId()) != localUserIds.end() &&
find(remoteUserIds.begin(), remoteUserIds.end(),
item.GetAccessee().GetAccesseeUserId()) != remoteUserIds.end()) {
item.SetStatus(ACTIVE);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
} else if (item.GetAccessee().GetAccesseeDeviceId() == localUdid &&
item.GetAccesser().GetAccesserDeviceId() == remoteUdid &&
find(localUserIds.begin(), localUserIds.end(),
item.GetAccessee().GetAccesseeUserId()) != localUserIds.end() &&
find(remoteUserIds.begin(), remoteUserIds.end(),
item.GetAccesser().GetAccesserUserId()) != remoteUserIds.end()) {
item.SetStatus(ACTIVE);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
}
}
}
std::vector<ProcessInfo> DeviceProfileConnector::GetOfflineProcessInfo(std::string &localUdid,
const std::vector<int32_t> &localUserIds, const std::string &remoteUdid, const std::vector<int32_t> &remoteUserIds)
{
LOGI("localUdid %{public}s, remoteUdid %{public}s.", GetAnonyString(localUdid).c_str(),
GetAnonyString(remoteUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::vector<ProcessInfo> processInfos;
int32_t bindLevel = 100;
for (const auto &item : profiles) {
ProcessInfo processInfo;
if (item.GetAccesser().GetAccesserDeviceId() == localUdid &&
item.GetAccessee().GetAccesseeDeviceId() == remoteUdid &&
find(localUserIds.begin(), localUserIds.end(),
item.GetAccesser().GetAccesserUserId()) != localUserIds.end() &&
find(remoteUserIds.begin(), remoteUserIds.end(),
item.GetAccessee().GetAccesseeUserId()) != remoteUserIds.end() &&
item.GetStatus() == ACTIVE) {
processInfo.pkgName = item.GetAccesser().GetAccesserBundleName();
processInfo.userId = item.GetAccesser().GetAccesserUserId();
bindLevel = std::min(bindLevel, static_cast<int32_t>(item.GetBindLevel()));
} else if (item.GetAccessee().GetAccesseeDeviceId() == localUdid &&
item.GetAccesser().GetAccesserDeviceId() == remoteUdid &&
find(localUserIds.begin(), localUserIds.end(),
item.GetAccessee().GetAccesseeUserId()) != localUserIds.end() &&
find(remoteUserIds.begin(), remoteUserIds.end(),
item.GetAccesser().GetAccesserUserId()) != remoteUserIds.end() &&
item.GetStatus() == ACTIVE) {
processInfo.pkgName = item.GetAccessee().GetAccesseeBundleName();
processInfo.userId = item.GetAccessee().GetAccesseeUserId();
bindLevel = std::min(bindLevel, static_cast<int32_t>(item.GetBindLevel()));
}
processInfos.push_back(processInfo);
}
if (bindLevel == INVALIED_TYPE || bindLevel == DEVICE) {
processInfos.clear();
for (const auto &item : localUserIds) {
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = item;
processInfos.push_back(processInfo);
}
}
return processInfos;
}
std::map<int32_t, int32_t> DeviceProfileConnector::GetUserIdAndBindLevel(const std::string &localUdid,
const std::string &peerUdid)
{
LOGI("localUdid %{public}s, peerUdid %{public}s.", GetAnonyString(localUdid).c_str(),
GetAnonyString(peerUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::map<int32_t, int32_t> userIdAndBindLevel;
for (const auto &item : profiles) {
if (item.GetStatus() == INACTIVE) {
continue;
}
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserid = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserid = item.GetAccessee().GetAccesseeUserId();
if (accesserUdid == localUdid && accesseeUdid == peerUdid) {
if (userIdAndBindLevel.find(accesserUserid) == userIdAndBindLevel.end()) {
userIdAndBindLevel[accesserUserid] = item.GetBindLevel();
} else {
userIdAndBindLevel[accesserUserid] =
std::min(static_cast<int32_t>(item.GetBindLevel()), userIdAndBindLevel[accesserUserid]);
}
} else if (accesseeUdid == localUdid && accesserUdid == peerUdid) {
if (userIdAndBindLevel.find(accesseeUserid) == userIdAndBindLevel.end()) {
userIdAndBindLevel[accesseeUserid] = item.GetBindLevel();
} else {
userIdAndBindLevel[accesseeUserid] =
std::min(static_cast<int32_t>(item.GetBindLevel()), userIdAndBindLevel[accesseeUserid]);
}
}
}
return userIdAndBindLevel;
}
void DeviceProfileConnector::UpdatePeerUserId(std::string &localUdid, const std::vector<int32_t> &localUserIds,
const std::string &remoteUdid, const std::vector<int32_t> &remoteFrontUserIds,
const std::vector<int32_t> &remoteBackUserIds)
{
LOGI("localUdid %{public}s, remoteUdid %{public}s.", GetAnonyString(localUdid).c_str(),
GetAnonyString(remoteUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
for (auto item : profiles) {
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserid = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserid = item.GetAccessee().GetAccesseeUserId();
int32_t bindType = item.GetBindType();
// deleta signal trust acl.
if (accesserUdid == remoteUdid && accesserUserid != 0 && accesserUserid != -1 &&
find(remoteFrontUserIds.begin(), remoteFrontUserIds.end(), accesserUserid) == remoteFrontUserIds.end() &&
find(remoteBackUserIds.begin(), remoteBackUserIds.end(), accesserUserid) == remoteBackUserIds.end()) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
continue;
}
if (accesseeUdid == remoteUdid && accesseeUserid != 0 && accesseeUserid != -1 &&
find(remoteFrontUserIds.begin(), remoteFrontUserIds.end(), accesseeUserid) == remoteFrontUserIds.end() &&
find(remoteBackUserIds.begin(), remoteBackUserIds.end(), accesseeUserid) == remoteBackUserIds.end()) {
DistributedDeviceProfileClient::GetInstance().DeleteAccessControlProfile(item.GetAccessControlId());
continue;
}
// update identical account userId.
if (accesserUdid == localUdid && accesseeUdid == remoteUdid && bindType == DM_IDENTICAL_ACCOUNT &&
find(localUserIds.begin(), localUserIds.end(), accesserUserid) != localUserIds.end() &&
(accesseeUserid == 0 || accesseeUserid == -1)) {
Accessee accessee = item.GetAccessee();
accessee.SetAccesseeUserId(remoteFrontUserIds[0]);
item.SetAccessee(accessee);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
continue;
}
if (accesserUdid == remoteUdid && accesseeUdid == localUdid && bindType == DM_IDENTICAL_ACCOUNT &&
find(localUserIds.begin(), localUserIds.end(), accesseeUserid) != localUserIds.end() &&
(accesserUserid == 0 || accesserUserid == -1)) {
Accesser accesser = item.GetAccesser();
accesser.SetAccesserUserId(remoteFrontUserIds[0]);
item.SetAccesser(accesser);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
continue;
}
}
}
std::multimap<std::string, int32_t> DeviceProfileConnector::GetDevIdAndUserIdByActHash(const std::string &localUdid,
const std::string &peerUdid, int32_t peerUserId, const std::string &peerAccountHash)
{
LOGI("localUdid %{public}s, peerUdid %{public}s, peerUserId %{public}d, peerAccountHash %{public}s.",
GetAnonyString(localUdid).c_str(), GetAnonyString(peerUdid).c_str(), peerUserId, peerAccountHash.c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::multimap<std::string, int32_t> deviceIdMap;
for (const auto &item : profiles) {
std::string accesserAccountId = item.GetAccesser().GetAccesserAccountId();
std::string accesseeAccountId = item.GetAccessee().GetAccesseeAccountId();
char accesserAccountIdHash[DM_MAX_DEVICE_ID_LEN] = {0};
if (Crypto::GetAccountIdHash(accesserAccountId, reinterpret_cast<uint8_t *>(accesserAccountIdHash)) != DM_OK) {
LOGE("GetAccountHash failed.");
return deviceIdMap;
}
char accesseeAccountIdHash[DM_MAX_DEVICE_ID_LEN] = {0};
if (Crypto::GetAccountIdHash(accesseeAccountId, reinterpret_cast<uint8_t *>(accesseeAccountIdHash)) != DM_OK) {
LOGE("GetAccountHash failed.");
return deviceIdMap;
}
LOGI("accesserAccountIdHash %{public}s, accesseeAccountIdHash %{public}s", accesserAccountIdHash,
accesseeAccountIdHash);
if (std::string(accesserAccountIdHash) != peerAccountHash ||
std::string(accesseeAccountIdHash) != peerAccountHash) {
continue;
}
std::string accesserUdid = item.GetAccesser().GetAccesserDeviceId();
std::string accesseeUdid = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesserUserid = item.GetAccesser().GetAccesserUserId();
int32_t accesseeUserid = item.GetAccessee().GetAccesseeUserId();
if (accesserUdid == localUdid && accesseeUdid == peerUdid && accesseeUserid == peerUserId) {
deviceIdMap.insert(std::pair<std::string, int32_t>(accesserUdid, accesserUserid));
continue;
}
if (accesseeUdid == localUdid && accesserUdid == peerUdid && accesserUserid == peerUserId) {
deviceIdMap.insert(std::pair<std::string, int32_t>(accesseeUdid, accesseeUserid));
continue;
}
}
return deviceIdMap;
}
std::multimap<std::string, int32_t> DeviceProfileConnector::GetDeviceIdAndUserId(const std::string &localUdid,
int32_t localUserId)
{
LOGI("localUdid %{public}s, userId %{public}d.", GetAnonyString(localUdid).c_str(), localUserId);
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
std::multimap<std::string, int32_t> deviceIdMap;
for (const auto &item : profiles) {
std::string accesserDeviceId = item.GetAccesser().GetAccesserDeviceId();
int32_t accesserUserId = item.GetAccesser().GetAccesserUserId();
std::string accesseeDeviceId = item.GetAccessee().GetAccesseeDeviceId();
int32_t accesseeUserId = item.GetAccessee().GetAccesseeUserId();
if (accesserDeviceId == localUdid && accesserUserId == localUserId) {
if (!IsValueExist(deviceIdMap, accesseeDeviceId, accesseeUserId)) {
deviceIdMap.insert(std::pair<std::string, int32_t>(accesseeDeviceId, accesseeUserId));
}
continue;
}
if (accesseeDeviceId == localUdid && accesseeUserId == localUserId) {
if (!IsValueExist(deviceIdMap, accesserDeviceId, accesserUserId)) {
deviceIdMap.insert(std::pair<std::string, int32_t>(accesserDeviceId, accesserUserId));
}
continue;
}
}
return deviceIdMap;
}
void DeviceProfileConnector::HandleSyncBackgroundUserIdEvent(const std::vector<int32_t> &remoteUserIds,
const std::string &remoteUdid, const std::vector<int32_t> &localUserIds, std::string &localUdid)
{
LOGI("localUdid %{public}s, remoteUdid %{public}s.", GetAnonyString(localUdid).c_str(),
GetAnonyString(remoteUdid).c_str());
std::vector<AccessControlProfile> profiles = GetAllAccessControlProfile();
for (auto &item : profiles) {
if (item.GetAccesser().GetAccesserDeviceId() == localUdid &&
item.GetAccessee().GetAccesseeDeviceId() == remoteUdid &&
find(remoteUserIds.begin(), remoteUserIds.end(),
item.GetAccessee().GetAccesseeUserId()) != remoteUserIds.end()) {
item.SetStatus(INACTIVE);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
} else if ((item.GetAccessee().GetAccesseeDeviceId() == localUdid &&
item.GetAccesser().GetAccesserDeviceId() == remoteUdid) &&
find(remoteUserIds.begin(), remoteUserIds.end(),
item.GetAccesser().GetAccesserUserId()) == remoteUserIds.end()) {
item.SetStatus(INACTIVE);
DistributedDeviceProfileClient::GetInstance().UpdateAccessControlProfile(item);
}
}
}
IDeviceProfileConnector *CreateDpConnectorInstance()
{
return &DeviceProfileConnector::GetInstance();

146
commondependency/src/multiple_user_connector.cpp
View File

@ -15,10 +15,11 @@
#include "multiple_user_connector.h"
#include "dm_constants.h"
#include "dm_log.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "account_info.h"
#include "ipc_skeleton.h"
#include "ohos_account_kits.h"
#ifdef OS_ACCOUNT_PART_EXISTS
#include "os_account_manager.h"
@ -72,6 +73,25 @@ std::string MultipleUserConnector::GetOhosAccountId(void)
#endif
}
std::string MultipleUserConnector::GetOhosAccountIdByUserId(int32_t userId)
{
#if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
(void)userId;
return "";
#elif OS_ACCOUNT_PART_EXISTS
OhosAccountInfo accountInfo;
ErrCode ret = OhosAccountKits::GetInstance().GetOhosAccountInfoByUserId(userId, accountInfo);
if (ret != 0 || accountInfo.uid_ == "") {
LOGE("error ret: %{public}d", ret);
return "";
}
return accountInfo.uid_;
#else
(void)userId;
return "";
#endif
}
std::string MultipleUserConnector::GetOhosAccountName(void)
{
#if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
@ -92,6 +112,34 @@ std::string MultipleUserConnector::GetOhosAccountName(void)
#endif
}
void MultipleUserConnector::GetTokenIdAndForegroundUserId(uint32_t &tokenId, int32_t &userId)
{
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
tokenId = OHOS::IPCSkeleton::GetCallingTokenID();
#else
(void)tokenId;
#endif
userId = GetFirstForegroundUserId();
}
void MultipleUserConnector::GetCallerUserId(int32_t &userId)
{
#if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
(void)userId;
return;
#elif OS_ACCOUNT_PART_EXISTS
int32_t uid = OHOS::IPCSkeleton::GetCallingUid();
ErrCode ret = OsAccountManager::GetOsAccountLocalIdFromUid(uid, userId);
if (ret != 0) {
LOGE("GetOsAccountLocalIdFromUid error ret: %{public}d", ret);
}
return;
#else // OS_ACCOUNT_PART_EXISTS
(void)userId;
return;
#endif
}
void MultipleUserConnector::SetSwitchOldUserId(int32_t userId)
{
std::lock_guard<std::mutex> lock(lock_);
@ -156,5 +204,101 @@ void MultipleUserConnector::DeleteAccountInfoByUserId(int32_t userId)
dmAccountInfoMap_.erase(userId);
}
}
int32_t MultipleUserConnector::GetForegroundUserIds(std::vector<int32_t> &userVec)
{
#if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
userVec.push_back(DEFAULT_OS_ACCOUNT_ID);
return DM_OK;
#elif OS_ACCOUNT_PART_EXISTS
userVec.clear();
std::vector<AccountSA::ForegroundOsAccount> accounts;
ErrCode ret = OsAccountManager::GetForegroundOsAccounts(accounts);
if (ret != 0 || accounts.empty()) {
LOGE("error ret: %{public}d", ret);
return ret;
}
for (auto &account : accounts) {
userVec.push_back(account.localId);
}
return DM_OK;
#else // OS_ACCOUNT_PART_EXISTS
userVec.push_back(DEFAULT_OS_ACCOUNT_ID);
return DM_OK;
#endif
}
int32_t MultipleUserConnector::GetFirstForegroundUserId(void)
{
std::vector<int32_t> userVec;
int32_t ret = GetForegroundUserIds(userVec);
if (ret != DM_OK || userVec.size() == 0) {
LOGE("get userid error ret: %{public}d.", ret);
return -1;
}
return userVec[0];
}
int32_t MultipleUserConnector::GetBackgroundUserIds(std::vector<int32_t> &userIdVec)
{
#if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
return DM_OK;
#elif OS_ACCOUNT_PART_EXISTS
userIdVec.clear();
std::vector<OsAccountInfo> allOsAccounts;
ErrCode ret = OsAccountManager::QueryAllCreatedOsAccounts(allOsAccounts);
if (ret != 0) {
LOGE("Get all created accounts error, ret: %{public}d", ret);
return ret;
}
std::vector<AccountSA::ForegroundOsAccount> foregroundAccounts;
ret = OsAccountManager::GetForegroundOsAccounts(foregroundAccounts);
if (ret != 0) {
LOGE("Get foreground accounts error ret: %{public}d", ret);
return ret;
}
std::vector<int32_t> allUserIds;
std::vector<int32_t> foregroundUserIds;
for (const auto &u : allOsAccounts) {
allUserIds.push_back(u.GetLocalId());
}
for (const auto &u : foregroundAccounts) {
foregroundUserIds.push_back(u.localId);
}
for (const auto &userId : allUserIds) {
if (std::find(foregroundUserIds.begin(), foregroundUserIds.end(), userId) == foregroundUserIds.end()) {
userIdVec.push_back(userId);
}
}
return DM_OK;
#else
return DM_OK;
#endif
}
int32_t MultipleUserConnector::GetAllUserIds(std::vector<int32_t> &userIdVec)
{
#if (defined(__LITEOS_M__) || defined(LITE_DEVICE))
return DM_OK;
#elif OS_ACCOUNT_PART_EXISTS
userIdVec.clear();
std::vector<OsAccountInfo> allOsAccounts;
ErrCode ret = OsAccountManager::QueryAllCreatedOsAccounts(allOsAccounts);
if (ret != 0) {
LOGE("Get all created accounts error, ret: %{public}d", ret);
return ret;
}
for (const auto &u : allOsAccounts) {
userIdVec.push_back(u.GetLocalId());
}
return DM_OK;
#else
return DM_OK;
#endif
}
} // namespace DistributedHardware
} // namespace OHOS

7
interfaces/inner_kits/native_cpp/include/device_manager_impl.h
View File

@ -412,21 +412,20 @@ private:
DeviceManagerImpl(DeviceManagerImpl &&) = delete;
DeviceManagerImpl &operator=(DeviceManagerImpl &&) = delete;
uint16_t AddDiscoveryCallback(const std::string &pkgName, std::shared_ptr<DiscoveryCallback> callback);
uint16_t AddDiscoveryCallback(const std::string &pkgName, std::map<std::string, std::string> &discoverParam,
std::shared_ptr<DiscoveryCallback> callback);
uint16_t RemoveDiscoveryCallback(const std::string &pkgName);
int32_t AddPublishCallback(const std::string &pkgName);
int32_t RemovePublishCallback(const std::string &pkgName);
int32_t CheckApiPermission(int32_t permissionLevel);
void ConvertDeviceInfoToDeviceBasicInfo(const DmDeviceInfo &info, DmDeviceBasicInfo &deviceBasicInfo);
uint16_t GetSubscribeIdFromMap(const std::string &pkgName);
private:
#if !defined(__LITEOS_M__)
std::shared_ptr<IpcClientProxy> ipcClientProxy_ =
std::make_shared<IpcClientProxy>(std::make_shared<IpcClientManager>());
#endif
std::mutex subscribIdLock;
std::map<uint64_t, uint16_t> subscribIdMap_;
std::mutex subMapLock;
std::map<std::string, uint16_t> pkgName2SubIdMap_;

39
interfaces/inner_kits/native_cpp/include/dm_device_info.h
View File

@ -361,6 +361,45 @@ typedef struct DmAccessCallee {
int32_t userId;
std::string extra;
} DmAccessCallee;
typedef struct ProcessInfo {
int32_t userId;
std::string pkgName;
bool operator==(const ProcessInfo &other) const
{
return (userId == other.userId) && (pkgName == other.pkgName);
}
bool operator<(const ProcessInfo &other) const
{
return (userId < other.userId) ||
(userId == other.userId && pkgName < other.pkgName);
}
} ProcessInfo;
typedef struct DmNotifyKey {
int32_t processUserId;
std::string processPkgName;
int32_t notifyUserId;
std::string udid;
bool operator==(const DmNotifyKey &other) const
{
return (processUserId == other.processUserId) && (processPkgName == other.processPkgName) &&
(notifyUserId == other.notifyUserId) && (udid == other.udid);
}
bool operator<(const DmNotifyKey &other) const
{
return (processUserId < other.processUserId) ||
(processUserId == other.processUserId && processPkgName < other.processPkgName) ||
(processUserId == other.processUserId && processPkgName == other.processPkgName &&
notifyUserId < other.notifyUserId) ||
(processUserId == other.processUserId && processPkgName == other.processPkgName &&
notifyUserId == other.notifyUserId && udid < other.udid);
}
} DmNotifyKey;
} // namespace DistributedHardware
} // namespace OHOS
#endif // OHOS_DM_DEVICE_INFO_H

1
interfaces/inner_kits/native_cpp/include/notify/device_manager_notify.h
View File

@ -125,6 +125,7 @@ public:
uint16_t deviceTypeId, int32_t errcode);
void OnSinkBindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result, int32_t status,
std::string content);
std::shared_ptr<DiscoveryCallback> GetDiscoveryCallback(const std::string &pkgName, uint16_t subscribeId);
private:
#if !defined(__LITEOS_M__)

310
interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
View File

@ -55,9 +55,6 @@
#include "ipc_set_credential_rsp.h"
#include "ipc_set_useroperation_req.h"
#include "ipc_skeleton.h"
#include "ipc_start_discovery_req.h"
#include "ipc_start_discover_req.h"
#include "ipc_stop_discovery_req.h"
#include "ipc_unauthenticate_device_req.h"
#include "ipc_unbind_device_req.h"
#include "ipc_unpublish_req.h"
@ -455,35 +452,14 @@ int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, cons
LOGE("DeviceManagerImpl::StartDeviceDiscovery error: Invalid para, pkgName: %{public}s", pkgName.c_str());
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
DmTraceStart(std::string(DM_HITRACE_START_DEVICE));
DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeInfo.subscribeId, callback);
std::shared_ptr<IpcStartDiscoveryReq> req = std::make_shared<IpcStartDiscoveryReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetExtra(extra);
req->SetSubscribeInfo(subscribeInfo);
int32_t ret = ipcClientProxy_->SendRequest(START_DEVICE_DISCOVER, req, rsp);
if (ret != DM_OK) {
LOGE("StartDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
return ERR_DM_IPC_SEND_REQUEST_FAILED;
}
ret = rsp->GetErrCode();
if (ret != DM_OK) {
LOGE("StartDeviceDiscovery error: Failed with ret %{public}d", ret);
SysEventWrite(std::string(START_DEVICE_DISCOVERY_FAILED), DM_HISYEVENT_BEHAVIOR,
std::string(START_DEVICE_DISCOVERY_FAILED_MSG));
return ret;
}
DmTraceEnd();
LOGI("Completed");
SysEventWrite(std::string(START_DEVICE_DISCOVERY_SUCCESS), DM_HISYEVENT_BEHAVIOR,
std::string(START_DEVICE_DISCOVERY_SUCCESS_MSG));
return DM_OK;
std::map<std::string, std::string> discParam;
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_SUBSCRIBE_ID,
std::to_string(subscribeInfo.subscribeId)));
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_DISC_MEDIUM, std::to_string(subscribeInfo.medium)));
std::map<std::string, std::string> filterOps;
filterOps.insert(std::pair<std::string, std::string>(PARAM_KEY_FILTER_OPTIONS, extra));
return StartDiscovering(pkgName, discParam, filterOps, callback);
}
int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, uint64_t tokenId,
@ -493,35 +469,64 @@ int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, uint
LOGE("DeviceManagerImpl::StartDeviceDiscovery error: Invalid para, pkgName: %{public}s", pkgName.c_str());
return ERR_DM_INPUT_PARA_INVALID;
}
std::map<std::string, std::string> discParam;
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_SUBSCRIBE_ID, std::to_string(tokenId)));
std::map<std::string, std::string> filterOps;
filterOps.insert(std::pair<std::string, std::string>(PARAM_KEY_FILTER_OPTIONS, filterOptions));
return StartDiscovering(pkgName, discParam, filterOps, callback);
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
uint16_t subscribeId = 0;
{
std::lock_guard<std::mutex> autoLock(subscribIdLock);
if (subscribIdMap_.find(tokenId) != subscribIdMap_.end()) {
return ERR_DM_DISCOVERY_REPEATED;
}
subscribeId = GenRandUint(0, DM_MAX_RANDOM);
subscribIdMap_[tokenId] = subscribeId;
int32_t DeviceManagerImpl::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId)
{
if (pkgName.empty()) {
LOGE("DeviceManagerImpl::StopDeviceDiscovery Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
std::map<std::string, std::string> discParam;
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId)));
return StopDiscovering(pkgName, discParam);
}
int32_t DeviceManagerImpl::StopDeviceDiscovery(uint64_t tokenId, const std::string &pkgName)
{
if (pkgName.empty()) {
LOGE("DeviceManagerImpl::StopDeviceDiscovery Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
std::map<std::string, std::string> discParam;
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_SUBSCRIBE_ID, std::to_string(tokenId)));
return StopDiscovering(pkgName, discParam);
}
int32_t DeviceManagerImpl::StartDiscovering(const std::string &pkgName,
std::map<std::string, std::string> &discoverParam, const std::map<std::string, std::string> &filterOptions,
std::shared_ptr<DiscoveryCallback> callback)
{
if (pkgName.empty() || callback == nullptr) {
LOGE("DeviceManagerImpl::StartDiscovering failed: input callback is null or pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
DmTraceStart(std::string(DM_HITRACE_START_DEVICE));
DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
std::shared_ptr<IpcStartDevDiscoveryByIdReq> req = std::make_shared<IpcStartDevDiscoveryByIdReq>();
uint16_t subscribeId = AddDiscoveryCallback(pkgName, discoverParam, callback);
discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
std::string discParaStr = ConvertMapToJsonString(discoverParam);
std::string filterOpStr = ConvertMapToJsonString(filterOptions);
std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetFilterOption(filterOptions);
req->SetSubscribeId(subscribeId);
int32_t ret = ipcClientProxy_->SendRequest(START_DEVICE_DISCOVERY, req, rsp);
req->SetPkgName(ComposeStr(pkgName, subscribeId));
req->SetFirstParam(discParaStr);
req->SetSecondParam(filterOpStr);
int32_t ret = ipcClientProxy_->SendRequest(START_DISCOVERING, req, rsp);
if (ret != DM_OK) {
LOGE("StartDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
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("StartDeviceDiscovery error: Failed with ret %{public}d", ret);
SysEventWrite(std::string(START_DEVICE_DISCOVERY_FAILED), DM_HISYEVENT_BEHAVIOR,
std::string(START_DEVICE_DISCOVERY_FAILED_MSG));
LOGE("StartDiscovering error: Failed with ret %{public}d", ret);
return ret;
}
@ -532,67 +537,44 @@ int32_t DeviceManagerImpl::StartDeviceDiscovery(const std::string &pkgName, uint
return DM_OK;
}
int32_t DeviceManagerImpl::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId)
int32_t DeviceManagerImpl::StopDiscovering(const std::string &pkgName,
std::map<std::string, std::string> &discoverParam)
{
if (pkgName.empty()) {
LOGE("DeviceManagerImpl::StopDeviceDiscovery Invalid parameter, pkgName is empty.");
LOGE("DeviceManagerImpl::StopDiscovering failed: input pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
std::shared_ptr<IpcStopDiscoveryReq> req = std::make_shared<IpcStopDiscoveryReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetSubscribeId(subscribeId);
int32_t ret = ipcClientProxy_->SendRequest(STOP_DEVICE_DISCOVER, req, rsp);
if (ret != DM_OK) {
LOGE("StopDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
return ERR_DM_IPC_SEND_REQUEST_FAILED;
uint16_t subscribeId = DM_INVALID_FLAG_ID;
if (discoverParam.find(PARAM_KEY_SUBSCRIBE_ID) != discoverParam.end()) {
subscribeId = std::atoi((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
}
ret = rsp->GetErrCode();
if (ret != DM_OK) {
LOGE("StopDeviceDiscovery error: Failed with ret %{public}d", ret);
return ret;
if (subscribeId == DM_INVALID_FLAG_ID) {
subscribeId = GetSubscribeIdFromMap(pkgName);
}
DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
LOGI("Completed");
return DM_OK;
}
int32_t DeviceManagerImpl::StopDeviceDiscovery(uint64_t tokenId, const std::string &pkgName)
{
if (pkgName.empty()) {
LOGE("DeviceManagerImpl::StopDeviceDiscovery Invalid parameter, pkgName is empty.");
if (subscribeId == DM_INVALID_FLAG_ID) {
LOGE("DeviceManagerImpl::StopDiscovering failed: cannot find pkgName in cache map.");
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
uint16_t subscribeId = 0;
{
std::lock_guard<std::mutex> autoLock(subscribIdLock);
if (subscribIdMap_.find(tokenId) == subscribIdMap_.end()) {
return ERR_DM_STOP_DISCOVERY;
}
subscribeId = subscribIdMap_[tokenId];
subscribIdMap_.erase(tokenId);
}
std::shared_ptr<IpcStopDiscoveryReq> req = std::make_shared<IpcStopDiscoveryReq>();
std::string discoveryFlag = ComposeStr(pkgName, subscribeId);
discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
std::string discParaStr = ConvertMapToJsonString(discoverParam);
std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetSubscribeId(subscribeId);
int32_t ret = ipcClientProxy_->SendRequest(STOP_DEVICE_DISCOVER, req, rsp);
req->SetPkgName(discoveryFlag);
req->SetFirstParam(discParaStr);
int32_t ret = ipcClientProxy_->SendRequest(STOP_DISCOVERING, req, rsp);
if (ret != DM_OK) {
LOGE("StopDeviceDiscovery error: Send Request failed ret: %{public}d", ret);
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("StopDeviceDiscovery error: Failed with ret %{public}d", ret);
LOGE("StopDiscovering error: Failed with ret %{public}d", ret);
return ret;
}
DeviceManagerNotify::GetInstance().UnRegisterDiscoveryCallback(pkgName, subscribeId);
RemoveDiscoveryCallback(discoveryFlag);
LOGI("Completed");
return DM_OK;
}
@ -1648,86 +1630,6 @@ int32_t DeviceManagerImpl::ExportAuthCode(std::string &authCode)
return DM_OK;
}
int32_t DeviceManagerImpl::StartDiscovering(const std::string &pkgName,
std::map<std::string, std::string> &discoverParam, const std::map<std::string, std::string> &filterOptions,
std::shared_ptr<DiscoveryCallback> callback)
{
if (pkgName.empty() || callback == nullptr) {
LOGE("DeviceManagerImpl::StartDiscovering failed: input callback is null or pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
DmTraceStart(std::string(DM_HITRACE_START_DEVICE));
uint16_t subscribeId = AddDiscoveryCallback(pkgName, callback);
discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
std::string discParaStr = ConvertMapToJsonString(discoverParam);
std::string filterOpStr = ConvertMapToJsonString(filterOptions);
std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetFirstParam(discParaStr);
req->SetSecondParam(filterOpStr);
int32_t ret = ipcClientProxy_->SendRequest(START_DISCOVERING, req, rsp);
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;
}
DmTraceEnd();
LOGI("Completed");
SysEventWrite(std::string(START_DEVICE_DISCOVERY_SUCCESS), DM_HISYEVENT_BEHAVIOR,
std::string(START_DEVICE_DISCOVERY_SUCCESS_MSG));
return DM_OK;
}
int32_t DeviceManagerImpl::StopDiscovering(const std::string &pkgName,
std::map<std::string, std::string> &discoverParam)
{
if (pkgName.empty()) {
LOGE("DeviceManagerImpl::StopDiscovering failed: input pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
uint16_t subscribeId = DM_INVALID_FLAG_ID;
{
std::lock_guard<std::mutex> autoLock(subMapLock);
if (pkgName2SubIdMap_.find(pkgName) != pkgName2SubIdMap_.end()) {
subscribeId = pkgName2SubIdMap_[pkgName];
}
}
if (subscribeId == DM_INVALID_FLAG_ID) {
LOGE("DeviceManagerImpl::StopDiscovering failed: cannot find pkgName in cache map.");
return ERR_DM_INPUT_PARA_INVALID;
}
discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
std::string discParaStr = ConvertMapToJsonString(discoverParam);
std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetFirstParam(discParaStr);
int32_t ret = ipcClientProxy_->SendRequest(STOP_DISCOVERING, req, rsp);
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;
}
RemoveDiscoveryCallback(pkgName);
LOGI("Completed");
return DM_OK;
}
int32_t DeviceManagerImpl::RegisterDiscoveryCallback(const std::string &pkgName,
std::map<std::string, std::string> &discoverParam, const std::map<std::string, std::string> &filterOptions,
std::shared_ptr<DiscoveryCallback> callback)
@ -1737,15 +1639,14 @@ int32_t DeviceManagerImpl::RegisterDiscoveryCallback(const std::string &pkgName,
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
uint16_t subscribeId = AddDiscoveryCallback(pkgName, callback);
uint16_t subscribeId = AddDiscoveryCallback(pkgName, discoverParam, callback);
discoverParam.emplace(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId));
std::string discParaStr = ConvertMapToJsonString(discoverParam);
std::string filterOpStr = ConvertMapToJsonString(filterOptions);
std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetPkgName(ComposeStr(pkgName, subscribeId));
req->SetFirstParam(discParaStr);
req->SetSecondParam(filterOpStr);
int32_t ret = ipcClientProxy_->SendRequest(REGISTER_DISCOVERY_CALLBACK, req, rsp);
@ -1771,8 +1672,8 @@ int32_t DeviceManagerImpl::UnRegisterDiscoveryCallback(const std::string &pkgNam
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("Start, pkgName: %{public}s", pkgName.c_str());
uint16_t subscribeId = RemoveDiscoveryCallback(pkgName);
std::string discoveryFlag = ComposeStr(pkgName, DM_INVALID_FLAG_ID);
uint16_t subscribeId = RemoveDiscoveryCallback(discoveryFlag);
if (subscribeId == DM_INVALID_FLAG_ID) {
DmRadarHelper::GetInstance().ReportDmBehavior(
pkgName, "UnRegisterDiscoveryCallback", ERR_DM_INPUT_PARA_INVALID);
@ -1785,21 +1686,21 @@ int32_t DeviceManagerImpl::UnRegisterDiscoveryCallback(const std::string &pkgNam
std::shared_ptr<IpcCommonParamReq> req = std::make_shared<IpcCommonParamReq>();
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
req->SetPkgName(pkgName);
req->SetPkgName(discoveryFlag);
req->SetFirstParam(extraParaStr);
int32_t ret = ipcClientProxy_->SendRequest(UNREGISTER_DISCOVERY_CALLBACK, req, rsp);
if (ret != DM_OK) {
DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnRegisterDiscoveryCallback", ret);
DmRadarHelper::GetInstance().ReportDmBehavior(discoveryFlag, "UnRegisterDiscoveryCallback", ret);
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(pkgName, "UnRegisterDiscoveryCallback", ret);
DmRadarHelper::GetInstance().ReportDmBehavior(discoveryFlag, "UnRegisterDiscoveryCallback", ret);
LOGE("UnRegisterDiscoveryCallback error: Failed with ret %{public}d", ret);
return ret;
}
DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "UnRegisterDiscoveryCallback", DM_OK);
DmRadarHelper::GetInstance().ReportDmBehavior(discoveryFlag, "UnRegisterDiscoveryCallback", DM_OK);
LOGI("Completed");
return DM_OK;
}
@ -1982,20 +1883,32 @@ int32_t DeviceManagerImpl::CheckAccessToTarget(uint64_t tokenId, const std::stri
}
uint16_t DeviceManagerImpl::AddDiscoveryCallback(const std::string &pkgName,
std::shared_ptr<DiscoveryCallback> callback)
std::map<std::string, std::string> &discoverParam, std::shared_ptr<DiscoveryCallback> callback)
{
if (discoverParam.empty() || callback == nullptr) {
LOGE("input param invalid.");
return DM_INVALID_FLAG_ID;
}
uint16_t subscribeId = DM_INVALID_FLAG_ID;
if (discoverParam.find(PARAM_KEY_SUBSCRIBE_ID) != discoverParam.end()) {
subscribeId = std::atoi((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
}
if (subscribeId == DM_INVALID_FLAG_ID) {
subscribeId = GetSubscribeIdFromMap(pkgName);
}
if (subscribeId == DM_INVALID_FLAG_ID) {
subscribeId = GenRandUint(DM_MIN_RANDOM, DM_MAX_RANDOM);
}
std::string discoveryFlag = ComposeStr(pkgName, subscribeId);
{
std::lock_guard<std::mutex> autoLock(subMapLock);
if (pkgName2SubIdMap_.find(pkgName) != pkgName2SubIdMap_.end()) {
subscribeId = pkgName2SubIdMap_[pkgName];
} else {
subscribeId = GenRandUint(DM_MIN_RANDOM, DM_MAX_RANDOM);
pkgName2SubIdMap_[pkgName] = subscribeId;
auto iter = pkgName2SubIdMap_.find(discoveryFlag);
if (iter == pkgName2SubIdMap_.end()) {
pkgName2SubIdMap_[discoveryFlag] = subscribeId;
}
}
DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(pkgName, subscribeId, callback);
DmRadarHelper::GetInstance().ReportDmBehavior(pkgName, "AddDiscoveryCallback", DM_OK);
DeviceManagerNotify::GetInstance().RegisterDiscoveryCallback(discoveryFlag, subscribeId, callback);
DmRadarHelper::GetInstance().ReportDmBehavior(discoveryFlag, "AddDiscoveryCallback", DM_OK);
return subscribeId;
}
@ -2488,5 +2401,18 @@ int32_t DeviceManagerImpl::UnRegisterSinkBindCallback(const std::string &pkgName
LOGI("Completed, pkgName: %{public}s", pkgName.c_str());
return DM_OK;
}
uint16_t DeviceManagerImpl::GetSubscribeIdFromMap(const std::string &pkgName)
{
{
std::lock_guard<std::mutex> autoLock(subMapLock);
for (auto &item : pkgName2SubIdMap_) {
if (item.first.find(pkgName) == 0) {
return GetSubscribeId(item.first);
}
}
}
return DM_INVALID_FLAG_ID;
}
} // namespace DistributedHardware
} // namespace OHOS

40
interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_cmd_parser.cpp
View File

@ -30,8 +30,6 @@
#include "ipc_register_listener_req.h"
#include "ipc_set_credential_req.h"
#include "ipc_set_credential_rsp.h"
#include "ipc_start_discover_req.h"
#include "ipc_stop_discovery_req.h"
#include "securec.h"
namespace OHOS {
@ -163,44 +161,6 @@ ON_IPC_READ_RESPONSE(GET_TRUST_DEVICE_LIST, IpcIo &reply, std::shared_ptr<IpcRsp
return DM_OK;
}
ON_IPC_SET_REQUEST(START_DEVICE_DISCOVERY, std::shared_ptr<IpcReq> pBaseReq, IpcIo &request, uint8_t *buffer,
size_t buffLen)
{
std::shared_ptr<IpcStartDevDiscoveryByIdReq> pReq = std::static_pointer_cast<IpcStartDevDiscoveryByIdReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string extra = pReq->GetFilterOption();
uint16_t subscribeId = pReq->GetSubscribeId();
IpcIoInit(&request, buffer, buffLen, 0);
WriteString(&request, pkgName.c_str());
WriteString(&request, extra.c_str());
WriteUint16(&request, subscribeId);
return DM_OK;
}
ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVERY, IpcIo &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
return SetRspErrCode(reply, pBaseRsp);
}
ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr<IpcReq> pBaseReq, IpcIo &request, uint8_t *buffer,
size_t buffLen)
{
std::shared_ptr<IpcStopDiscoveryReq> pReq = std::static_pointer_cast<IpcStopDiscoveryReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
uint16_t subscribeId = pReq->GetSubscribeId();
IpcIoInit(&request, buffer, buffLen, 0);
WriteString(&request, pkgName.c_str());
WriteUint16(&request, subscribeId);
return DM_OK;
}
ON_IPC_READ_RESPONSE(STOP_DEVICE_DISCOVER, IpcIo &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
return SetRspErrCode(reply, pBaseRsp);
}
ON_IPC_SET_REQUEST(REQUEST_CREDENTIAL, std::shared_ptr<IpcReq> pBaseReq, IpcIo &request, uint8_t *buffer,
size_t buffLen)
{

83
interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_cmd_parser.cpp
View File

@ -48,9 +48,6 @@
#include "ipc_set_credential_req.h"
#include "ipc_set_credential_rsp.h"
#include "ipc_set_useroperation_req.h"
#include "ipc_start_discovery_req.h"
#include "ipc_start_discover_req.h"
#include "ipc_stop_discovery_req.h"
#include "ipc_permission_req.h"
#include "ipc_publish_req.h"
#include "ipc_unbind_device_req.h"
@ -314,86 +311,6 @@ ON_IPC_READ_RESPONSE(GET_UUID_BY_NETWORK, MessageParcel &reply, std::shared_ptr<
return DM_OK;
}
ON_IPC_SET_REQUEST(START_DEVICE_DISCOVER, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
std::shared_ptr<IpcStartDiscoveryReq> pReq = std::static_pointer_cast<IpcStartDiscoveryReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string extra = pReq->GetExtra();
const DmSubscribeInfo dmSubscribeInfo = pReq->GetSubscribeInfo();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(extra)) {
LOGE("write extra failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteRawData(&dmSubscribeInfo, sizeof(DmSubscribeInfo))) {
LOGE("write subscribe info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVER, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(START_DEVICE_DISCOVERY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
std::shared_ptr<IpcStartDevDiscoveryByIdReq> pReq = std::static_pointer_cast<IpcStartDevDiscoveryByIdReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string filterOption = pReq->GetFilterOption();
const uint16_t subscribeId = pReq->GetSubscribeId();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(filterOption)) {
LOGE("write filterOption failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteUint16(subscribeId)) {
LOGE("write subscribe id failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(START_DEVICE_DISCOVERY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(STOP_DEVICE_DISCOVER, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
std::shared_ptr<IpcStopDiscoveryReq> pReq = std::static_pointer_cast<IpcStopDiscoveryReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
uint16_t subscribeId = pReq->GetSubscribeId();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt16((int16_t)subscribeId)) {
LOGE("write subscribeId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(STOP_DEVICE_DISCOVER, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
if (pBaseRsp == nullptr) {
LOGE("pBaseRsp is null");
return ERR_DM_FAILED;
}
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(PUBLISH_DEVICE_DISCOVER, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
std::shared_ptr<IpcPublishReq> pReq = std::static_pointer_cast<IpcPublishReq>(pBaseReq);

108
interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp
View File

@ -31,7 +31,7 @@ constexpr const char* DEVICEINFO_CHANGE = "deviceInfoChange";
constexpr const char* DEVICE_READY = "deviceReady";
constexpr const char* DEVICE_TRUST_CHANGE = "deviceTrustChange";
#endif
const uint16_t DM_INVALID_FLAG_ID = 0;
void DeviceManagerNotify::RegisterDeathRecipientCallback(const std::string &pkgName,
std::shared_ptr<DmInitCallback> dmInitCallback)
{
@ -521,68 +521,34 @@ void DeviceManagerNotify::OnDeviceReady(const std::string &pkgName, const DmDevi
void DeviceManagerNotify::OnDeviceFound(const std::string &pkgName, uint16_t subscribeId,
const DmDeviceInfo &deviceInfo)
{
LOGD("pkgName:%{public}s, subscribeId:%{public}d.",
GetAnonyString(pkgName).c_str(), (int32_t)subscribeId);
if (pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return;
}
std::shared_ptr<DiscoveryCallback> tempCbk;
{
std::lock_guard<std::mutex> autoLock(lock_);
if (deviceDiscoveryCallbacks_.count(pkgName) == 0) {
LOGE("DeviceManagerNotify::OnDeviceFound error, device discovery callback not register for"
"pkgName %{public}s.", pkgName.c_str());
return;
}
std::map<uint16_t, std::shared_ptr<DiscoveryCallback>> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName];
auto iter = discoverCallMap.find(subscribeId);
if (iter == discoverCallMap.end()) {
LOGE("OnDeviceFound error, no register deviceDiscoveryCallback for subscribeId %{public}d.",
(int32_t)subscribeId);
return;
}
tempCbk = iter->second;
}
std::shared_ptr<DiscoveryCallback> tempCbk = GetDiscoveryCallback(pkgName, subscribeId);
if (tempCbk == nullptr) {
LOGE("OnDeviceFound error, registered device discovery callback is nullptr.");
return;
}
LOGD("Complete with devInfo, pkgName:%{public}s, subscribeId:%{public}d.",
GetAnonyString(pkgName).c_str(), (int32_t)subscribeId);
tempCbk->OnDeviceFound(subscribeId, deviceInfo);
}
void DeviceManagerNotify::OnDeviceFound(const std::string &pkgName, uint16_t subscribeId,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGD("pkgName:%{public}s, subscribeId:%{public}d.",
GetAnonyString(pkgName).c_str(), (int32_t)subscribeId);
if (pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return;
}
std::shared_ptr<DiscoveryCallback> tempCbk;
{
std::lock_guard<std::mutex> autoLock(lock_);
if (deviceDiscoveryCallbacks_.count(pkgName) == 0) {
LOGE("DeviceManagerNotify::OnDeviceFound error, device discovery callback not register for"
"pkgName %{public}s.", pkgName.c_str());
return;
}
std::map<uint16_t, std::shared_ptr<DiscoveryCallback>> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName];
auto iter = discoverCallMap.find(subscribeId);
if (iter == discoverCallMap.end()) {
LOGE("OnDeviceFound error, no register deviceDiscoveryCallback for subscribeId %{public}d.",
(int32_t)subscribeId);
return;
}
tempCbk = iter->second;
}
std::shared_ptr<DiscoveryCallback> tempCbk = GetDiscoveryCallback(pkgName, subscribeId);
if (tempCbk == nullptr) {
LOGE("OnDeviceFound error, registered device discovery callback is nullptr.");
return;
}
LOGD("Complete with DmDeviceBasicInfo, pkgName:%{public}s, subscribeId:%{public}d.",
GetAnonyString(pkgName).c_str(), (int32_t)subscribeId);
tempCbk->OnDeviceFound(subscribeId, deviceBasicInfo);
}
@ -594,23 +560,7 @@ void DeviceManagerNotify::OnDiscoveryFailed(const std::string &pkgName, uint16_t
}
LOGI("DeviceManagerNotify::OnDiscoveryFailed in, pkgName:%{public}s, subscribeId %{public}d, failed"
"reason %{public}d", pkgName.c_str(), (int32_t)subscribeId, failedReason);
std::shared_ptr<DiscoveryCallback> tempCbk;
{
std::lock_guard<std::mutex> autoLock(lock_);
if (deviceDiscoveryCallbacks_.count(pkgName) == 0) {
LOGE("DeviceManagerNotify::OnDiscoveryFailed error, device discovery callback not register for"
"pkgName %{public}s.", pkgName.c_str());
return;
}
std::map<uint16_t, std::shared_ptr<DiscoveryCallback>> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName];
auto iter = discoverCallMap.find(subscribeId);
if (iter == discoverCallMap.end()) {
LOGE("OnDiscoveryFailed error, device discovery callback not register for subscribeId %{public}d.",
subscribeId);
return;
}
tempCbk = iter->second;
}
std::shared_ptr<DiscoveryCallback> tempCbk = GetDiscoveryCallback(pkgName, subscribeId);
if (tempCbk == nullptr) {
LOGE("OnDiscoveryFailed error, registered device discovery callback is nullptr.");
return;
@ -625,23 +575,7 @@ void DeviceManagerNotify::OnDiscoverySuccess(const std::string &pkgName, uint16_
return;
}
LOGI("PkgName:%{public}s, subscribeId:%{public}d.", GetAnonyString(pkgName).c_str(), subscribeId);
std::shared_ptr<DiscoveryCallback> tempCbk;
{
std::lock_guard<std::mutex> autoLock(lock_);
if (deviceDiscoveryCallbacks_.count(pkgName) == 0) {
LOGE("OnDiscoverySuccess error, device discovery callback not register for pkgName %{public}s.",
pkgName.c_str());
return;
}
std::map<uint16_t, std::shared_ptr<DiscoveryCallback>> &discoverCallMap = deviceDiscoveryCallbacks_[pkgName];
auto iter = discoverCallMap.find(subscribeId);
if (iter == discoverCallMap.end()) {
LOGE("OnDiscoverySuccess error, device discovery callback not register for subscribeId %{public}d.",
(int32_t)subscribeId);
return;
}
tempCbk = iter->second;
}
std::shared_ptr<DiscoveryCallback> tempCbk = GetDiscoveryCallback(pkgName, subscribeId);
if (tempCbk == nullptr) {
LOGE("OnDiscoverySuccess error, registered device discovery callback is nullptr.");
return;
@ -1238,5 +1172,29 @@ void DeviceManagerNotify::OnSinkBindResult(const std::string &pkgName, const Pee
}
tempCbk->OnBindResult(targetId, result, status, content);
}
std::shared_ptr<DiscoveryCallback> DeviceManagerNotify::GetDiscoveryCallback(const std::string &pkgName,
uint16_t subscribeId)
{
std::string discWithSubscribeId = ComposeStr(pkgName, subscribeId);
std::lock_guard<std::mutex> autoLock(lock_);
auto iter = deviceDiscoveryCallbacks_.find(discWithSubscribeId);
if (iter != deviceDiscoveryCallbacks_.end()) {
auto subIter = iter->second.find(subscribeId);
if (subIter != iter->second.end()) {
return subIter->second;
}
return nullptr;
}
std::string discNoSubscribeId = ComposeStr(pkgName, DM_INVALID_FLAG_ID);
iter = deviceDiscoveryCallbacks_.find(discNoSubscribeId);
if (iter != deviceDiscoveryCallbacks_.end()) {
auto subIter = iter->second.find(DM_INVALID_FLAG_ID);
if (subIter != iter->second.end()) {
return subIter->second;
}
}
return nullptr;
}
} // namespace DistributedHardware
} // namespace OHOS

1
services/implementation/include/authentication/auth_message_processor.h
View File

@ -72,6 +72,7 @@ constexpr const char* TAG_DATA_LEN = "dataLen";
constexpr const char* TAG_IMPORT_AUTH_CODE = "IMPORT_AUTH_CODE";
constexpr const char* TAG_HOST_PKGLABEL = "hostPkgLabel";
constexpr const char* TAG_EDITION = "edition";
constexpr const char* TAG_BUNDLE_NAME = "bundleName";
class DmAuthManager;
struct DmAuthRequestContext;

2
services/implementation/include/authentication/auth_ui_state_manager.h
View File

@ -42,7 +42,7 @@ public:
void UnRegisterUiStateCallback(const std::string pkgName);
void UpdateUiState(const DmUiStateMsg msg);
private:
std::set<std::string> pkgSet_;
std::set<ProcessInfo> pkgSet_;
std::mutex pkgSetMutex_;
std::shared_ptr<IDeviceManagerServiceListener> listener_;
};

14
services/implementation/include/authentication/dm_auth_manager.h
View File

@ -103,6 +103,7 @@ typedef struct DmAuthRequestContext {
std::string cryptoVer;
std::string hostPkgName;
std::string targetPkgName;
std::string bundleName;
std::string appOperation;
std::string appDesc;
std::string appName;
@ -145,6 +146,7 @@ typedef struct DmAuthResponseContext {
std::string groupName;
std::string hostPkgName;
std::string targetPkgName;
std::string bundleName;
std::string appOperation;
std::string appDesc;
std::string customDesc;
@ -166,6 +168,7 @@ typedef struct DmAuthResponseContext {
std::string localAccountId;
int32_t localUserId;
int64_t tokenId;
int64_t remoteTokenId;
bool authed;
std::string dmVersion;
std::vector<int32_t> bindType;
@ -368,13 +371,6 @@ public:
*/
void HandleAuthenticateTimeout(std::string name);
/**
* @tc.name: DmAuthManager::CancelDisplay
* @tc.desc: Cancel Display of the DeviceManager Authenticate Manager
* @tc.type: FUNC
*/
void CancelDisplay();
/**
* @tc.name: DmAuthManager::GeneratePincode
* @tc.desc: Generate Pincode of the DeviceManager Authenticate Manager
@ -533,6 +529,9 @@ private:
void DeleteOffLineTimer(int32_t sessionId);
bool IsAllowDeviceBind();
int32_t GetBindLevel(int32_t bindLevel);
std::string GetBundleName(nlohmann::json &jsonObject);
int32_t GetBinderInfo();
void SetProcessInfo();
private:
std::shared_ptr<SoftbusConnector> softbusConnector_;
@ -568,6 +567,7 @@ private:
std::string remoteVersion_ = "";
std::atomic<int32_t> authType_ = AUTH_TYPE_UNKNOW;
std::string remoteUdidHash_ = "";
ProcessInfo processInfo_;
};
} // namespace DistributedHardware
} // namespace OHOS

5
services/implementation/include/credential/dm_credential_manager.h
View File

@ -95,7 +95,7 @@ public:
int32_t DeleteCredential(const std::string &pkgName, const std::string &deleteInfo);
/**
* @tc.name: HiChainConnector::OnCredentialResult
* @tc.name: HiChainConnector::OnGroupResult
* @tc.desc: Credential Result of the DmCredential Manager
* @tc.type: FUNC
*/
@ -103,6 +103,7 @@ public:
int32_t ImportRemoteCredentialExt(const std::string &credentialInfo);
void OnGroupResultExt(int32_t action, const std::string &resultInfo);
void HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode);
private:
std::shared_ptr<HiChainConnector> hiChainConnector_;
@ -110,7 +111,7 @@ private:
std::vector<std::string> credentialVec_;
int64_t requestId_ = 0;
std::mutex locks_;
std::string pkgName_;
ProcessInfo processInfo_;
private:
int32_t GetCredentialData(const std::string &credentialInfo, const CredentialData &inputCreData,
nlohmann::json &jsonOutObj);

14
services/implementation/include/dependency/softbus/softbus_connector.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* 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
@ -143,11 +143,11 @@ public:
std::string GetNetworkIdByDeviceId(const std::string &deviceId);
void HandleDeviceOnline(std::string deviceId, int32_t authForm);
void HandleDeviceOffline(std::string deviceId);
void SetPkgName(std::string pkgName);
void SetProcessInfo(ProcessInfo processInfo);
bool CheckIsOnline(const std::string &targetDeviceId);
void SetPkgNameVec(std::vector<std::string> pkgNameVec);
std::vector<std::string> GetPkgName();
void ClearPkgName();
void SetProcessInfoVec(std::vector<ProcessInfo> processInfoVec);
std::vector<ProcessInfo> GetProcessInfo();
void ClearProcessInfo();
DmDeviceInfo GetDeviceInfoByDeviceId(const std::string &deviceId);
void DeleteOffLineTimer(std::string &udidHash);
@ -177,11 +177,11 @@ private:
std::shared_ptr<ISoftbusStateCallback> deviceStateManagerCallback_;
static std::queue<std::string> discoveryDeviceIdQueue_;
static std::unordered_map<std::string, std::string> deviceUdidMap_;
static std::vector<std::string> pkgNameVec_;
static std::vector<ProcessInfo> processInfoVec_;
static std::mutex discoveryCallbackMutex_;
static std::mutex discoveryDeviceInfoMutex_;
static std::mutex deviceUdidLocks_;
static std::mutex pkgNameVecMutex_;
static std::mutex processInfoVecMutex_;
};
} // namespace DistributedHardware
} // namespace OHOS

15
services/implementation/include/device_manager_service_impl.h
View File

@ -128,26 +128,33 @@ public:
void HandleDeviceNotTrust(const std::string &udid);
int32_t GetBindLevel(const std::string &pkgName, const std::string &localUdid,
const std::string &udid, uint64_t &tokenId);
void HandleIdentAccountLogout(const std::string &udid, int32_t userId, const std::string &accountId);
void HandleIdentAccountLogout(const std::string &localUdid, int32_t localUserId, const std::string &peerUdid,
int32_t peerUserId);
void HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo);
int32_t StopAuthenticateDevice(const std::string &pkgName);
void HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode);
int32_t ProcessAppUnintall(const std::string &appId, int32_t accessTokenId);
void HandleSyncUserIdEvent(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backroundUserIds, const std::string &remoteUdid);
void HandleUserSwitched(const std::map<std::string, int32_t> &deviceMap, int32_t currentUserId,
int32_t beforeUserId);
std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t localUserId);
private:
int32_t PraseNotifyEventJson(const std::string &event, nlohmann::json &jsonObject);
std::string GetUdidHashByNetworkId(const std::string &networkId);
void HandleOffline(DmDeviceState devState, DmDeviceInfo &devInfo);
void HandleOnline(DmDeviceState devState, DmDeviceInfo &devInfo);
void PutIdenticalAccountToAcl(std::string requestDeviceId, std::string trustDeviceId);
std::map<std::string, int32_t> GetDeviceIdAndBindType(int32_t userId, const std::string &accountId);
std::map<std::string, int32_t> GetDeviceIdAndBindLevel(int32_t userId);
std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t userId, const std::string &accountId);
void HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
const std::string &remoteUdid);
void HandleDevUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid);
void HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId);
void HandleUserRemoved(int32_t preUserId);
void HandleRemoteUserRemoved(int32_t preUserId, const std::string &remoteUdid);
DmAuthForm ConvertBindTypeToAuthForm(int32_t bindType);
private:
std::shared_ptr<DmAuthManager> authMgr_;
std::shared_ptr<DmDeviceStateManager> deviceStateMgr_;

13
services/implementation/include/device_manager_service_impl_lite.h
View File

@ -127,18 +127,25 @@ public:
void HandleDeviceNotTrust(const std::string &udid);
int32_t GetBindLevel(const std::string &pkgName, const std::string &localUdid,
const std::string &udid, uint64_t &tokenId);
std::map<std::string, int32_t> GetDeviceIdAndBindType(int32_t userId, const std::string &accountId);
std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t userId, const std::string &accountId);
void HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
const std::string &remoteUdid);
void HandleDevUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid);
void HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId);
void HandleIdentAccountLogout(const std::string &udid, int32_t userId, const std::string &accountId);
void HandleIdentAccountLogout(const std::string &localUdid, int32_t localUserId, const std::string &peerUdid,
int32_t peerUserId);
void HandleUserRemoved(int32_t preUserId);
void HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo);
void HandleUserSwitched(const std::map<std::string, int32_t> &deviceMap, int32_t currentUserId,
int32_t beforeUserId);
int32_t StopAuthenticateDevice(const std::string &pkgName);
void HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode);
int32_t ProcessAppUnintall(const std::string &appId, int32_t accessTokenId);
void HandleSyncUserIdEvent(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backroundUserIds, const std::string &remoteUdid);
void HandleRemoteUserRemoved(int32_t preUserId, const std::string &remoteUdid);
std::map<std::string, int32_t> GetDeviceIdAndBindLevel(int32_t userId);
std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t localUserId);
private:
std::string GetUdidHashByNetworkId(const std::string &networkId);

1
services/implementation/include/devicestate/dm_device_state_manager.h
View File

@ -96,7 +96,6 @@ public:
bool CheckIsOnline(const std::string &udid);
void DeleteOffLineTimer(std::string udidHash);
void HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo);
void HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode);
private:
void StartEventThread();
void StopEventThread();

9
services/implementation/src/authentication/auth_message_processor.cpp
View File

@ -42,7 +42,7 @@ AuthMessageProcessor::~AuthMessageProcessor()
void AuthMessageProcessor::GetJsonObj(nlohmann::json &jsonObj)
{
if (authResponseContext_->bindType.size() > MAX_BINDTYPE_SIZE) {
if (authResponseContext_ == nullptr || authResponseContext_->bindType.size() > MAX_BINDTYPE_SIZE) {
LOGE("GetJsonObj invalid bindType size.");
return;
}
@ -176,6 +176,7 @@ void AuthMessageProcessor::CreateNegotiateMessage(nlohmann::json &json)
json[TAG_AUTHED] = authResponseContext_->authed;
json[TAG_DMVERSION] = authResponseContext_->dmVersion;
json[TAG_HOST] = authResponseContext_->hostPkgName;
json[TAG_BUNDLE_NAME] = authResponseContext_->bundleName;
json[TAG_TOKENID] = authResponseContext_->tokenId;
json[TAG_IDENTICAL_ACCOUNT] = authResponseContext_->isIdenticalAccount;
json[TAG_HAVE_CREDENTIAL] = authResponseContext_->haveCredential;
@ -201,6 +202,7 @@ void AuthMessageProcessor::CreateRespNegotiateMessage(nlohmann::json &json)
json[TAG_LOCAL_ACCOUNTID] = authResponseContext_->localAccountId;
json[TAG_LOCAL_USERID] = authResponseContext_->localUserId;
json[TAG_TOKENID] = authResponseContext_->tokenId;
json[TAG_ISONLINE] = authResponseContext_->isOnline;
json[TAG_AUTHED] = authResponseContext_->authed;
json[TAG_DMVERSION] = authResponseContext_->dmVersion;
@ -462,7 +464,7 @@ void AuthMessageProcessor::ParsePkgNegotiateMessage(const nlohmann::json &json)
authResponseContext_->authed = json[TAG_AUTHED].get<bool>();
}
if (IsInt64(json, TAG_TOKENID)) {
authResponseContext_->tokenId = json[TAG_TOKENID].get<int64_t>();
authResponseContext_->remoteTokenId = json[TAG_TOKENID].get<int64_t>();
}
if (IsString(json, TAG_DMVERSION)) {
authResponseContext_->dmVersion = json[TAG_DMVERSION].get<std::string>();
@ -525,6 +527,9 @@ void AuthMessageProcessor::ParseNegotiateMessage(const nlohmann::json &json)
if (IsString(json, TAG_EDITION)) {
authResponseContext_->edition = json[TAG_EDITION].get<std::string>();
}
if (IsString(json, TAG_BUNDLE_NAME)) {
authResponseContext_->bundleName = json[TAG_BUNDLE_NAME].get<std::string>();
}
ParsePkgNegotiateMessage(json);
}

26
services/implementation/src/authentication/auth_ui_state_manager.cpp
View File

@ -16,7 +16,9 @@
#include "auth_ui_state_manager.h"
#include "dm_log.h"
#include "nlohmann/json.hpp"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "multiple_user_connector.h"
#endif
namespace OHOS {
namespace DistributedHardware {
constexpr const char* UI_STATE_MSG = "uiStateMsg";
@ -27,18 +29,28 @@ AuthUiStateManager::AuthUiStateManager(std::shared_ptr<IDeviceManagerServiceList
void AuthUiStateManager::RegisterUiStateCallback(const std::string pkgName)
{
int32_t userId = -1;
MultipleUserConnector::GetCallerUserId(userId);
ProcessInfo processInfo;
processInfo.userId = userId;
processInfo.pkgName = pkgName;
std::lock_guard<std::mutex> lock(pkgSetMutex_);
pkgSet_.emplace(pkgName);
pkgSet_.emplace(processInfo);
}
void AuthUiStateManager::UnRegisterUiStateCallback(const std::string pkgName)
{
int32_t userId = -1;
MultipleUserConnector::GetCallerUserId(userId);
ProcessInfo processInfo;
processInfo.userId = userId;
processInfo.pkgName = pkgName;
std::lock_guard<std::mutex> lock(pkgSetMutex_);
if (pkgSet_.find(pkgName) == pkgSet_.end()) {
LOGE("AuthUiStateManager UnRegisterUiStateCallback pkgName is not exist.");
if (pkgSet_.find(processInfo) == pkgSet_.end()) {
LOGE("AuthUiStateManager UnRegisterUiStateCallback processInfo is not exist.");
return;
}
pkgSet_.erase(pkgName);
pkgSet_.erase(processInfo);
}
void AuthUiStateManager::UpdateUiState(const DmUiStateMsg msg)
@ -51,8 +63,8 @@ void AuthUiStateManager::UpdateUiState(const DmUiStateMsg msg)
jsonObj[UI_STATE_MSG] = msg;
std::string paramJson = jsonObj.dump();
std::lock_guard<std::mutex> lock(pkgSetMutex_);
for (auto pkgName : pkgSet_) {
listener_->OnUiCall(pkgName, paramJson);
for (auto item : pkgSet_) {
listener_->OnUiCall(item, paramJson);
}
LOGI("AuthUiStateManager::UpdateUiState complete.");
}

200
services/implementation/src/authentication/dm_auth_manager.cpp
View File

@ -42,6 +42,9 @@
#include "nlohmann/json.hpp"
#include "parameter.h"
#include "show_confirm.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "multiple_user_connector.h"
#endif
namespace OHOS {
namespace DistributedHardware {
@ -90,6 +93,7 @@ constexpr const char* APP_OPERATION_KEY = "appOperation";
constexpr const char* TARGET_PKG_NAME_KEY = "targetPkgName";
constexpr const char* CUSTOM_DESCRIPTION_KEY = "customDescription";
constexpr const char* CANCEL_DISPLAY_KEY = "cancelPinCodeDisplay";
constexpr const char* BUNDLE_NAME_KEY = "bundleName";
constexpr const char* DM_VERSION_4_1_5_1 = "4.1.5.1";
constexpr const char* DM_VERSION_5_0_1 = "5.0.1";
constexpr const char* DM_VERSION_5_0_2 = "5.0.2";
@ -136,9 +140,9 @@ int32_t DmAuthManager::CheckAuthParamVaild(const std::string &pkgName, int32_t a
if (!IsAuthTypeSupported(authType)) {
LOGE("DmAuthManager::CheckAuthParamVaild authType %{public}d not support.", authType);
listener_->OnAuthResult(pkgName, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT,
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT,
ERR_DM_UNSUPPORTED_AUTH_TYPE);
listener_->OnBindResult(pkgName, peerTargetId_, ERR_DM_UNSUPPORTED_AUTH_TYPE, STATUS_DM_AUTH_DEFAULT, "");
listener_->OnBindResult(processInfo_, peerTargetId_, ERR_DM_UNSUPPORTED_AUTH_TYPE, STATUS_DM_AUTH_DEFAULT, "");
return ERR_DM_UNSUPPORTED_AUTH_TYPE;
}
@ -149,15 +153,17 @@ int32_t DmAuthManager::CheckAuthParamVaild(const std::string &pkgName, int32_t a
if (!softbusConnector_->HaveDeviceInMap(deviceId)) {
LOGE("CheckAuthParamVaild failed, the discoveryDeviceInfoMap_ not have this device.");
listener_->OnAuthResult(pkgName, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT, ERR_DM_INPUT_PARA_INVALID);
listener_->OnBindResult(pkgName, peerTargetId_, ERR_DM_INPUT_PARA_INVALID, STATUS_DM_AUTH_DEFAULT, "");
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT,
ERR_DM_INPUT_PARA_INVALID);
listener_->OnBindResult(processInfo_, peerTargetId_, ERR_DM_INPUT_PARA_INVALID, STATUS_DM_AUTH_DEFAULT, "");
return ERR_DM_INPUT_PARA_INVALID;
}
if ((authType == AUTH_TYPE_IMPORT_AUTH_CODE) && (!IsAuthCodeReady(pkgName))) {
LOGE("Auth code not exist.");
listener_->OnAuthResult(pkgName, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT, ERR_DM_INPUT_PARA_INVALID);
listener_->OnBindResult(pkgName, peerTargetId_, ERR_DM_INPUT_PARA_INVALID, STATUS_DM_AUTH_DEFAULT, "");
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT,
ERR_DM_INPUT_PARA_INVALID);
listener_->OnBindResult(processInfo_, peerTargetId_, ERR_DM_INPUT_PARA_INVALID, STATUS_DM_AUTH_DEFAULT, "");
return ERR_DM_INPUT_PARA_INVALID;
}
return DM_OK;
@ -198,9 +204,11 @@ void DmAuthManager::GetAuthParam(const std::string &pkgName, int32_t authType,
authRequestContext_->deviceId = deviceId;
authRequestContext_->addr = deviceId;
authRequestContext_->dmVersion = DM_VERSION_5_0_2;
authRequestContext_->localUserId = MultipleUserConnector::GetCurrentAccountUserID();
authRequestContext_->localAccountId = MultipleUserConnector::GetAccountInfoByUserId(
authRequestContext_->localUserId).accountId;
uint32_t tokenId;
MultipleUserConnector::GetTokenIdAndForegroundUserId(tokenId, authRequestContext_->localUserId);
authRequestContext_->tokenId = static_cast<int64_t>(tokenId);
authRequestContext_->localAccountId =
MultipleUserConnector::GetOhosAccountIdByUserId(authRequestContext_->localUserId);
authRequestContext_->isOnline = false;
authRequestContext_->authed = !authRequestContext_->bindType.empty();
authRequestContext_->bindLevel = INVALIED_TYPE;
@ -218,14 +226,12 @@ void DmAuthManager::GetAuthParam(const std::string &pkgName, int32_t authType,
if (IsString(jsonObject, APP_THUMBNAIL)) {
authRequestContext_->appThumbnail = jsonObject[APP_THUMBNAIL].get<std::string>();
}
if (IsString(jsonObject, TAG_TOKENID)) {
authRequestContext_->tokenId = StringToInt64(jsonObject[TAG_TOKENID].get<std::string>(), STRTOLL_BASE_10);
}
if (IsInt32(jsonObject, TAG_BIND_LEVEL)) {
authRequestContext_->bindLevel = jsonObject[TAG_BIND_LEVEL].get<int32_t>();
}
authRequestContext_->bindLevel = GetBindLevel(authRequestContext_->bindLevel);
}
authRequestContext_->bundleName = GetBundleName(jsonObject);
authRequestContext_->token = std::to_string(GenRandInt(MIN_PIN_TOKEN, MAX_PIN_TOKEN));
}
@ -260,6 +266,10 @@ int32_t DmAuthManager::AuthenticateDevice(const std::string &pkgName, int32_t au
{
LOGI("DmAuthManager::AuthenticateDevice start auth type %{public}d.", authType);
SetAuthType(authType);
int32_t userId = -1;
MultipleUserConnector::GetCallerUserId(userId);
processInfo_.pkgName = pkgName;
processInfo_.userId = userId;
int32_t ret = CheckAuthParamVaild(pkgName, authType, deviceId, extra);
if (ret != DM_OK) {
LOGE("DmAuthManager::AuthenticateDevice failed, param is invaild.");
@ -274,8 +284,8 @@ int32_t DmAuthManager::AuthenticateDevice(const std::string &pkgName, int32_t au
if (authType == AUTH_TYPE_CRE) {
LOGI("DmAuthManager::AuthenticateDevice for credential type, joinLNN directly.");
softbusConnector_->JoinLnn(deviceId);
listener_->OnAuthResult(pkgName, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT, DM_OK);
listener_->OnBindResult(pkgName, peerTargetId_, DM_OK, STATUS_DM_AUTH_DEFAULT, "");
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, "", STATUS_DM_AUTH_DEFAULT, DM_OK);
listener_->OnBindResult(processInfo_, peerTargetId_, DM_OK, STATUS_DM_AUTH_DEFAULT, "");
return DM_OK;
}
InitAuthState(pkgName, authType, deviceId, extra);
@ -335,17 +345,22 @@ int32_t DmAuthManager::DeleteAcl(const std::string &pkgName, const std::string &
LOGE("Acl not contain the pkgname bind data.");
return ERR_DM_FAILED;
}
if (bindLevel == APP && offlineParam.leftAclNumber != 0) {
LOGI("The pkgName unbind app-level type leftAclNumber not zero.");
softbusConnector_->SetPkgName(pkgName);
softbusConnector_->HandleDeviceOffline(remoteUdid);
return DM_OK;
}
if (bindLevel == APP && offlineParam.leftAclNumber == 0) {
LOGI("The pkgName unbind app-level type leftAclNumber is zero.");
softbusConnector_->SetPkgName(pkgName);
hiChainAuthConnector_->DeleteCredential(remoteUdid, MultipleUserConnector::GetCurrentAccountUserID());
return DM_OK;
if (bindLevel == APP) {
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
if (offlineParam.leftAclNumber != 0) {
LOGI("The pkgName unbind app-level type leftAclNumber not zero.");
softbusConnector_->SetProcessInfoVec(offlineParam.processVec);
softbusConnector_->HandleDeviceOffline(remoteUdid);
return DM_OK;
}
if (offlineParam.leftAclNumber == 0) {
LOGI("The pkgName unbind app-level type leftAclNumber is zero.");
softbusConnector_->SetProcessInfoVec(offlineParam.processVec);
hiChainAuthConnector_->DeleteCredential(remoteUdid, MultipleUserConnector::GetCurrentAccountUserID());
return DM_OK;
}
}
if (bindLevel == DEVICE && offlineParam.leftAclNumber != 0) {
LOGI("Unbind deivce-level, retain identical account bind type.");
@ -741,6 +756,7 @@ void DmAuthManager::StartNegotiate(const int32_t &sessionId)
authResponseContext_->deviceId = authRequestContext_->deviceId;
authResponseContext_->accountGroupIdHash = GetAccountGroupIdHash();
authResponseContext_->hostPkgName = authRequestContext_->hostPkgName;
authResponseContext_->bundleName = authRequestContext_->bundleName;
authResponseContext_->hostPkgLabel = authRequestContext_->hostPkgLabel;
authResponseContext_->tokenId = authRequestContext_->tokenId;
authResponseContext_->bindLevel = authRequestContext_->bindLevel;
@ -898,9 +914,9 @@ void DmAuthManager::ProcessAuthRequest(const int32_t &sessionId)
softbusConnector_->GetSoftbusSession()->SendData(sessionId, msg);
}
listener_->OnAuthResult(authResponseContext_->hostPkgName, peerTargetId_.deviceId,
authRequestContext_->token, STATUS_DM_SHOW_AUTHORIZE_UI, DM_OK);
listener_->OnBindResult(authResponseContext_->hostPkgName, peerTargetId_, DM_OK, STATUS_DM_SHOW_AUTHORIZE_UI, "");
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, authRequestContext_->token,
STATUS_DM_SHOW_AUTHORIZE_UI, DM_OK);
listener_->OnBindResult(processInfo_, peerTargetId_, DM_OK, STATUS_DM_SHOW_AUTHORIZE_UI, "");
timer_->StartTimer(std::string(CONFIRM_TIMEOUT_TASK),
GetTaskTimeout(CONFIRM_TIMEOUT_TASK, CONFIRM_TIMEOUT), [this] (std::string name) {
DmAuthManager::HandleAuthenticateTimeout(name);
@ -962,9 +978,9 @@ void DmAuthManager::ProcessAuthRequestExt(const int32_t &sessionId)
for (auto msg : messageList) {
softbusConnector_->GetSoftbusSession()->SendData(sessionId, msg);
}
listener_->OnAuthResult(authResponseContext_->hostPkgName, peerTargetId_.deviceId,
authRequestContext_->token, STATUS_DM_SHOW_AUTHORIZE_UI, DM_OK);
listener_->OnBindResult(authResponseContext_->hostPkgName, peerTargetId_, DM_OK, STATUS_DM_SHOW_AUTHORIZE_UI, "");
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, authRequestContext_->token,
STATUS_DM_SHOW_AUTHORIZE_UI, DM_OK);
listener_->OnBindResult(processInfo_, peerTargetId_, DM_OK, STATUS_DM_SHOW_AUTHORIZE_UI, "");
timer_->StartTimer(std::string(CONFIRM_TIMEOUT_TASK),
GetTaskTimeout(CONFIRM_TIMEOUT_TASK, CONFIRM_TIMEOUT), [this] (std::string name) {
DmAuthManager::HandleAuthenticateTimeout(name);
@ -974,7 +990,7 @@ void DmAuthManager::ProcessAuthRequestExt(const int32_t &sessionId)
bool DmAuthManager::IsAuthFinish()
{
if (authResponseContext_->reply == ERR_DM_UNSUPPORTED_AUTH_TYPE) {
listener_->OnAuthResult(authResponseContext_->hostPkgName, peerTargetId_.deviceId,
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId,
authRequestContext_->token, AuthState::AUTH_REQUEST_NEGOTIATE_DONE, ERR_DM_UNSUPPORTED_AUTH_TYPE);
authRequestState_->TransitionTo(std::make_shared<AuthRequestFinishState>());
return true;
@ -1107,10 +1123,9 @@ void DmAuthManager::StartRespAuthProcess()
GetTaskTimeout(SESSION_HEARTBEAT_TIMEOUT_TASK, SESSION_HEARTBEAT_TIMEOUT), [this] (std::string name) {
DmAuthManager::HandleSessionHeartbeat(name);
});
listener_->OnAuthResult(authRequestContext_->hostPkgName, peerTargetId_.deviceId,
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId,
authRequestContext_->token, STATUS_DM_SHOW_PIN_INPUT_UI, DM_OK);
listener_->OnBindResult(authRequestContext_->hostPkgName, peerTargetId_, DM_OK,
STATUS_DM_SHOW_PIN_INPUT_UI, "");
listener_->OnBindResult(processInfo_, peerTargetId_, DM_OK, STATUS_DM_SHOW_PIN_INPUT_UI, "");
authRequestState_->TransitionTo(std::make_shared<AuthRequestJoinState>());
} else {
LOGE("do not accept");
@ -1210,7 +1225,8 @@ int32_t DmAuthManager::JoinNetwork()
void DmAuthManager::SinkAuthenticateFinish()
{
LOGI("DmAuthManager::SinkAuthenticateFinish, isFinishOfLocal: %{public}d", isFinishOfLocal_);
listener_->OnSinkBindResult(authResponseContext_->hostPkgName, peerTargetId_, authResponseContext_->reply,
processInfo_.pkgName = authResponseContext_->hostPkgName;
listener_->OnSinkBindResult(processInfo_, peerTargetId_, authResponseContext_->reply,
authResponseContext_->state, GenerateBindResultContent());
if (authResponseState_->GetStateType() == AuthState::AUTH_RESPONSE_FINISH && authPtr_ != nullptr) {
authUiStateMgr_->UpdateUiState(DmUiStateMsg::MSG_CANCEL_PIN_CODE_SHOW);
@ -1239,9 +1255,9 @@ void DmAuthManager::SrcAuthenticateFinish()
authUiStateMgr_->UpdateUiState(DmUiStateMsg::MSG_CANCEL_PIN_CODE_INPUT);
}
usleep(USLEEP_TIME_US_500000); // 500ms
listener_->OnAuthResult(authRequestContext_->hostPkgName, peerTargetId_.deviceId,
authRequestContext_->token, authResponseContext_->state, authRequestContext_->reason);
listener_->OnBindResult(authRequestContext_->hostPkgName, peerTargetId_, authRequestContext_->reason,
listener_->OnAuthResult(processInfo_, peerTargetId_.deviceId, authRequestContext_->token,
authResponseContext_->state, authRequestContext_->reason);
listener_->OnBindResult(processInfo_, peerTargetId_, authRequestContext_->reason,
authResponseContext_->state, GenerateBindResultContent());
softbusConnector_->GetSoftbusSession()->CloseAuthSession(authRequestContext_->sessionId);
authRequestContext_ = nullptr;
@ -1284,16 +1300,6 @@ void DmAuthManager::AuthenticateFinish()
LOGI("DmAuthManager::AuthenticateFinish complete");
}
void DmAuthManager::CancelDisplay()
{
LOGI("DmAuthManager::CancelDisplay start");
nlohmann::json jsonObj;
jsonObj[CANCEL_DISPLAY_KEY] = CANCEL_PIN_CODE_DISPLAY;
std::string paramJson = jsonObj.dump();
std::string pkgName = "com.ohos.devicemanagerui";
listener_->OnUiCall(pkgName, paramJson);
}
int32_t DmAuthManager::RegisterUiStateCallback(const std::string pkgName)
{
LOGI("DmAuthManager::RegisterUiStateCallback start");
@ -1956,9 +1962,8 @@ void DmAuthManager::SrcAuthDeviceFinish()
if (authResponseContext_->confirmOperation == USER_OPERATION_TYPE_ALLOW_AUTH ||
(authResponseContext_->confirmOperation == USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS &&
authResponseContext_->haveCredential)) {
if ((authResponseContext_->bindLevel == APP || authResponseContext_->bindLevel == SERVICE) &&
!authResponseContext_->isIdenticalAccount && !authResponseContext_->hostPkgName.empty()) {
softbusConnector_->SetPkgName(authResponseContext_->hostPkgName);
if (!authResponseContext_->isIdenticalAccount && !authResponseContext_->hostPkgName.empty()) {
SetProcessInfo();
}
softbusConnector_->HandleDeviceOnline(remoteDeviceId_, authForm_);
timer_->DeleteTimer(std::string(AUTHENTICATE_TIMEOUT_TASK));
@ -1971,9 +1976,8 @@ void DmAuthManager::SrcAuthDeviceFinish()
if (authResponseContext_->confirmOperation == USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS &&
!authResponseContext_->haveCredential) {
authUiStateMgr_->UpdateUiState(DmUiStateMsg::MSG_CANCEL_PIN_CODE_INPUT);
if ((authResponseContext_->bindLevel == APP || authResponseContext_->bindLevel == SERVICE) &&
!authResponseContext_->isIdenticalAccount && !authResponseContext_->hostPkgName.empty()) {
softbusConnector_->SetPkgName(authResponseContext_->hostPkgName);
if (!authResponseContext_->isIdenticalAccount && !authResponseContext_->hostPkgName.empty()) {
SetProcessInfo();
}
softbusConnector_->HandleDeviceOnline(remoteDeviceId_, authForm_);
authRequestState_->TransitionTo(std::make_shared<AuthRequestCredential>());
@ -2003,7 +2007,7 @@ void DmAuthManager::SinkAuthDeviceFinish()
}
if (authResponseContext_->isOnline) {
LOGI("The device is online.");
softbusConnector_->SetPkgName(authResponseContext_->hostPkgName);
SetProcessInfo();
softbusConnector_->HandleDeviceOnline(remoteDeviceId_, authForm_);
}
}
@ -2124,16 +2128,14 @@ void DmAuthManager::ProcRespNegotiateExt(const int32_t &sessionId)
{
LOGI("DmAuthManager::ProcRespNegotiateExt start.");
remoteDeviceId_ = authResponseContext_->localDeviceId;
int32_t userId = MultipleUserConnector::GetCurrentAccountUserID();
std::string accountId = MultipleUserConnector::GetAccountInfoByUserId(userId).accountId;
authResponseContext_->remoteAccountId = authResponseContext_->localAccountId;
authResponseContext_->remoteUserId = authResponseContext_->localUserId;
GetBinderInfo();
authResponseContext_->isIdenticalAccount = false;
if (authResponseContext_->localAccountId == accountId && accountId != "ohosAnonymousUid") {
if (authResponseContext_->localAccountId == authResponseContext_->remoteAccountId &&
authResponseContext_->localAccountId != "ohosAnonymousUid") {
authResponseContext_->isIdenticalAccount = true;
}
authResponseContext_->remoteAccountId = authResponseContext_->localAccountId;
authResponseContext_->localAccountId = accountId;
authResponseContext_->remoteUserId = authResponseContext_->localUserId;
authResponseContext_->localUserId = userId;
char localDeviceId[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH);
authResponseContext_->deviceId = authResponseContext_->localDeviceId;
@ -2305,25 +2307,24 @@ void DmAuthManager::PutAccessControlList()
}
aclInfo.deviceIdHash = localUdidHash;
DmAccesser accesser;
accesser.requestTokenId = static_cast<uint64_t>(authResponseContext_->tokenId);
accesser.requestBundleName = authResponseContext_->hostPkgName;
DmAccessee accessee;
accessee.trustBundleName = authResponseContext_->hostPkgName;
if (authRequestState_ != nullptr && authResponseState_ == nullptr) {
accesser.requestTokenId = static_cast<uint64_t>(authResponseContext_->tokenId);
accesser.requestUserId = authRequestContext_->localUserId;
accesser.requestAccountId = authRequestContext_->localAccountId;
accesser.requestDeviceId = authRequestContext_->localDeviceId;
} else if (authRequestState_ == nullptr && authResponseState_ != nullptr) {
accesser.requestUserId = authResponseContext_->remoteUserId;
accesser.requestAccountId = authResponseContext_->remoteAccountId;
accesser.requestDeviceId = authResponseContext_->localDeviceId;
}
DmAccessee accessee;
accessee.trustTokenId = static_cast<uint64_t>(authResponseContext_->tokenId);
accessee.trustBundleName = authResponseContext_->hostPkgName;
if (authRequestState_ != nullptr && authResponseState_ == nullptr) {
accessee.trustTokenId = static_cast<uint64_t>(authResponseContext_->remoteTokenId);
accessee.trustUserId = authRequestContext_->remoteUserId;
accessee.trustAccountId = authRequestContext_->remoteAccountId;
accessee.trustDeviceId = authResponseContext_->deviceId;
} else if (authRequestState_ == nullptr && authResponseState_ != nullptr) {
accesser.requestTokenId = static_cast<uint64_t>(authResponseContext_->remoteTokenId);
accesser.requestUserId = authResponseContext_->remoteUserId;
accesser.requestAccountId = authResponseContext_->remoteAccountId;
accesser.requestDeviceId = authResponseContext_->localDeviceId;
accessee.trustTokenId = static_cast<uint64_t>(authResponseContext_->tokenId);
accessee.trustUserId = authResponseContext_->localUserId;
accessee.trustAccountId = authResponseContext_->localAccountId;
accessee.trustDeviceId = localUdid;
@ -2546,5 +2547,58 @@ int32_t DmAuthManager::GetBindLevel(int32_t bindLevel)
}
return bindLevel;
}
std::string DmAuthManager::GetBundleName(nlohmann::json &jsonObject)
{
if (!jsonObject.is_discarded() && IsString(jsonObject, BUNDLE_NAME_KEY)) {
return jsonObject[BUNDLE_NAME_KEY].get<std::string>();
}
bool isSystemSA = false;
std::string bundleName;
AppManager::GetInstance().GetCallerName(isSystemSA, bundleName);
return bundleName;
}
int32_t DmAuthManager::GetBinderInfo()
{
CHECK_NULL_RETURN(authResponseContext_, ERR_DM_POINT_NULL);
if (authResponseContext_->bundleName.empty()) {
LOGI("bundleName is empty");
authResponseContext_->localUserId = MultipleUserConnector::GetCurrentAccountUserID();
authResponseContext_->localAccountId = MultipleUserConnector::GetOhosAccountId();
authResponseContext_->tokenId = authResponseContext_->remoteTokenId;
return DM_OK;
}
authResponseContext_->localUserId = MultipleUserConnector::GetFirstForegroundUserId();
authResponseContext_->localAccountId =
MultipleUserConnector::GetOhosAccountIdByUserId(authResponseContext_->localUserId);
int32_t ret = AppManager::GetInstance().
GetNativeTokenIdByName(authResponseContext_->bundleName, authResponseContext_->tokenId);
if (ret == DM_OK) {
LOGI("bundleName is sa");
return DM_OK;
}
ret = AppManager::GetInstance().GetHapTokenIdByName(authResponseContext_->localUserId,
authResponseContext_->bundleName, 0, authResponseContext_->tokenId);
if (ret != DM_OK) {
LOGI("get tokenId by bundleName failed %{public}s", GetAnonyString(authResponseContext_->bundleName).c_str());
authResponseContext_->tokenId = authResponseContext_->remoteTokenId;
}
return ret;
}
void DmAuthManager::SetProcessInfo()
{
CHECK_NULL_VOID(authResponseContext_);
ProcessInfo processInfo;
if (authResponseContext_->bindLevel == APP) {
processInfo.pkgName = authResponseContext_->hostPkgName;
processInfo.userId = authResponseContext_->localUserId;
} else if (authResponseContext_->bindLevel == DEVICE || authResponseContext_->bindLevel == INVALIED_TYPE) {
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = authResponseContext_->localUserId;
}
softbusConnector_->SetProcessInfo(processInfo);
}
} // namespace DistributedHardware
} // namespace OHOS

31
services/implementation/src/credential/dm_credential_manager.cpp
View File

@ -20,7 +20,9 @@
#include "dm_log.h"
#include "dm_random.h"
#include "parameter.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "multiple_user_connector.h"
#endif
namespace OHOS {
namespace DistributedHardware {
const int32_t LOCAL_CREDENTIAL_DEAL_TYPE = 1;
@ -123,7 +125,6 @@ int32_t DmCredentialManager::ImportCredential(const std::string &pkgName, const
LOGE("credentialInfo not found by pkgName %{public}s", GetAnonyString(pkgName).c_str());
return ERR_DM_FAILED;
}
pkgName_ = pkgName;
nlohmann::json jsonObject = nlohmann::json::parse(credentialInfo, nullptr, false);
if (jsonObject.is_discarded()) {
LOGE("credentialInfo string not a json type.");
@ -213,7 +214,12 @@ int32_t DmCredentialManager::DeleteCredential(const std::string &pkgName, const
LOGE("credentialInfo not found by pkgName %{public}s", GetAnonyString(pkgName).c_str());
return ERR_DM_FAILED;
}
pkgName_ = pkgName;
int32_t callerUserId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
MultipleUserConnector::GetCallerUserId(callerUserId);
#endif
processInfo_.pkgName = pkgName;
processInfo_.userId = callerUserId;
nlohmann::json jsonObject = nlohmann::json::parse(deleteInfo, nullptr, false);
if (jsonObject.is_discarded()) {
LOGE("deleteInfo string not a json type.");
@ -247,7 +253,8 @@ int32_t DmCredentialManager::DeleteCredential(const std::string &pkgName, const
void DmCredentialManager::OnGroupResultExt(int32_t action, const std::string &resultInfo)
{
LOGI("DmCredentialManager::OnGroupResultExt action %{public}d, resultInfo %{public}s.", action, resultInfo.c_str());
listener_->OnCredentialResult(pkgName_, action, resultInfo);
CHECK_NULL_VOID(listener_);
listener_->OnCredentialResult(processInfo_, action, resultInfo);
}
void DmCredentialManager::OnGroupResult(int64_t requestId, int32_t action,
@ -257,7 +264,8 @@ void DmCredentialManager::OnGroupResult(int64_t requestId, int32_t action,
if (requestId_ != requestId) {
return;
}
listener_->OnCredentialResult(pkgName_, action, resultInfo);
CHECK_NULL_VOID(listener_);
listener_->OnCredentialResult(processInfo_, action, resultInfo);
}
int32_t DmCredentialManager::RegisterCredentialCallback(const std::string &pkgName)
@ -266,9 +274,15 @@ int32_t DmCredentialManager::RegisterCredentialCallback(const std::string &pkgNa
LOGE("DmCredentialManager::RegisterCredentialCallback input param is empty");
return ERR_DM_FAILED;
}
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
MultipleUserConnector::GetCallerUserId(userId);
#endif
LOGI("DmCredentialManager::RegisterCredentialCallback pkgName = %{public}s", GetAnonyString(pkgName).c_str());
{
std::lock_guard<std::mutex> autoLock(locks_);
processInfo_.pkgName = pkgName;
processInfo_.userId = userId;
credentialVec_.push_back(pkgName);
}
return hiChainConnector_->RegisterHiChainGroupCallback(std::shared_ptr<IDmGroupResCallback>(shared_from_this()));
@ -519,5 +533,12 @@ int32_t DmCredentialManager::DeleteRemoteCredential(const std::string &deleteInf
}
return DM_OK;
}
void DmCredentialManager::HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId,
int32_t errcode)
{
CHECK_NULL_VOID(listener_);
listener_->OnCredentialAuthStatus(processInfo_, deviceList, deviceTypeId, errcode);
}
} // namespace DistributedHardware
} // namespace OHOS

32
services/implementation/src/dependency/softbus/softbus_connector.cpp
View File

@ -49,11 +49,11 @@ std::map<std::string, std::shared_ptr<ISoftbusDiscoveryCallback>> SoftbusConnect
std::map<std::string, std::shared_ptr<ISoftbusPublishCallback>> SoftbusConnector::publishCallbackMap_ = {};
std::queue<std::string> SoftbusConnector::discoveryDeviceIdQueue_ = {};
std::unordered_map<std::string, std::string> SoftbusConnector::deviceUdidMap_ = {};
std::vector<std::string> SoftbusConnector::pkgNameVec_ = {};
std::vector<ProcessInfo> SoftbusConnector::processInfoVec_ = {};
std::mutex SoftbusConnector::discoveryCallbackMutex_;
std::mutex SoftbusConnector::discoveryDeviceInfoMutex_;
std::mutex SoftbusConnector::deviceUdidLocks_;
std::mutex SoftbusConnector::pkgNameVecMutex_;
std::mutex SoftbusConnector::processInfoVecMutex_;
IPublishCb SoftbusConnector::softbusPublishCallback_ = {
.OnPublishResult = SoftbusConnector::OnSoftbusPublishResult,
@ -675,32 +675,32 @@ std::string SoftbusConnector::GetNetworkIdByDeviceId(const std::string &deviceId
return "";
}
void SoftbusConnector::SetPkgName(std::string pkgName)
void SoftbusConnector::SetProcessInfo(ProcessInfo processInfo)
{
LOGI("SoftbusConnector::SetPkgName");
std::lock_guard<std::mutex> lock(pkgNameVecMutex_);
pkgNameVec_.push_back(pkgName);
LOGI("SoftbusConnector::SetProcessInfo");
std::lock_guard<std::mutex> lock(processInfoVecMutex_);
processInfoVec_.push_back(processInfo);
}
void SoftbusConnector::SetPkgNameVec(std::vector<std::string> pkgNameVec)
void SoftbusConnector::SetProcessInfoVec(std::vector<ProcessInfo> processInfoVec)
{
LOGI("SoftbusConnector::SetPkgNameVec");
std::lock_guard<std::mutex> lock(pkgNameVecMutex_);
pkgNameVec_ = pkgNameVec;
LOGI("SoftbusConnector::SetProcessInfoVec");
std::lock_guard<std::mutex> lock(processInfoVecMutex_);
processInfoVec_ = processInfoVec;
}
std::vector<std::string> SoftbusConnector::GetPkgName()
std::vector<ProcessInfo> SoftbusConnector::GetProcessInfo()
{
LOGI("In");
std::lock_guard<std::mutex> lock(pkgNameVecMutex_);
return pkgNameVec_;
std::lock_guard<std::mutex> lock(processInfoVecMutex_);
return processInfoVec_;
}
void SoftbusConnector::ClearPkgName()
void SoftbusConnector::ClearProcessInfo()
{
LOGI("In");
std::lock_guard<std::mutex> lock(pkgNameVecMutex_);
pkgNameVec_.clear();
std::lock_guard<std::mutex> lock(processInfoVecMutex_);
processInfoVec_.clear();
}
void SoftbusConnector::HandleDeviceOnline(std::string deviceId, int32_t authForm)

258
services/implementation/src/device_manager_service_impl.cpp
View File

@ -212,26 +212,31 @@ void DeviceManagerServiceImpl::HandleOffline(DmDeviceState devState, DmDeviceInf
char localUdid[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdid, DEVICE_UUID_LENGTH);
std::string requestDeviceId = std::string(localUdid);
DmOfflineParam offlineParam =
DeviceProfileConnector::GetInstance().GetOfflineParamFromAcl(trustDeviceId, requestDeviceId);
LOGI("The offline device bind type is %{public}d.", offlineParam.bindType);
if (offlineParam.leftAclNumber == 0 && offlineParam.bindType == INVALIED_TYPE) {
deviceStateMgr_->HandleDeviceStatusChange(devState, devInfo);
} else if (offlineParam.bindType == IDENTICAL_ACCOUNT_TYPE) {
LOGI("The offline device is identical account bind type.");
deviceStateMgr_->HandleDeviceStatusChange(devState, devInfo);
} else if (offlineParam.bindType == DEVICE_PEER_TO_PEER_TYPE) {
LOGI("The offline device is device-level bind type.");
deviceStateMgr_->HandleDeviceStatusChange(devState, devInfo);
} else if (offlineParam.bindType == APP_PEER_TO_PEER_TYPE) {
LOGI("The offline device is app-level bind type.");
softbusConnector_->SetPkgNameVec(offlineParam.pkgNameVec);
deviceStateMgr_->HandleDeviceStatusChange(devState, devInfo);
}
if (offlineParam.leftAclNumber == 0) {
LOGI("Delete credential in HandleDeviceOffline.");
hiChainAuthConnector_->DeleteCredential(trustDeviceId, MultipleUserConnector::GetCurrentAccountUserID());
std::map<int32_t, int32_t> userIdAndBindLevel =
DeviceProfileConnector::GetInstance().GetUserIdAndBindLevel(requestDeviceId, trustDeviceId);
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
for (const auto &item : userIdAndBindLevel) {
if (item.second == INVALIED_TYPE) {
LOGI("The offline device is identical account bind type.");
devInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
processInfo.userId = item.first;
softbusConnector_->SetProcessInfo(processInfo);
} else if (item.second == DEVICE) {
LOGI("The offline device is device bind type.");
devInfo.authForm = DmAuthForm::PEER_TO_PEER;
processInfo.userId = item.first;
softbusConnector_->SetProcessInfo(processInfo);
} else if (item.second == SERVICE || item.second == APP) {
LOGI("The offline device is APP_PEER_TO_PEER_TYPE bind type.");
std::vector<ProcessInfo> processInfoVec =
DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(requestDeviceId, trustDeviceId,
item.first);
softbusConnector_->SetProcessInfoVec(processInfoVec);
}
}
deviceStateMgr_->HandleDeviceStatusChange(devState, devInfo);
}
void DeviceManagerServiceImpl::HandleOnline(DmDeviceState devState, DmDeviceInfo &devInfo)
@ -239,7 +244,7 @@ void DeviceManagerServiceImpl::HandleOnline(DmDeviceState devState, DmDeviceInfo
LOGI("DeviceManagerServiceImpl::HandleOnline");
std::string trustDeviceId = "";
if (softbusConnector_->GetUdidByNetworkId(devInfo.networkId, trustDeviceId) != DM_OK) {
LOGE("HandleDeviceOffline get udid failed.");
LOGE("HandleOnline get udid failed.");
return;
}
std::string udisHash = softbusConnector_->GetDeviceUdidHashByUdid(trustDeviceId);
@ -252,32 +257,34 @@ void DeviceManagerServiceImpl::HandleOnline(DmDeviceState devState, DmDeviceInfo
std::string requestDeviceId = std::string(localUdid);
uint32_t bindType = DeviceProfileConnector::GetInstance().CheckBindType(trustDeviceId, requestDeviceId);
LOGI("The online device bind type is %{public}d.", bindType);
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
if (bindType == INVALIED_TYPE && isCredentialType_.load()) {
PutIdenticalAccountToAcl(requestDeviceId, trustDeviceId);
devInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
isCredentialType_.store(false);
softbusConnector_->SetProcessInfo(processInfo);
} else if (bindType == IDENTICAL_ACCOUNT_TYPE) {
devInfo.authForm = DmAuthForm::IDENTICAL_ACCOUNT;
softbusConnector_->SetProcessInfo(processInfo);
} else if (bindType == DEVICE_PEER_TO_PEER_TYPE) {
devInfo.authForm = DmAuthForm::PEER_TO_PEER;
softbusConnector_->SetProcessInfo(processInfo);
} else if (bindType == DEVICE_ACROSS_ACCOUNT_TYPE) {
devInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
softbusConnector_->SetProcessInfo(processInfo);
} else if (bindType == APP_PEER_TO_PEER_TYPE) {
std::vector<std::string> pkgNameVec =
DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(requestDeviceId, trustDeviceId);
if (pkgNameVec.size() == 0) {
LOGI("The online device not need report pkgname");
return;
}
softbusConnector_->SetPkgNameVec(pkgNameVec);
std::vector<ProcessInfo> processInfoVec =
DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(requestDeviceId, trustDeviceId,
MultipleUserConnector::GetFirstForegroundUserId());
softbusConnector_->SetProcessInfoVec(processInfoVec);
devInfo.authForm = DmAuthForm::PEER_TO_PEER;
} else if (bindType == APP_ACROSS_ACCOUNT_TYPE) {
std::vector<std::string> pkgNameVec =
DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(requestDeviceId, trustDeviceId);
if (pkgNameVec.size() == 0) {
LOGI("The online device not need report pkgname");
return;
}
softbusConnector_->SetPkgNameVec(pkgNameVec);
std::vector<ProcessInfo> processInfoVec =
DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(requestDeviceId, trustDeviceId,
MultipleUserConnector::GetFirstForegroundUserId());
softbusConnector_->SetProcessInfoVec(processInfoVec);
devInfo.authForm = DmAuthForm::ACROSS_ACCOUNT;
}
LOGI("DeviceManagerServiceImpl::HandleOnline success devInfo auform %{public}d.", devInfo.authForm);
@ -300,6 +307,10 @@ void DeviceManagerServiceImpl::HandleDeviceStatusChange(DmDeviceState devState,
LOGE("get deviceId: %{public}s failed", GetAnonyString(udiddHash).c_str());
return;
}
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
softbusConnector_->SetProcessInfo(processInfo);
deviceStateMgr_->HandleDeviceStatusChange(devState, devInfo);
}
}
@ -488,7 +499,7 @@ int32_t DeviceManagerServiceImpl::RegisterUiStateCallback(const std::string &pkg
int32_t DeviceManagerServiceImpl::UnRegisterUiStateCallback(const std::string &pkgName)
{
if (pkgName.empty()) {
LOGE("RegisterUiStateCallback failed, pkgName is empty");
LOGE("UnRegisterUiStateCallback failed, pkgName is empty");
return ERR_DM_INPUT_PARA_INVALID;
}
if (authMgr_ == nullptr) {
@ -624,8 +635,8 @@ void DeviceManagerServiceImpl::PutIdenticalAccountToAcl(std::string requestDevic
aclInfo.authenticationType = ALLOW_AUTH_ALWAYS;
aclInfo.deviceIdHash = localUdidHash;
DmAccesser accesser;
accesser.requestUserId = MultipleUserConnector::GetCurrentAccountUserID();
accesser.requestAccountId = MultipleUserConnector::GetOhosAccountId();
accesser.requestUserId = MultipleUserConnector::GetFirstForegroundUserId();
accesser.requestAccountId = MultipleUserConnector::GetOhosAccountIdByUserId(accesser.requestUserId);
MultipleUserConnector::SetSwitchOldUserId(accesser.requestUserId);
MultipleUserConnector::SetSwitchOldAccountId(accesser.requestAccountId);
accesser.requestDeviceId = requestDeviceId;
@ -641,6 +652,10 @@ int32_t DeviceManagerServiceImpl::DpAclAdd(const std::string &udid)
MultipleUserConnector::SetSwitchOldAccountId(MultipleUserConnector::GetOhosAccountId());
if (deviceStateMgr_->CheckIsOnline(udid)) {
LOGI("DeviceManagerServiceImpl DpAclAdd identical account and online");
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
softbusConnector_->SetProcessInfo(processInfo);
deviceStateMgr_->OnDeviceOnline(udid, DmAuthForm::IDENTICAL_ACCOUNT);
}
LOGI("DeviceManagerServiceImpl::DpAclAdd completed");
@ -671,27 +686,68 @@ void DeviceManagerServiceImpl::LoadHardwareFwkService()
DmDistributedHardwareLoad::GetInstance().LoadDistributedHardwareFwk();
}
void DeviceManagerServiceImpl::HandleIdentAccountLogout(const std::string &udid, int32_t userId,
const std::string &accountId)
void DeviceManagerServiceImpl::HandleIdentAccountLogout(const std::string &localUdid, int32_t localUserId,
const std::string &peerUdid, int32_t peerUserId)
{
LOGI("Udid %{public}s, userId %{public}d, accountId %{public}s.", GetAnonyString(udid).c_str(),
userId, GetAnonyString(accountId).c_str());
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
DeviceProfileConnector::GetInstance().DeleteAclForAccountLogOut(localUdid, userId, udid);
CHECK_NULL_VOID(hiChainConnector_);
authMgr_->DeleteGroup(DM_PKG_NAME, userId, udid);
LOGI("localUdid %{public}s, localUserId %{public}d, peerUdid %{public}s, peerUserId %{public}d.",
GetAnonyString(localUdid).c_str(), localUserId, GetAnonyString(peerUdid).c_str(), peerUserId);
bool notifyOffline = DeviceProfileConnector::GetInstance().DeleteAclForAccountLogOut(localUdid, localUserId,
peerUdid, peerUserId);
if (notifyOffline) {
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = localUserId;
CHECK_NULL_VOID(softbusConnector_);
softbusConnector_->SetProcessInfo(processInfo);
CHECK_NULL_VOID(deviceStateMgr_);
deviceStateMgr_->OnDeviceOffline(peerUdid);
}
}
void DeviceManagerServiceImpl::HandleUserRemoved(int32_t preUserId)
{
LOGI("PreUserId %{public}d.", preUserId);
DeviceProfileConnector::GetInstance().DeleteAclForUserRemoved(preUserId);
char localDeviceId[DEVICE_UUID_LENGTH];
GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH);
std::string localUdid = reinterpret_cast<char *>(localDeviceId);
DeviceProfileConnector::GetInstance().DeleteAclForUserRemoved(localUdid, preUserId);
CHECK_NULL_VOID(hiChainConnector_);
hiChainConnector_->DeleteAllGroup(preUserId);
}
void DeviceManagerServiceImpl::HandleRemoteUserRemoved(int32_t userId, const std::string &remoteUdid)
{
LOGI("remoteUdid %{public}s, userId %{public}d", GetAnonyString(remoteUdid).c_str(), userId);
DeviceProfileConnector::GetInstance().DeleteAclForUserRemoved(remoteUdid, userId);
CHECK_NULL_VOID(hiChainConnector_);
hiChainConnector_->DeleteAllGroup(userId);
}
void DeviceManagerServiceImpl::HandleUserSwitched(const std::map<std::string, int32_t> &deviceMap,
int32_t currentUserId, int32_t beforeUserId)
{
LOGI("currentUserId: %{public}s, beforeUserId: %{public}s", GetAnonyInt32(currentUserId).c_str(),
GetAnonyInt32(beforeUserId).c_str());
char localDeviceId[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localDeviceId, DEVICE_UUID_LENGTH);
std::string localUdid = static_cast<std::string>(localDeviceId);
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = beforeUserId;
for (const auto &item : deviceMap) {
if (item.second == INVALIED_TYPE || item.second == DEVICE) {
softbusConnector_->SetProcessInfo(processInfo);
} else {
std::vector<ProcessInfo> processInfoVec =
DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(localUdid,
item.first, beforeUserId);
softbusConnector_->SetProcessInfoVec(processInfoVec);
}
softbusConnector_->HandleDeviceOffline(item.first);
}
DeviceProfileConnector::GetInstance().HandleUserSwitched(localUdid, currentUserId, beforeUserId);
}
void DeviceManagerServiceImpl::ScreenCommonEventCallback(std::string commonEventType)
{
if (commonEventType == EventFwk::CommonEventSupport::COMMON_EVENT_SCREEN_LOCKED) {
@ -731,13 +787,23 @@ int32_t DeviceManagerServiceImpl::GetBindLevel(const std::string &pkgName, const
return DeviceProfileConnector::GetInstance().GetBindLevel(pkgName, localUdid, udid, tokenId);
}
std::map<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndBindType(int32_t userId,
std::map<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndBindLevel(int32_t userId)
{
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
std::vector<int32_t> userIds;
userIds.push_back(userId);
return DeviceProfileConnector::GetInstance().GetDeviceIdAndBindLevel(userIds, localUdid);
}
std::multimap<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndUserId(int32_t userId,
const std::string &accountId)
{
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
return DeviceProfileConnector::GetInstance().GetDeviceIdAndBindType(userId, accountId, localUdid);
return DeviceProfileConnector::GetInstance().GetDeviceIdAndUserId(userId, accountId, localUdid);
}
void DeviceManagerServiceImpl::HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
@ -746,18 +812,26 @@ void DeviceManagerServiceImpl::HandleAccountLogoutEvent(int32_t remoteUserId, co
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
int32_t bindType = DeviceProfileConnector::GetInstance().HandleAccountLogoutEvent(remoteUserId, remoteAccountHash,
remoteUdid, localUdid);
if (bindType == DM_INVALIED_BINDTYPE) {
LOGE("Invalied bindtype.");
return;
}
CHECK_NULL_VOID(authMgr_);
authMgr_->DeleteGroup(DM_PKG_NAME, remoteUdid);
std::multimap<std::string, int32_t> devIdAndUserMap =
DeviceProfileConnector::GetInstance().GetDevIdAndUserIdByActHash(localUdid, remoteUdid,
remoteUserId, remoteAccountHash);
CHECK_NULL_VOID(listener_);
std::string uuid = "";
SoftbusCache::GetInstance().GetUuidByUdid(remoteUdid, uuid);
listener_->OnDeviceTrustChange(remoteUdid, uuid, ConvertBindTypeToAuthForm(bindType));
listener_->OnDeviceTrustChange(remoteUdid, uuid, DmAuthForm::IDENTICAL_ACCOUNT);
for (const auto &item : devIdAndUserMap) {
bool notifyOffline = DeviceProfileConnector::GetInstance().DeleteAclForAccountLogOut(item.first, item.second,
remoteUdid, remoteUserId);
if (notifyOffline) {
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = item.second;
CHECK_NULL_VOID(softbusConnector_);
softbusConnector_->SetProcessInfo(processInfo);
CHECK_NULL_VOID(deviceStateMgr_);
deviceStateMgr_->OnDeviceOffline(remoteUdid);
}
}
}
DmAuthForm DeviceManagerServiceImpl::ConvertBindTypeToAuthForm(int32_t bindType)
@ -796,17 +870,47 @@ void DeviceManagerServiceImpl::HandleAppUnBindEvent(int32_t remoteUserId, const
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
std::string pkgName =
ProcessInfo processInfo =
DeviceProfileConnector::GetInstance().HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId, localUdid);
if (pkgName.empty()) {
if (processInfo.pkgName.empty()) {
LOGE("Pkgname is empty.");
return;
}
CHECK_NULL_VOID(softbusConnector_);
softbusConnector_->SetPkgName(pkgName);
softbusConnector_->SetProcessInfo(processInfo);
softbusConnector_->HandleDeviceOffline(remoteUdid);
}
void DeviceManagerServiceImpl::HandleSyncUserIdEvent(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backroundUserIds, const std::string &remoteUdid)
{
LOGI("remote udid: %{public}s", GetAnonyString(remoteUdid).c_str());
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
std::vector<int32_t> rmtFrontUserIdsTemp(foregroundUserIds.begin(), foregroundUserIds.end());
std::vector<int32_t> rmtBackUserIdsTemp(backroundUserIds.begin(), backroundUserIds.end());
std::vector<int32_t> localUserIds;
int32_t ret = MultipleUserConnector::GetForegroundUserIds(localUserIds);
if (ret != DM_OK || localUserIds.empty()) {
LOGE("Get foreground userids failed, ret: %{public}d", ret);
}
DeviceProfileConnector::GetInstance().UpdatePeerUserId(localUdid, localUserIds, remoteUdid,
rmtFrontUserIdsTemp, rmtBackUserIdsTemp);
std::vector<ProcessInfo> offlineProcInfo =
DeviceProfileConnector::GetInstance().GetOfflineProcessInfo(localUdid, localUserIds,
remoteUdid, rmtBackUserIdsTemp);
if (!offlineProcInfo.empty()) {
CHECK_NULL_VOID(softbusConnector_);
softbusConnector_->SetProcessInfoVec(offlineProcInfo);
softbusConnector_->HandleDeviceOffline(remoteUdid);
}
DeviceProfileConnector::GetInstance().HandleSyncForegroundUserIdEvent(rmtFrontUserIdsTemp, remoteUdid,
localUserIds, localUdid);
DeviceProfileConnector::GetInstance().HandleSyncBackgroundUserIdEvent(rmtBackUserIdsTemp, remoteUdid,
localUserIds, localUdid);
}
void DeviceManagerServiceImpl::HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo)
{
LOGI("In");
@ -831,16 +935,15 @@ void DeviceManagerServiceImpl::HandleDeviceScreenStatusChange(DmDeviceInfo &devI
return;
} else if (bindType == IDENTICAL_ACCOUNT_TYPE || bindType == DEVICE_PEER_TO_PEER_TYPE ||
bindType == DEVICE_ACROSS_ACCOUNT_TYPE) {
softbusConnector_->ClearPkgName();
LOGI("networkId: %{public}s", GetAnonyString(devInfo.networkId).c_str());
ProcessInfo processInfo;
processInfo.pkgName = std::string(DM_PKG_NAME);
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
softbusConnector_->SetProcessInfo(processInfo);
} else if (bindType == APP_PEER_TO_PEER_TYPE || bindType == APP_ACROSS_ACCOUNT_TYPE) {
std::vector<std::string> pkgNameVec =
DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(requestDeviceId, trustDeviceId);
if (pkgNameVec.size() == 0) {
LOGI("not need report pkgname");
return;
}
softbusConnector_->SetPkgNameVec(pkgNameVec);
std::vector<ProcessInfo> processInfoVec =
DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(requestDeviceId, trustDeviceId,
MultipleUserConnector::GetFirstForegroundUserId());
softbusConnector_->SetProcessInfoVec(processInfoVec);
}
deviceStateMgr_->HandleDeviceScreenStatusChange(devInfo);
}
@ -848,8 +951,8 @@ void DeviceManagerServiceImpl::HandleDeviceScreenStatusChange(DmDeviceInfo &devI
void DeviceManagerServiceImpl::HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId,
int32_t errcode)
{
CHECK_NULL_VOID(deviceStateMgr_);
deviceStateMgr_->HandleCredentialAuthStatus(deviceList, deviceTypeId, errcode);
CHECK_NULL_VOID(credentialMgr_);
credentialMgr_->HandleCredentialAuthStatus(deviceList, deviceTypeId, errcode);
}
int32_t DeviceManagerServiceImpl::ProcessAppUnintall(const std::string &appId, int32_t accessTokenId)
@ -889,6 +992,15 @@ int32_t DeviceManagerServiceImpl::ProcessAppUnintall(const std::string &appId, i
return DM_OK;
}
std::multimap<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndUserId(int32_t localUserId)
{
LOGI("localUserId %{public}d.", localUserId);
char localdeviceId[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localdeviceId, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localdeviceId);
return DeviceProfileConnector::GetInstance().GetDeviceIdAndUserId(localUdid, localUserId);
}
extern "C" IDeviceManagerServiceImpl *CreateDMServiceObject(void)
{
return new DeviceManagerServiceImpl;

51
services/implementation/src/device_manager_service_impl_lite.cpp
View File

@ -458,12 +458,12 @@ int32_t DeviceManagerServiceImpl::GetBindLevel(const std::string &pkgName, const
return DEVICE_BIUND_LEVEL;
}
std::map<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndBindType(int32_t userId,
std::multimap<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndUserId(int32_t userId,
const std::string &accountId)
{
(void)userId;
(void)accountId;
return std::map<std::string, int32_t> {};
return std::multimap<std::string, int32_t> {};
}
void DeviceManagerServiceImpl::HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
@ -491,12 +491,13 @@ void DeviceManagerServiceImpl::HandleAppUnBindEvent(int32_t remoteUserId, const
return;
}
void DeviceManagerServiceImpl::HandleIdentAccountLogout(const std::string &udid, int32_t userId,
const std::string &accountId)
void DeviceManagerServiceImpl::HandleIdentAccountLogout(const std::string &localUdid, int32_t localUserId,
const std::string &peerUdid, int32_t peerUserId)
{
(void)udid;
(void)userId;
(void)accountId;
(void)localUdid;
(void)localUserId;
(void)peerUdid;
(void)peerUserId;
return;
}
@ -512,6 +513,15 @@ void DeviceManagerServiceImpl::HandleDeviceScreenStatusChange(DmDeviceInfo &devI
return;
}
void DeviceManagerServiceImpl::HandleUserSwitched(const std::map<std::string, int32_t> &deviceMap,
int32_t currentUserId, int32_t beforeUserId)
{
(void)deviceMap;
(void)currentUserId;
(void)beforeUserId;
return;
}
int32_t DeviceManagerServiceImpl::StopAuthenticateDevice(const std::string &pkgName)
{
(void)pkgName;
@ -527,13 +537,38 @@ void DeviceManagerServiceImpl::HandleCredentialAuthStatus(const std::string &dev
return;
}
int32_t ProcessAppUnintall(const std::string &appId, int32_t accessTokenId)
int32_t DeviceManagerServiceImpl::ProcessAppUnintall(const std::string &appId, int32_t accessTokenId)
{
(void)appId;
(void)accessTokenId;
return 0;
}
void DeviceManagerServiceImpl::HandleSyncUserIdEvent(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backroundUserIds, const std::string &remoteUdid)
{
(void)foregroundUserIds;
(void)backroundUserIds;
(void)remoteUdid;
}
void HandleRemoteUserRemoved(int32_t preUserId, const std::string &remoteUdid)
{
(void)preUserId;
(void)remoteUdid;
}
std::map<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndBindLevel(int32_t userId)
{
(void)userId;
}
std::multimap<std::string, int32_t> DeviceManagerServiceImpl::GetDeviceIdAndUserId(int32_t localUserId)
{
(void)localUserId;
return {};
}
extern "C" IDeviceManagerServiceImpl *CreateDMServiceObject(void)
{
return new DeviceManagerServiceImpl;

62
services/implementation/src/devicestate/dm_device_state_manager.cpp
View File

@ -21,6 +21,7 @@
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "dm_crypto.h"
#include "dm_device_info.h"
#include "dm_distributed_hardware_load.h"
#include "dm_log.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
@ -110,7 +111,7 @@ void DmDeviceStateManager::OnDeviceOnline(std::string deviceId, int32_t authForm
}
}
ProcessDeviceStateChange(DEVICE_STATE_ONLINE, devInfo);
softbusConnector_->ClearPkgName();
softbusConnector_->ClearProcessInfo();
}
void DmDeviceStateManager::OnDeviceOffline(std::string deviceId)
@ -126,7 +127,7 @@ void DmDeviceStateManager::OnDeviceOffline(std::string deviceId)
devInfo = stateDeviceInfos_[deviceId];
}
ProcessDeviceStateChange(DEVICE_STATE_OFFLINE, devInfo);
softbusConnector_->ClearPkgName();
softbusConnector_->ClearProcessInfo();
}
void DmDeviceStateManager::HandleDeviceStatusChange(DmDeviceState devState, DmDeviceInfo &devInfo)
@ -139,7 +140,7 @@ void DmDeviceStateManager::HandleDeviceStatusChange(DmDeviceState devState, DmDe
SaveOnlineDeviceInfo(devInfo);
DmDistributedHardwareLoad::GetInstance().LoadDistributedHardwareFwk();
ProcessDeviceStateChange(devState, devInfo);
softbusConnector_->ClearPkgName();
softbusConnector_->ClearProcessInfo();
break;
case DEVICE_STATE_OFFLINE:
StartOffLineTimer(devInfo);
@ -150,12 +151,12 @@ void DmDeviceStateManager::HandleDeviceStatusChange(DmDeviceState devState, DmDe
softbusConnector_->EraseUdidFromMap(udid);
}
ProcessDeviceStateChange(devState, devInfo);
softbusConnector_->ClearPkgName();
softbusConnector_->ClearProcessInfo();
break;
case DEVICE_INFO_CHANGED:
ChangeDeviceInfo(devInfo);
ProcessDeviceStateChange(devState, devInfo);
softbusConnector_->ClearPkgName();
softbusConnector_->ClearProcessInfo();
break;
default:
LOGE("HandleDeviceStatusChange error, unknown device state = %{public}d", devState);
@ -165,17 +166,11 @@ void DmDeviceStateManager::HandleDeviceStatusChange(DmDeviceState devState, DmDe
void DmDeviceStateManager::ProcessDeviceStateChange(const DmDeviceState devState, const DmDeviceInfo &devInfo)
{
if (softbusConnector_ == nullptr || listener_ == nullptr) {
LOGE("ProcessDeviceStateChange failed, callback_ptr is null.");
return;
}
std::vector<std::string> pkgName = softbusConnector_->GetPkgName();
if (pkgName.size() == 0) {
listener_->OnDeviceStateChange(std::string(DM_PKG_NAME), devState, devInfo);
} else {
for (auto item : pkgName) {
listener_->OnDeviceStateChange(item, devState, devInfo);
}
CHECK_NULL_VOID(softbusConnector_);
CHECK_NULL_VOID(listener_);
std::vector<ProcessInfo> processInfoVec = softbusConnector_->GetProcessInfo();
for (const auto &item : processInfoVec) {
listener_->OnDeviceStateChange(item, devState, devInfo);
}
}
@ -201,7 +196,10 @@ void DmDeviceStateManager::OnDbReady(const std::string &pkgName, const std::stri
}
if (listener_ != nullptr) {
DmDeviceState state = DEVICE_INFO_READY;
listener_->OnDeviceStateChange(pkgName, state, saveInfo);
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
processInfo.userId = MultipleUserConnector::GetFirstForegroundUserId();
listener_->OnDeviceStateChange(processInfo, state, saveInfo);
}
}
@ -511,30 +509,14 @@ bool DmDeviceStateManager::CheckIsOnline(const std::string &udid)
void DmDeviceStateManager::HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo)
{
if (softbusConnector_ == nullptr || listener_ == nullptr) {
LOGE("failed, ptr is null.");
return;
CHECK_NULL_VOID(softbusConnector_);
CHECK_NULL_VOID(listener_);
std::vector<ProcessInfo> processInfos = softbusConnector_->GetProcessInfo();
softbusConnector_->ClearProcessInfo();
LOGI("pkgName size: %{public}zu", processInfos.size());
for (const auto &item : processInfos) {
listener_->OnDeviceScreenStateChange(item, devInfo);
}
std::vector<std::string> pkgName = softbusConnector_->GetPkgName();
LOGI("pkgName size: %{public}zu", pkgName.size());
if (pkgName.size() == 0) {
listener_->OnDeviceScreenStateChange(std::string(DM_PKG_NAME), devInfo);
} else {
for (auto item : pkgName) {
listener_->OnDeviceScreenStateChange(item, devInfo);
}
}
softbusConnector_->ClearPkgName();
}
void DmDeviceStateManager::HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId,
int32_t errcode)
{
if (listener_ == nullptr) {
LOGE("Failed, listener_ is null.");
return;
}
listener_->OnCredentialAuthStatus(std::string(DM_PKG_NAME), deviceList, deviceTypeId, errcode);
}
} // namespace DistributedHardware
} // namespace OHOS

8
services/implementation/src/discovery/dm_discovery_manager.cpp
View File

@ -160,9 +160,6 @@ void DmDiscoveryManager::OnDeviceFound(const std::string &pkgName, DmDeviceInfo
info.authForm = DmAuthForm::INVALID_TYPE;
GetAuthForm(localDeviceId, info.deviceId, filterPara.isTrusted, info.authForm);
filterPara.authForm = info.authForm;
if (filter.IsValidDevice(discoveryContext.filterOp, discoveryContext.filters, filterPara)) {
listener_->OnDeviceFound(pkgName, discoveryContext.subscribeId, info);
}
return;
}
@ -223,9 +220,6 @@ void DmDiscoveryManager::OnDeviceFound(const std::string &pkgName,
DmAuthForm authForm = DmAuthForm::INVALID_TYPE;
GetAuthForm(localDeviceId, info.deviceId, filterPara.isTrusted, authForm);
filterPara.authForm = authForm;
if (filter.IsValidDevice(discoveryContext.filterOp, discoveryContext.filters, filterPara)) {
listener_->OnDeviceFound(pkgName, discoveryContext.subscribeId, info);
}
return;
}
@ -248,7 +242,6 @@ void DmDiscoveryManager::OnDiscoveryFailed(const std::string &pkgName, int32_t s
}
}
softbusConnector_->StopDiscovery(subscribeId);
listener_->OnDiscoveryFailed(pkgName, (uint32_t)subscribeId, failedReason);
}
void DmDiscoveryManager::OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId)
@ -258,7 +251,6 @@ void DmDiscoveryManager::OnDiscoverySuccess(const std::string &pkgName, int32_t
std::lock_guard<std::mutex> autoLock(locks_);
discoveryContextMap_[pkgName].subscribeId = (uint32_t)subscribeId;
}
listener_->OnDiscoverySuccess(pkgName, subscribeId);
}
void DmDiscoveryManager::HandleDiscoveryTimeout(std::string name)

5
services/service/BUILD.gn
View File

@ -30,7 +30,6 @@ if (defined(ohos_lite)) {
"include/ipc/lite",
"include/permission/lite",
"include/pinholder",
"include/relationshipsyncmgr",
"${common_path}/include",
"${common_path}/include/ipc",
"${common_path}/include/ipc/lite",
@ -72,7 +71,6 @@ if (defined(ohos_lite)) {
"src/permission/lite/permission_manager.cpp",
"src/pinholder/pin_holder.cpp",
"src/pinholder/pin_holder_session.cpp",
"src/relationshipsyncmgr/relationship_sync_mgr.cpp",
"src/softbus/mine_softbus_listener.cpp",
"src/softbus/softbus_listener.cpp",
]
@ -180,6 +178,9 @@ if (defined(ohos_lite)) {
"src/publishcommonevent/dm_data_share_common_event.cpp",
"src/publishcommonevent/dm_package_common_event.cpp",
"src/publishcommonevent/dm_screen_common_event.cpp",
"src/relationshipsyncmgr/dm_comm_tool.cpp",
"src/relationshipsyncmgr/dm_transport.cpp",
"src/relationshipsyncmgr/dm_transport_msg.cpp",
"src/relationshipsyncmgr/relationship_sync_mgr.cpp",
"src/softbus/mine_softbus_listener.cpp",
"src/softbus/softbus_listener.cpp",

55
services/service/include/device_manager_service.h
View File

@ -35,6 +35,7 @@
#include "dm_account_common_event.h"
#include "dm_package_common_event.h"
#include "dm_screen_common_event.h"
#include "relationship_sync_mgr.h"
#if defined(SUPPORT_BLUETOOTH) || defined(SUPPORT_WIFI)
#include "dm_publish_common_event.h"
#endif // SUPPORT_BLUETOOTH SUPPORT_WIFI
@ -76,14 +77,6 @@ public:
int32_t GetUuidByNetworkId(const std::string &pkgName, const std::string &netWorkId, std::string &uuid);
int32_t StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo,
const std::string &extra);
int32_t StartDeviceDiscovery(const std::string &pkgName, const uint16_t subscribeInfo,
const std::string &filterOptions);
int32_t StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId);
int32_t PublishDeviceDiscovery(const std::string &pkgName, const DmPublishInfo &publishInfo);
int32_t UnPublishDeviceDiscovery(const std::string &pkgName, int32_t publishId);
@ -192,17 +185,22 @@ public:
bool CheckAccessControl(const DmAccessCaller &caller, const DmAccessCallee &callee);
bool CheckIsSameAccount(const DmAccessCaller &caller, const DmAccessCallee &callee);
void HandleDeviceNotTrust(const std::string &msg);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
void HandleDeviceTrustedChange(const std::string &msg);
void HandleUserIdCheckSumChange(const std::string &msg);
#endif
int32_t SetDnPolicy(const std::string &pkgName, std::map<std::string, std::string> &policy);
void ClearDiscoveryCache(const std::string &pkgName);
void ClearDiscoveryCache(const ProcessInfo &processInfo);
void HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo);
int32_t GetDeviceScreenStatus(const std::string &pkgName, const std::string &networkId,
int32_t &screenStatus);
void SubscribePackageCommonEvent();
int32_t GetNetworkIdByUdid(const std::string &pkgName, const std::string &udid, std::string &networkId);
void HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode);
void ProcessSyncUserIds(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backgroundUserIds, const std::string &remoteUdid);
int32_t SetLocalDeviceName(const std::string &localDeviceName, const std::string &localDisplayName);
void RemoveNotifyRecord(const ProcessInfo &processInfo);
private:
bool IsDMServiceImplReady();
bool IsDMServiceAdapterLoad();
@ -216,17 +214,50 @@ private:
void SendServiceUnBindBroadCast(const std::vector<std::string> &peerUdids, int32_t userId, uint64_t tokenId);
void SendAccountLogoutBroadCast(const std::vector<std::string> &peerUdids, const std::string &accountId,
const std::string &accountName, int32_t userId);
/**
* @brief send local foreground or background userids by broadcast
*
* @param peerUdids the broadcast target device udid list
* @param foregroundUserIds local foreground userids
* @param backgroundUserIds local background userids
*/
void SendUserIdsBroadCast(const std::vector<std::string> &peerUdids,
const std::vector<int32_t> &foregroundUserIds, const std::vector<int32_t> &backgroundUserIds,
bool isNeedResponse);
void SendUserRemovedBroadCast(const std::vector<std::string> &peerUdids, int32_t userId);
/**
* @brief parse dsoftbus checksum msg
*
* @param msg checksum msg
* @param networkId remote device networkid
* @param discoveryType remote device link type, wifi or ble/br
* @return int32_t 0 for success
*/
int32_t ParseCheckSumMsg(const std::string &msg, std::string &networkId, uint32_t &discoveryType);
void ProcessCheckSumByWifi(std::string networkId, std::vector<int32_t> foregroundUserIds,
std::vector<int32_t> backgroundUserIds);
void ProcessCheckSumByBT(std::string networkId, std::vector<int32_t> foregroundUserIds,
std::vector<int32_t> backgroundUserIds);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
void SubscribeAccountCommonEvent();
void AccountCommonEventCallback(int32_t userId, const std::string commonEventType);
void AccountCommonEventCallback(const std::string commonEventType, int32_t currentUserId, int32_t beforeUserId);
void SubscribeScreenLockEvent();
void ScreenCommonEventCallback(std::string commonEventType);
void ConvertUdidHashToAnoyDeviceId(DmDeviceInfo &deviceInfo);
int32_t ConvertUdidHashToAnoyDeviceId(const std::string &udidHash, std::string &anoyDeviceId);
int32_t GetUdidHashByAnoyDeviceId(const std::string &anoyDeviceId, std::string &udidHash);
void HandleAccountLogout(int32_t userId, const std::string &accountId, const std::string &accountName);
void HandleUserRemoved(int32_t preUserId);
void HandleUserRemoved(int32_t removedUserId);
/**
* @brief process the user switch
*
* @param currentUserId the user id which switched to foreground.
* @param beforeUserId the user id which switched to backend.
*/
void HandleUserSwitched(int32_t curUserId, int32_t preUserId);
void HandleUserIdsBroadCast(const std::vector<UserIdInfo> &remoteUserIdInfos,
const std::string &remoteUdid, bool isNeedResponse);
#if defined(SUPPORT_BLUETOOTH) || defined(SUPPORT_WIFI)
void SubscribePublishCommonEvent();
void QueryDependsSwitchState();

67
services/service/include/device_manager_service_listener.h
View File

@ -39,57 +39,56 @@ public:
DeviceManagerServiceListener() {};
virtual ~DeviceManagerServiceListener() {};
void OnDeviceStateChange(const std::string &pkgName, const DmDeviceState &state, const DmDeviceInfo &info) override;
void OnDeviceStateChange(const ProcessInfo &processInfo, const DmDeviceState &state,
const DmDeviceInfo &info) override;
void OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, const DmDeviceInfo &info) override;
void OnDeviceFound(const ProcessInfo &processInfo, uint16_t subscribeId, const DmDeviceInfo &info) override;
void OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, DmDeviceBasicInfo &info) override;
void OnDiscoveryFailed(const ProcessInfo &processInfo, uint16_t subscribeId, int32_t failedReason) override;
void OnDiscoveryFailed(const std::string &pkgName, uint16_t subscribeId, int32_t failedReason) override;
void OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId) override;
void OnDiscoverySuccess(const ProcessInfo &processInfo, int32_t subscribeId) override;
void OnPublishResult(const std::string &pkgName, int32_t publishId, int32_t publishResult) override;
void OnAuthResult(const std::string &pkgName, const std::string &deviceId, const std::string &token, int32_t status,
int32_t reason) override;
void OnAuthResult(const ProcessInfo &processInfo, const std::string &deviceId, const std::string &token,
int32_t status, int32_t reason) override;
void OnUiCall(std::string &pkgName, std::string &paramJson) override;
void OnUiCall(const ProcessInfo &processInfo, std::string &paramJson) override;
void OnCredentialResult(const std::string &pkgName, int32_t action, const std::string &resultInfo) override;
void OnCredentialResult(const ProcessInfo &processInfo, int32_t action, const std::string &resultInfo) override;
void OnBindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result,
void OnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, int32_t result,
int32_t status, std::string content) override;
void OnUnbindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result,
void OnUnbindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, int32_t result,
std::string content) override;
void OnPinHolderCreate(const std::string &pkgName, const std::string &deviceId, DmPinType pinType,
void OnPinHolderCreate(const ProcessInfo &processInfo, const std::string &deviceId, DmPinType pinType,
const std::string &payload) override;
void OnPinHolderDestroy(const std::string &pkgName, DmPinType pinType, const std::string &payload) override;
void OnCreateResult(const std::string &pkgName, int32_t result) override;
void OnDestroyResult(const std::string &pkgName, int32_t result) override;
void OnPinHolderEvent(const std::string &pkgName, DmPinHolderEvent event, int32_t result,
void OnPinHolderDestroy(const ProcessInfo &processInfo, DmPinType pinType, const std::string &payload) override;
void OnCreateResult(const ProcessInfo &processInfo, int32_t result) override;
void OnDestroyResult(const ProcessInfo &processInfo, int32_t result) override;
void OnPinHolderEvent(const ProcessInfo &processInfo, DmPinHolderEvent event, int32_t result,
const std::string &content) override;
void OnDeviceTrustChange(const std::string &udid, const std::string &uuid, DmAuthForm authForm) override;
void OnDeviceScreenStateChange(const std::string &pkgName, DmDeviceInfo &devInfo) override;
void OnCredentialAuthStatus(const std::string &pkgName, const std::string &deviceList, uint16_t deviceTypeId,
void OnDeviceScreenStateChange(const ProcessInfo &processInfo, DmDeviceInfo &devInfo) override;
void OnCredentialAuthStatus(const ProcessInfo &processInfo, const std::string &deviceList, uint16_t deviceTypeId,
int32_t errcode) override;
void OnAppUnintall(const std::string &pkgName) override;
void OnSinkBindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result,
void OnSinkBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, int32_t result,
int32_t status, std::string content) override;
void OnProcessRemove(const ProcessInfo &processInfo) override;
private:
void ConvertDeviceInfoToDeviceBasicInfo(const std::string &pkgName,
const DmDeviceInfo &info, DmDeviceBasicInfo &deviceBasicInfo);
void SetDeviceInfo(std::shared_ptr<IpcNotifyDeviceStateReq> pReq, const std::string &pkgName,
void SetDeviceInfo(std::shared_ptr<IpcNotifyDeviceStateReq> pReq, const ProcessInfo &processInfo,
const DmDeviceState &state, const DmDeviceInfo &deviceInfo, const DmDeviceBasicInfo &deviceBasicInfo);
void ProcessDeviceStateChange(const DmDeviceState &state, const DmDeviceInfo &info,
void ProcessDeviceStateChange(const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo);
void ProcessAppStateChange(const std::string &pkgName, const DmDeviceState &state,
void ProcessAppStateChange(const ProcessInfo &processInfo, const DmDeviceState &state,
const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo);
std::string ComposeOnlineKey(const std::string &pkgName, const std::string &devId);
void SetDeviceScreenInfo(std::shared_ptr<IpcNotifyDeviceStateReq> pReq, const std::string &pkgName,
void SetDeviceScreenInfo(std::shared_ptr<IpcNotifyDeviceStateReq> pReq, const ProcessInfo &processInfo,
const DmDeviceInfo &deviceInfo);
void RemoveOnlinePkgName(const DmDeviceInfo &info);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
@ -97,11 +96,25 @@ private:
int32_t ConvertUdidHashToAnoyDeviceId(const std::string &pkgName, const std::string &udidHash,
std::string &anoyDeviceId);
#endif
std::vector<ProcessInfo> GetWhiteListSAProcessInfo();
std::vector<ProcessInfo> GetNotifyProcessInfoByUserId(int32_t userId);
ProcessInfo DealBindProcessInfo(const ProcessInfo &processInfo);
void ProcessDeviceOnline(const std::vector<ProcessInfo> procInfoVec, const ProcessInfo &processInfo,
const DmDeviceState &state, const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo);
void ProcessDeviceOffline(const std::vector<ProcessInfo> procInfoVec, const ProcessInfo &processInfo,
const DmDeviceState &state, const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo);
void ProcessDeviceInfoChange(const std::vector<ProcessInfo> procInfoVec, const ProcessInfo &processInfo,
const DmDeviceState &state, const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo);
void ProcessAppOnline(const std::vector<ProcessInfo> procInfoVec, const ProcessInfo &processInfo,
const DmDeviceState &state, const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo);
void ProcessAppOffline(const std::vector<ProcessInfo> procInfoVec, const ProcessInfo &processInfo,
const DmDeviceState &state, const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo);
void RemoveNotExistProcess(const std::vector<ProcessInfo> &procInfoVec);
private:
#if !defined(__LITEOS_M__)
IpcServerListener ipcServerListener_;
static std::mutex alreadyOnlinePkgNameLock_;
static std::unordered_map<std::string, DmDeviceInfo> alreadyOnlinePkgName_;
static std::mutex alreadyNotifyPkgNameLock_;
static std::map<DmNotifyKey, DmDeviceInfo> alreadyOnlinePkgName_;
#endif
};
} // namespace DistributedHardware

13
services/service/include/discovery/discovery_manager.h
View File

@ -36,6 +36,11 @@ typedef struct DiscoveryContext {
std::vector<DeviceFilters> filters;
} DiscoveryContext;
typedef struct MultiUserDiscovery {
std::string pkgName;
int32_t userId;
} MultiUserDiscovery;
typedef enum {
PROXY_TRANSMISION = 0,
PROXY_HEARTBEAT = 1,
@ -84,12 +89,16 @@ private:
const std::string &searchJson);
int32_t HandleDiscoveryQueue(const std::string &pkgName, uint16_t subscribeId,
const std::map<std::string, std::string> &filterOps);
int32_t GetDeviceAclParam(const std::string &pkgName, std::string deviceId, bool &isOnline, int32_t &authForm);
int32_t GetDeviceAclParam(const std::string &pkgName, int32_t userId, std::string deviceId, bool &isOnline,
int32_t &authForm);
void ConfigDiscParam(const std::map<std::string, std::string> &discoverParam, DmSubscribeInfo *dmSubInfo);
bool CompareCapability(uint32_t capabilityType, const std::string &capabilityStr);
void OnDeviceFound(const std::string &pkgName, const uint32_t capabilityType,
const DmDeviceInfo &info, const DeviceFilterPara &filterPara);
void UpdateInfoFreq(const std::map<std::string, std::string> &discoverParam, DmSubscribeInfo &dmSubInfo);
std::string AddMultiUserIdentify(const std::string &pkgName);
std::string RemoveMultiUserIdentify(const std::string &pkgName);
void GetPkgNameAndUserId(const std::string &pkgName, std::string &callerPkgName, int32_t &userId);
private:
std::mutex locks_;
@ -104,6 +113,8 @@ private:
std::set<std::string> pkgNameSet_;
std::map<std::string, std::string> capabilityMap_;
std::mutex capabilityMapLocks_;
std::mutex multiUserDiscLocks_;
std::map<std::string, MultiUserDiscovery> multiUserDiscMap_;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
static bool isSoLoaded_;

13
services/service/include/idevice_manager_service_impl.h
View File

@ -261,20 +261,29 @@ public:
virtual int32_t CheckAccessControl(const DmAccessCaller &caller, const std::string &srcUdid,
const DmAccessCallee &callee, const std::string &sinkUdid) = 0;
virtual void HandleDeviceNotTrust(const std::string &udid) = 0;
virtual std::map<std::string, int32_t> GetDeviceIdAndBindType(int32_t userId, const std::string &accountId) = 0;
virtual std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t userId,
const std::string &accountId) = 0;
virtual void HandleAccountLogoutEvent(int32_t remoteUserId, const std::string &remoteAccountHash,
const std::string &remoteUdid) = 0;
virtual void HandleDevUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid) = 0;
virtual void HandleAppUnBindEvent(int32_t remoteUserId, const std::string &remoteUdid, int32_t tokenId) = 0;
virtual int32_t GetBindLevel(const std::string &pkgName, const std::string &localUdid,
const std::string &udid, uint64_t &tokenId) = 0;
virtual void HandleIdentAccountLogout(const std::string &udid, int32_t userId, const std::string &accountId) = 0;
virtual void HandleIdentAccountLogout(const std::string &localUdid, int32_t localUserId,
const std::string &peerUdid, int32_t peerUserId) = 0;
virtual void HandleUserRemoved(int32_t preUserId) = 0;
virtual void HandleDeviceScreenStatusChange(DmDeviceInfo &devInfo) = 0;
virtual void HandleUserSwitched(const std::map<std::string, int32_t> &deviceMap, int32_t currentUserId,
int32_t beforeUserId) = 0;
virtual int32_t StopAuthenticateDevice(const std::string &pkgName) = 0;
virtual void HandleCredentialAuthStatus(const std::string &deviceList, uint16_t deviceTypeId,
int32_t errcode) = 0;
virtual int32_t ProcessAppUnintall(const std::string &appId, int32_t accessTokenId) = 0;
virtual void HandleSyncUserIdEvent(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backroundUserIds, const std::string &remoteUdid) = 0;
virtual void HandleRemoteUserRemoved(int32_t userId, const std::string &remoteUdid) = 0;
virtual std::map<std::string, int32_t> GetDeviceIdAndBindLevel(int32_t userId) = 0;
virtual std::multimap<std::string, int32_t> GetDeviceIdAndUserId(int32_t localUserId) = 0;
};
using CreateDMServiceFuncPtr = IDeviceManagerServiceImpl *(*)(void);

42
services/service/include/idevice_manager_service_listener.h
View File

@ -32,7 +32,7 @@ public:
* @tc.desc: Device State Change of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDeviceStateChange(const std::string &pkgName, const DmDeviceState &state,
virtual void OnDeviceStateChange(const ProcessInfo &processInfo, const DmDeviceState &state,
const DmDeviceInfo &info) = 0;
/**
@ -40,28 +40,21 @@ public:
* @tc.desc: Device Found of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, const DmDeviceInfo &info) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnDeviceFound
* @tc.desc: Device Found of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDeviceFound(const std::string &pkgName, uint16_t subscribeId, DmDeviceBasicInfo &info) = 0;
virtual void OnDeviceFound(const ProcessInfo &processInfo, uint16_t subscribeId, const DmDeviceInfo &info) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnDiscoveryFailed
* @tc.desc: Discovery Failed of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDiscoveryFailed(const std::string &pkgName, uint16_t subscribeId, int32_t failedReason) = 0;
virtual void OnDiscoveryFailed(const ProcessInfo &processInfo, uint16_t subscribeId, int32_t failedReason) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnDiscoverySuccess
* @tc.desc: Discovery Success of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId) = 0;
virtual void OnDiscoverySuccess(const ProcessInfo &processInfo, int32_t subscribeId) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnPublishResult
@ -75,7 +68,7 @@ public:
* @tc.desc: Auth Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnAuthResult(const std::string &pkgName, const std::string &deviceId, const std::string &token,
virtual void OnAuthResult(const ProcessInfo &processInfo, const std::string &deviceId, const std::string &token,
int32_t status, int32_t reason) = 0;
/**
@ -83,21 +76,21 @@ public:
* @tc.desc: Fa Call of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnUiCall(std::string &pkgName, std::string &paramJson) = 0;
virtual void OnUiCall(const ProcessInfo &processInfo, std::string &paramJson) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnCredentialResult
* @tc.desc: Credential Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnCredentialResult(const std::string &pkgName, int32_t action, const std::string &resultInfo) = 0;
virtual void OnCredentialResult(const ProcessInfo &processInfo, int32_t action, const std::string &resultInfo) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnBindResult
* @tc.desc: Bind target Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnBindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result,
virtual void OnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, int32_t result,
int32_t status, std::string content) = 0;
/**
@ -105,7 +98,7 @@ public:
* @tc.desc: Unbind target Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnUnbindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result,
virtual void OnUnbindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, int32_t result,
std::string content) = 0;
/**
@ -113,7 +106,7 @@ public:
* @tc.desc: Unbind target Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnPinHolderCreate(const std::string &pkgName, const std::string &deviceId, DmPinType pinType,
virtual void OnPinHolderCreate(const ProcessInfo &processInfo, const std::string &deviceId, DmPinType pinType,
const std::string &payload) = 0;
/**
@ -121,28 +114,28 @@ public:
* @tc.desc: Unbind target Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnPinHolderDestroy(const std::string &pkgName, DmPinType pinType, const std::string &payload) = 0;
virtual void OnPinHolderDestroy(const ProcessInfo &processInfo, DmPinType pinType, const std::string &payload) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnCreateResult
* @tc.desc: Create Pin Holder Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnCreateResult(const std::string &pkgName, int32_t result) = 0;
virtual void OnCreateResult(const ProcessInfo &processInfo, int32_t result) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnDestroyResult
* @tc.desc: Destroy Pin Holder Result of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDestroyResult(const std::string &pkgName, int32_t result) = 0;
virtual void OnDestroyResult(const ProcessInfo &processInfo, int32_t result) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnPinHolderEvent
* @tc.desc: Pin Holder Event of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnPinHolderEvent(const std::string &pkgName, DmPinHolderEvent event, int32_t result,
virtual void OnPinHolderEvent(const ProcessInfo &processInfo, DmPinHolderEvent event, int32_t result,
const std::string &content) = 0;
/**
@ -157,18 +150,19 @@ public:
* @tc.desc: Device Screen State Change of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnDeviceScreenStateChange(const std::string &pkgName, DmDeviceInfo &devInfo) = 0;
virtual void OnDeviceScreenStateChange(const ProcessInfo &processInfo, DmDeviceInfo &devInfo) = 0;
/**
* @tc.name: IDeviceManagerServiceListener::OnCredentialAuthStatus
* @tc.desc: Candidate Restrict Status Change of the DeviceManager Service Listener
* @tc.type: FUNC
*/
virtual void OnCredentialAuthStatus(const std::string &pkgName, const std::string &deviceList,
virtual void OnCredentialAuthStatus(const ProcessInfo &processInfo, const std::string &deviceList,
uint16_t deviceTypeId, int32_t errcode) = 0;
virtual void OnAppUnintall(const std::string &pkgName) = 0;
virtual void OnSinkBindResult(const std::string &pkgName, const PeerTargetId &targetId, int32_t result,
virtual void OnSinkBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId, int32_t result,
int32_t status, std::string content) = 0;
virtual void OnProcessRemove(const ProcessInfo &processInfo) = 0;
};
} // namespace DistributedHardware
} // namespace OHOS

16
services/service/include/ipc/lite/ipc_server_listener.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* 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
@ -17,7 +17,9 @@
#define OHOS_DM_IPC_SERVER_LISTENER_H
#include <memory>
#include <set>
#include "dm_device_info.h"
#include "ipc_req.h"
#include "ipc_rsp.h"
#include "ipc_server_listenermgr.h"
@ -38,18 +40,12 @@ public:
int32_t SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp);
/**
* @tc.name: IpcServerListener::SendAll
* @tc.desc: Send All of the Ipc Server Listener
* @tc.type: FUNC
*/
int32_t SendAll(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp);
/**
* @tc.name: IpcServerListener::GetAllPkgName
* @tc.name: IpcServerListener::GetAllProcessInfo
* @tc.desc: Get All PkgName from stub
* @tc.type: FUNC
*/
std::vector<std::string> GetAllPkgName();
std::vector<ProcessInfo> GetAllProcessInfo();
std::set<std::string> GetSystemSA();
private:
void CommonSvcToIdentity(CommonSvcId *svcId, SvcIdentity *identity);

17
services/service/include/ipc/standard/ipc_server_listener.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022 Huawei Device Co., Ltd.
* 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
@ -17,7 +17,8 @@
#define OHOS_DM_IPC_SERVER_LISTENER_H
#include <cstdint>
#include <set>
#include "dm_device_info.h"
#include "ipc_req.h"
#include "ipc_rsp.h"
@ -37,18 +38,12 @@ public:
int32_t SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp);
/**
* @tc.name: IpcServerListener::SendAll
* @tc.desc: Send All of the Ipc Server Listener
* @tc.type: FUNC
*/
int32_t SendAll(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp);
/**
* @tc.name: IpcServerListener::GetAllPkgName
* @tc.name: IpcServerListener::GetAllProcessInfo
* @tc.desc: Get All PkgName from stub
* @tc.type: FUNC
*/
std::vector<std::string> GetAllPkgName();
std::vector<ProcessInfo> GetAllProcessInfo();
std::set<std::string> GetSystemSA();
};
} // namespace DistributedHardware
} // namespace OHOS

29
services/service/include/ipc/standard/ipc_server_stub.h
View File

@ -19,6 +19,7 @@
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <tuple>
#include <unordered_set>
#include <vector>
@ -30,6 +31,7 @@
#include "system_ability.h"
#include "account_boot_listener.h"
#include "dm_device_info.h"
#include "dm_single_instance.h"
namespace OHOS {
@ -86,14 +88,14 @@ public:
* @tc.desc: Register DeviceManager Listener of the IpcServerStub
* @tc.type: FUNC
*/
int32_t RegisterDeviceManagerListener(std::string &pkgName, sptr<IpcRemoteBroker> listener);
int32_t RegisterDeviceManagerListener(const ProcessInfo &processInfo, sptr<IpcRemoteBroker> listener);
/**
* @tc.name: IpcServerStub::UnRegisterDeviceManagerListener
* @tc.desc: UnRegister DeviceManager Listener of the IpcServerStub
* @tc.type: FUNC
*/
int32_t UnRegisterDeviceManagerListener(std::string &pkgName);
int32_t UnRegisterDeviceManagerListener(const ProcessInfo &processInfo);
/**
* @tc.name: IpcServerStub::QueryServiceState
@ -103,32 +105,25 @@ public:
ServiceRunningState QueryServiceState() const;
/**
* @tc.name: IpcServerStub::SendALL
* @tc.desc: SendALL of the IpcServerStub
* @tc.type: FUNC
*/
int32_t SendALL(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp);
/**
* @tc.name: IpcServerStub::GetAllPkgName
* @tc.name: IpcServerStub::GetAllProcessInfo
* @tc.desc: Get All PkgName from dmListener_
* @tc.type: FUNC
*/
std::vector<std::string> GetAllPkgName();
std::vector<ProcessInfo> GetAllProcessInfo();
/**
* @tc.name: IpcServerStub::GetDmListener
* @tc.desc: Get DmListener of the IpcServerStub
* @tc.type: FUNC
*/
const sptr<IpcRemoteBroker> GetDmListener(std::string pkgName) const;
const sptr<IpcRemoteBroker> GetDmListener(ProcessInfo processInfo) const;
/**
* @tc.name: IpcServerStub::GetDmListenerPkgName
* @tc.desc: Get DmListener PkgName of the IpcServerStub
* @tc.type: FUNC
*/
const std::string GetDmListenerPkgName(const wptr<IRemoteObject> &remote) const;
const ProcessInfo GetDmListenerPkgName(const wptr<IRemoteObject> &remote) const;
/**
* @tc.name: IpcServerStub::Dump
@ -150,19 +145,23 @@ public:
* @tc.type: FUNC
*/
void OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId) override;
std::set<std::string> GetSystemSA();
private:
IpcServerStub();
~IpcServerStub() 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<std::string, sptr<AppDeathRecipient>> appRecipient_;
std::map<std::string, sptr<IpcRemoteBroker>> dmListener_;
std::map<ProcessInfo, sptr<AppDeathRecipient>> appRecipient_;
std::map<ProcessInfo, sptr<IpcRemoteBroker>> dmListener_;
std::shared_ptr<AccountBootListener> accountBootListener_;
std::set<std::string> systemSA_;
};
} // namespace DistributedHardware
} // namespace OHOS

3
services/service/include/permission/lite/permission_manager.h
View File

@ -32,8 +32,9 @@ public:
int32_t GetCallerProcessName(std::string &processName);
bool CheckProcessNameValidOnAuthCode(const std::string &processName);
bool CheckProcessNameValidOnPinHolder(const std::string &processName);
bool CheckWhiteListSystemSA(const std::string &pkgName);
std::unordered_set<std::string> GetWhiteListSystemSA();
bool CheckSystemSA(const std::string &pkgName);
std::unordered_set<std::string> GetSystemSA();
bool CheckProcessNameValidOnSetDnPolicy(const std::string &processName);
};
} // namespace DistributedHardware

3
services/service/include/permission/standard/permission_manager.h
View File

@ -33,8 +33,9 @@ public:
int32_t GetCallerProcessName(std::string &processName);
bool CheckProcessNameValidOnAuthCode(const std::string &processName);
bool CheckProcessNameValidOnPinHolder(const std::string &processName);
bool CheckWhiteListSystemSA(const std::string &pkgName);
std::unordered_set<std::string> GetWhiteListSystemSA();
bool CheckSystemSA(const std::string &pkgName);
std::unordered_set<std::string> GetSystemSA();
bool CheckProcessNameValidOnSetDnPolicy(const std::string &processName);
};
} // namespace DistributedHardware

2
services/service/include/pinholder/pin_holder.h
View File

@ -76,7 +76,6 @@ private:
std::shared_ptr<PinHolderSession> session_ = nullptr;
std::shared_ptr<DmTimer> timer_ = nullptr;
std::string registerPkgName_ = "";
std::string remoteDeviceId_ = "";
std::string payload_ = "";
DmPinType pinType_ = NUMBER_PIN_CODE;
@ -86,6 +85,7 @@ private:
bool isRemoteSupported_ = false;
std::atomic<bool> isDestroy_ {false};
DestroyState destroyState_ = STATE_UNKNOW;
ProcessInfo processInfo_;
};
}
}

14
services/service/include/publishcommonevent/dm_account_common_event.h
View File

@ -33,7 +33,19 @@ namespace DistributedHardware {
using OHOS::EventFwk::CommonEventData;
using OHOS::EventFwk::CommonEventSubscriber;
using OHOS::EventFwk::CommonEventSubscribeInfo;
using AccountEventCallback = std::function<void(int32_t, std::string)>;
/**
* @brief account event callback define, fun(event_type, current userid, before userid)
* first param, accont event
* second param, the current userid
* third param, the userid before.
* first param | second param | third param
* ------------------------------------------
* COMMON_EVENT_USER_SWITCHED | switch target user id | the user id before switch
* COMMON_EVENT_USER_REMOVED | -1 | the user id removed
* COMMON_EVENT_HWID_LOGOUT | logout in witch user id | logout in witch user id
* COMMON_EVENT_HWID_LOGIN | login in witch user id | login in witch user id
*/
using AccountEventCallback = std::function<void(std::string, int32_t, int32_t)>;
class DmAccountEventSubscriber : public CommonEventSubscriber {
public:

69
services/service/include/relationshipsyncmgr/dm_comm_tool.h Normal file
View File

@ -0,0 +1,69 @@
/*
* Copyright (c) 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_COMM_TOOL_H
#define OHOS_DM_COMM_TOOL_H
#include <cstdint>
#include <string>
#include <vector>
#include <memory>
#include "dm_transport.h"
#include "dm_transport_msg.h"
#include "event_handler.h"
namespace OHOS {
namespace DistributedHardware {
// send local foreground userids msg
constexpr int32_t DM_COMM_SEND_LOCAL_USERIDS = 1;
// if receive remote device send foreground userids, response local foreground uerids
// This msg no need response
constexpr int32_t DM_COMM_RSP_LOCAL_USERIDS = 2;
class DMCommTool : public std::enable_shared_from_this<DMCommTool> {
public:
DMCommTool();
virtual ~DMCommTool() = default;
static std::shared_ptr<DMCommTool> GetInstance();
void Init();
void UnInit();
void SendUserIds(const std::string rmtNetworkId, const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backgroundUserIds);
void RspLocalFrontOrBackUserIds(const std::string rmtNetworkId, const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backgroundUserIds);
class DMCommToolEventHandler : public AppExecFwk::EventHandler {
public:
DMCommToolEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> runner,
std::shared_ptr<DMCommTool> dmCommToolPtr);
~DMCommToolEventHandler() override = default;
void ProcessEvent(const AppExecFwk::InnerEvent::Pointer &event) override;
private:
std::weak_ptr<DMCommTool> dmCommToolWPtr_;
};
std::shared_ptr<DMCommTool::DMCommToolEventHandler> GetEventHandler();
const std::shared_ptr<DMTransport> GetDMTransportPtr();
void ProcessReceiveUserIdsEvent(const std::shared_ptr<InnerCommMsg> commMsg);
void ProcessResponseUserIdsEvent(const std::shared_ptr<InnerCommMsg> commMsg);
private:
std::shared_ptr<DMTransport> dmTransportPtr_;
std::shared_ptr<DMCommTool::DMCommToolEventHandler> eventHandler_;
};
} // DistributedHardware
} // OHOS
#endif

67
services/service/include/relationshipsyncmgr/dm_transport.h Normal file
View File

@ -0,0 +1,67 @@
/*
* Copyright (c) 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_TRANSPORT_H
#define OHOS_DM_TRANSPORT_H
#include <atomic>
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include "event_handler.h"
#include "socket.h"
#include "softbus_bus_center.h"
namespace OHOS {
namespace DistributedHardware {
class DMCommTool;
class DMTransport {
public:
explicit DMTransport(std::shared_ptr<DMCommTool> dmCommToolPtr);
int32_t Init();
int32_t UnInit();
virtual ~DMTransport() = default;
// open softbus channel with remote device by networkid.
int32_t StartSocket(const std::string &rmtNetworkId);
// stop softbus channel with remote device by networkid.
int32_t StopSocket(const std::string &rmtNetworkId);
int32_t Send(const std::string &rmtNetworkId, const std::string &payload);
int32_t OnSocketOpened(int32_t socketId, const PeerSocketInfo &info);
void OnSocketClosed(int32_t socketId, ShutdownReason reason);
void OnBytesReceived(int32_t socketId, const void *data, uint32_t dataLen);
private:
int32_t CreateServerSocket();
int32_t CreateClientSocket(const std::string &remoteDevId);
bool IsDeviceSessionOpened(const std::string &remoteDevId, int32_t &socketId);
std::string GetRemoteNetworkIdBySocketId(int32_t socketId);
void ClearDeviceSocketOpened(const std::string &remoteDevId);
void HandleReceiveMessage(const int32_t socketId, const std::string &payload);
private:
std::mutex rmtSocketIdMtx_;
// record the socket id for the connection with remote devices, <remote networkId, socketId>
std::map<std::string, int32_t> remoteDevSocketIds_;
std::atomic<int32_t> localServerSocket_;
std::string localSocketName_;
std::atomic<bool> isSocketSvrCreateFlag_;
std::weak_ptr<DMCommTool> dmCommToolWPtr_;
};
} // DistributedHardware
} // OHOS
#endif

77
services/service/include/relationshipsyncmgr/dm_transport_msg.h Normal file
View File

@ -0,0 +1,77 @@
/*
* Copyright (c) 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_TRANSPORT_MSG_H
#define OHOS_DM_TRANSPORT_MSG_H
#include <cstdint>
#include <string>
#include <cJSON.h>
namespace OHOS {
namespace DistributedHardware {
const char* const FOREGROUND_USERIDS_MSG_USERIDS_KEY = "foregroundUserIds";
const char* const BACKGROUND_USERIDS_MSG_USERIDS_KEY = "backgroundUserIds";
const char* const COMM_MSG_CODE_KEY = "code";
const char* const COMM_MSG_MSG_KEY = "msg";
const char* const DSOFTBUS_NOTIFY_USERIDS_UDIDKEY = "remoteUdid";
const char* const DSOFTBUS_NOTIFY_USERIDS_USERIDKEY = "foregroundUserIds";
struct UserIdsMsg {
std::vector<uint32_t> foregroundUserIds;
std::vector<uint32_t> backgroundUserIds;
UserIdsMsg() : foregroundUserIds({}), backgroundUserIds({}) {}
UserIdsMsg(std::vector<uint32_t> foregroundUserIds, std::vector<uint32_t> backgroundUserIds)
: foregroundUserIds(foregroundUserIds), backgroundUserIds(backgroundUserIds) {}
};
void ToJson(cJSON *jsonObject, const UserIdsMsg &userIdsMsg);
void FromJson(const cJSON *jsonObject, UserIdsMsg &userIdsMsg);
struct CommMsg {
int32_t code;
std::string msg;
CommMsg() : code(-1), msg("") {}
CommMsg(int32_t code, std::string msg) : code(code), msg(msg) {}
};
void ToJson(cJSON *jsonObject, const CommMsg &commMsg);
void FromJson(const cJSON *jsonObject, CommMsg &commMsg);
std::string GetCommMsgString(const CommMsg &commMsg);
struct InnerCommMsg {
std::string remoteNetworkId;
std::shared_ptr<CommMsg> commMsg;
InnerCommMsg(std::string remoteNetworkId, std::shared_ptr<CommMsg> commMsg)
: remoteNetworkId(remoteNetworkId), commMsg(commMsg) {}
};
struct NotifyUserIds {
std::string remoteUdid;
std::vector<uint32_t> userIds;
NotifyUserIds() : remoteUdid(""), userIds({}) {}
NotifyUserIds(std::string remoteUdid, std::vector<uint32_t> userIds)
: remoteUdid(remoteUdid), userIds(userIds) {}
std::string ToString();
};
void ToJson(cJSON *jsonObject, const NotifyUserIds &userIds);
void FromJson(const cJSON *jsonObject, NotifyUserIds &userIds);
} // DistributedHardware
} // OHOS
#endif

31
services/service/include/relationshipsyncmgr/relationship_sync_mgr.h
View File

@ -22,6 +22,7 @@
#include "dm_single_instance.h"
namespace OHOS {
namespace DistributedHardware {
const uint32_t MAX_USER_ID_NUM = 5;
enum class RelationShipChangeType : uint32_t {
ACCOUNT_LOGOUT = 0,
DEVICE_UNBIND = 1,
@ -29,7 +30,18 @@ enum class RelationShipChangeType : uint32_t {
SERVICE_UNBIND = 3,
DEL_USER = 4,
APP_UNINSTALL = 5,
TYPE_MAX = 6
SYNC_USERID = 6,
TYPE_MAX = 7
};
struct UserIdInfo {
/**
* @brief true for foreground userid, false for background
*/
bool isForeground;
std::uint16_t userId;
UserIdInfo(bool isForeground, std::uint16_t userId) : isForeground(isForeground), userId(userId) {}
const std::string ToString() const;
};
struct RelationShipChangeMsg {
@ -37,9 +49,15 @@ struct RelationShipChangeMsg {
uint32_t userId;
std::string accountId;
uint64_t tokenId;
// The broadcast need send to these devices with the udids
std::vector<std::string> peerUdids;
// The broadcast from which device with the udid.
std::string peerUdid;
std::string accountName;
// true: request, false: response
bool syncUserIdFlag;
// The foreground and background user id infos
std::vector<UserIdInfo> userIdInfos;
explicit RelationShipChangeMsg();
bool ToBroadcastPayLoad(uint8_t *&msg, uint32_t &len) const;
@ -50,14 +68,20 @@ struct RelationShipChangeMsg {
void ToAccountLogoutPayLoad(uint8_t *&msg, uint32_t &len) const;
void ToDeviceUnbindPayLoad(uint8_t *&msg, uint32_t &len) const;
void ToAppUnbindPayLoad(uint8_t *&msg, uint32_t &len) const;
cJSON *ToArrayJson() const;
bool ToSyncFrontOrBackUserIdPayLoad(uint8_t *&msg, uint32_t &len) const;
void ToDelUserPayLoad(uint8_t *&msg, uint32_t &len) const;
cJSON *ToPayLoadJson() const;
bool FromAccountLogoutPayLoad(const cJSON *payloadJson);
bool FromDeviceUnbindPayLoad(const cJSON *payloadJson);
bool FromAppUnbindPayLoad(const cJSON *payloadJson);
bool FromSyncFrontOrBackUserIdPayLoad(const cJSON *payloadJson);
bool FromDelUserPayLoad(const cJSON *payloadJson);
std::string ToJson() const;
bool FromJson(const std::string &msgJson);
const std::string ToString() const;
};
class ReleationShipSyncMgr {
@ -67,6 +91,9 @@ public:
RelationShipChangeMsg ParseTrustRelationShipChange(const std::string &msgJson);
};
const std::string GetUserIdInfoList(const std::vector<UserIdInfo> &list);
void GetFrontAndBackUserIdInfos(const std::vector<UserIdInfo> &remoteUserIdInfos,
std::vector<UserIdInfo> &foregroundUserIdInfos, std::vector<UserIdInfo> &backgroundUserIdInfos);
} // DistributedHardware
} // OHOS
#endif // OHOS_RELATIONSHIP_SYNC_MGR_H

2
services/service/include/softbus/softbus_listener.h
View File

@ -56,6 +56,7 @@ public:
static void OnDeviceTrustedChange(TrustChangeType type, const char *msg, uint32_t msgLen);
static void DeviceNotTrust(const std::string &msg);
static void DeviceTrustedChange(const std::string &msg);
static void DeviceUserIdCheckSumChange(const std::string &msg);
static void OnDeviceScreenStatusChanged(NodeStatusType type, NodeStatus *status);
static void DeviceScreenStatusChange(DmDeviceInfo deviceInfo);
static void OnCredentialAuthStatus(const char *deviceList, uint32_t deviceListLen, uint16_t deviceTypeId,
@ -103,6 +104,7 @@ public:
int32_t GetDeviceScreenStatus(const char *networkId, int32_t &screenStatus);
static int32_t GetNetworkIdByUdid(const std::string &udid, std::string &networkId);
int32_t SetLocalDeviceName(const std::string &localDeviceName, const std::string &localDisplayName);
int32_t SetForegroundUserIdsToDSoftBus(const std::string &remoteUserId, const std::vector<uint32_t> &userIds);
private:
static int32_t FillDeviceInfo(const DeviceInfo &device, DmDeviceInfo &dmDevice);
int32_t InitSoftPublishLNN();

425
services/service/src/device_manager_service.cpp
View File

@ -19,6 +19,7 @@
#include <functional>
#include "app_manager.h"
#include "nlohmann/json.hpp"
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "dm_crypto.h"
@ -27,13 +28,15 @@
#include "dm_softbus_cache.h"
#include "parameter.h"
#include "permission_manager.h"
#include "relationship_sync_mgr.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "common_event_support.h"
#include "datetime_ex.h"
#include "dm_comm_tool.h"
#include "dm_transport_msg.h"
#include "iservice_registry.h"
#include "kv_adapter_manager.h"
#include "multiple_user_connector.h"
#include "relationship_sync_mgr.h"
#if defined(SUPPORT_POWER_MANAGER)
#include "power_mgr_client.h"
#endif // SUPPORT_POWER_MANAGER
@ -60,13 +63,18 @@ constexpr const char* LIB_DM_ADAPTER_NAME = "libdevicemanageradapter.z.so";
namespace OHOS {
namespace DistributedHardware {
DM_IMPLEMENT_SINGLE_INSTANCE(DeviceManagerService);
const int32_t NORMAL = 0;
const int32_t SYSTEM_BASIC = 1;
const int32_t SYSTEM_CORE = 2;
constexpr const char* ALL_PKGNAME = "";
constexpr const char* NETWORKID = "NETWORK_ID";
constexpr uint32_t INVALIED_BIND_LEVEL = 0;
constexpr uint32_t DM_IDENTICAL_ACCOUNT = 1;
namespace {
const int32_t NORMAL = 0;
const int32_t SYSTEM_BASIC = 1;
const int32_t SYSTEM_CORE = 2;
constexpr const char *ALL_PKGNAME = "";
constexpr const char *NETWORKID = "NETWORK_ID";
constexpr uint32_t INVALIED_BIND_LEVEL = 0;
constexpr uint32_t DM_IDENTICAL_ACCOUNT = 1;
const std::string USERID_CHECKSUM_NETWORKID_KEY = "networkId";
const std::string USERID_CHECKSUM_DISCOVER_TYPE_KEY = "discoverType";
constexpr uint32_t USERID_CHECKSUM_DISCOVERY_TYPE_WIFI_MASK = 0b0010;
}
DeviceManagerService::~DeviceManagerService()
{
LOGI("DeviceManagerService destructor");
@ -203,6 +211,9 @@ int32_t DeviceManagerService::InitDMServiceListener()
if (pinHolder_ == nullptr) {
pinHolder_ = std::make_shared<PinHolder>(listener_);
}
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
DMCommTool::GetInstance()->Init();
#endif
LOGI("Init success.");
return DM_OK;
}
@ -258,9 +269,9 @@ int32_t DeviceManagerService::GetTrustedDeviceList(const std::string &pkgName, c
}
return DM_OK;
}
if (onlineDeviceList.size() > 0 && IsDMServiceImplReady()) {
if (!onlineDeviceList.empty() && IsDMServiceImplReady()) {
std::unordered_map<std::string, DmAuthForm> udidMap;
if (PermissionManager::GetInstance().CheckSystemSA(pkgName)) {
if (PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName)) {
udidMap = dmServiceImpl_->GetAppTrustDeviceIdList(std::string(ALL_PKGNAME));
} else {
udidMap = dmServiceImpl_->GetAppTrustDeviceIdList(pkgName);
@ -404,72 +415,6 @@ int32_t DeviceManagerService::GetUuidByNetworkId(const std::string &pkgName, con
return SoftbusListener::GetUuidByNetworkId(netWorkId.c_str(), uuid);
}
int32_t DeviceManagerService::StartDeviceDiscovery(const std::string &pkgName, const DmSubscribeInfo &subscribeInfo,
const std::string &extra)
{
if (!PermissionManager::GetInstance().CheckPermission()) {
LOGE("The caller: %{public}s does not have permission to call StartDeviceDiscovery.", pkgName.c_str());
return ERR_DM_NO_PERMISSION;
}
LOGI("Begin for pkgName = %{public}s, extra = %{public}s",
pkgName.c_str(), extra.c_str());
if (pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
SoftbusListener::SetHostPkgName(pkgName);
std::map<std::string, std::string> discParam;
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_SUBSCRIBE_ID,
std::to_string(subscribeInfo.subscribeId)));
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_DISC_MEDIUM, std::to_string(subscribeInfo.medium)));
std::map<std::string, std::string> filterOps;
filterOps.insert(std::pair<std::string, std::string>(PARAM_KEY_FILTER_OPTIONS, extra));
CHECK_NULL_RETURN(discoveryMgr_, ERR_DM_POINT_NULL);
return discoveryMgr_->StartDiscovering(pkgName, discParam, filterOps);
}
int32_t DeviceManagerService::StartDeviceDiscovery(const std::string &pkgName, const uint16_t subscribeId,
const std::string &filterOptions)
{
if (!PermissionManager::GetInstance().CheckNewPermission()) {
LOGE("The caller: %{public}s does not have permission to call StartDeviceDiscovery.", pkgName.c_str());
return ERR_DM_NO_PERMISSION;
}
LOGI("Begin for pkgName = %{public}s, filterOptions = %{public}s, subscribeId = %{public}d",
pkgName.c_str(), filterOptions.c_str(), subscribeId);
if (pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
SoftbusListener::SetHostPkgName(pkgName);
std::map<std::string, std::string> discParam;
discParam.insert(std::pair<std::string, std::string>(PARAM_KEY_SUBSCRIBE_ID, std::to_string(subscribeId)));
std::map<std::string, std::string> filterOps;
filterOps.insert(std::pair<std::string, std::string>(PARAM_KEY_FILTER_OPTIONS, filterOptions));
CHECK_NULL_RETURN(discoveryMgr_, ERR_DM_POINT_NULL);
return discoveryMgr_->StartDiscovering(pkgName, discParam, filterOps);
}
int32_t DeviceManagerService::StopDeviceDiscovery(const std::string &pkgName, uint16_t subscribeId)
{
if (!PermissionManager::GetInstance().CheckPermission() &&
!PermissionManager::GetInstance().CheckNewPermission()) {
LOGE("The caller: %{public}s does not have permission to call StopDeviceDiscovery.", pkgName.c_str());
return ERR_DM_NO_PERMISSION;
}
LOGI("Begin for pkgName = %{public}s", pkgName.c_str());
if (pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
CHECK_NULL_RETURN(discoveryMgr_, ERR_DM_POINT_NULL);
return discoveryMgr_->StopDiscovering(pkgName, subscribeId);
}
int32_t DeviceManagerService::PublishDeviceDiscovery(const std::string &pkgName, const DmPublishInfo &publishInfo)
{
if (!PermissionManager::GetInstance().CheckPermission()) {
@ -1593,8 +1538,8 @@ void DeviceManagerService::SubscribeAccountCommonEvent()
if (accountCommonEventManager_ == nullptr) {
accountCommonEventManager_ = std::make_shared<DmAccountCommonEventManager>();
}
AccountEventCallback callback = [=](const auto &arg1, const auto &arg2) {
this->AccountCommonEventCallback(arg1, arg2);
AccountEventCallback callback = [=](const auto &eventType, const auto &currentUserId, const auto &beforeUserId) {
this->AccountCommonEventCallback(eventType, currentUserId, beforeUserId);
};
std::vector<std::string> AccountCommonEventVec;
AccountCommonEventVec.emplace_back(CommonEventSupport::COMMON_EVENT_USER_SWITCHED);
@ -1622,29 +1567,39 @@ void DeviceManagerService::SubscribeScreenLockEvent()
return;
}
void DeviceManagerService::AccountCommonEventCallback(int32_t userId, const std::string commonEventType)
void DeviceManagerService::AccountCommonEventCallback(const std::string commonEventType, int32_t currentUserId,
int32_t beforeUserId)
{
LOGI("CommonEventType: %{public}s, userId: %{public}d", commonEventType.c_str(), userId);
LOGI("CommonEventType: %{public}s, currentUserId: %{public}d, beforeUserId: %{public}d", commonEventType.c_str(),
currentUserId, beforeUserId);
if (commonEventType == CommonEventSupport::COMMON_EVENT_USER_SWITCHED) {
DMAccountInfo dmAccountInfo;
dmAccountInfo.accountId = MultipleUserConnector::GetOhosAccountId();
dmAccountInfo.accountName = MultipleUserConnector::GetOhosAccountName();
MultipleUserConnector::SetAccountInfo(userId, dmAccountInfo);
MultipleUserConnector::SetAccountInfo(currentUserId, dmAccountInfo);
if (beforeUserId == -1 || currentUserId == -1) {
return;
} else if (beforeUserId != -1 && currentUserId != -1) {
HandleUserSwitched(currentUserId, beforeUserId);
}
if (IsDMServiceAdapterLoad()) {
dmServiceImplExt_->AccountUserSwitched(userId, MultipleUserConnector::GetOhosAccountId());
dmServiceImplExt_->AccountUserSwitched(currentUserId, MultipleUserConnector::GetOhosAccountId());
}
} else if (commonEventType == CommonEventSupport::COMMON_EVENT_HWID_LOGIN) {
DMAccountInfo dmAccountInfo;
dmAccountInfo.accountId = MultipleUserConnector::GetOhosAccountId();
dmAccountInfo.accountName = MultipleUserConnector::GetOhosAccountName();
MultipleUserConnector::SetAccountInfo(userId, dmAccountInfo);
MultipleUserConnector::SetAccountInfo(currentUserId, dmAccountInfo);
} else if (commonEventType == CommonEventSupport::COMMON_EVENT_HWID_LOGOUT) {
DMAccountInfo dmAccountInfo = MultipleUserConnector::GetAccountInfoByUserId(userId);
HandleAccountLogout(userId, dmAccountInfo.accountId, dmAccountInfo.accountName);
MultipleUserConnector::DeleteAccountInfoByUserId(userId);
DMAccountInfo dmAccountInfo = MultipleUserConnector::GetAccountInfoByUserId(beforeUserId);
if (dmAccountInfo.accountId.empty()) {
return;
}
HandleAccountLogout(currentUserId, dmAccountInfo.accountId, dmAccountInfo.accountName);
MultipleUserConnector::DeleteAccountInfoByUserId(currentUserId);
} else if (commonEventType == CommonEventSupport::COMMON_EVENT_USER_REMOVED) {
HandleUserRemoved(userId);
MultipleUserConnector::DeleteAccountInfoByUserId(userId);
HandleUserRemoved(beforeUserId);
MultipleUserConnector::DeleteAccountInfoByUserId(beforeUserId);
} else {
LOGE("Invalied account common event.");
}
@ -1654,8 +1609,8 @@ void DeviceManagerService::AccountCommonEventCallback(int32_t userId, const std:
void DeviceManagerService::HandleAccountLogout(int32_t userId, const std::string &accountId,
const std::string &accountName)
{
LOGI("UserId: %{public}d, accountId: %{public}s, accountName: %{public}s", userId, GetAnonyString(accountId).c_str(),
GetAnonyString(accountName).c_str());
LOGI("UserId: %{public}d, accountId: %{public}s, accountName: %{public}s", userId,
GetAnonyString(accountId).c_str(), GetAnonyString(accountName).c_str());
if (IsDMServiceAdapterLoad()) {
dmServiceImplExt_->AccountIdLogout(userId, accountId);
}
@ -1663,14 +1618,14 @@ void DeviceManagerService::HandleAccountLogout(int32_t userId, const std::string
LOGE("Init impl failed.");
return;
}
std::map<std::string, int32_t> deviceMap;
std::multimap<std::string, int32_t> deviceMap;
std::vector<std::string> peerUdids;
deviceMap = dmServiceImpl_->GetDeviceIdAndBindType(userId, accountId);
char localUdidTemp[DEVICE_UUID_LENGTH] = {0};
GetDevUdid(localUdidTemp, DEVICE_UUID_LENGTH);
std::string localUdid = std::string(localUdidTemp);
deviceMap = dmServiceImpl_->GetDeviceIdAndUserId(userId, accountId);
for (const auto &item : deviceMap) {
if (item.second == DM_IDENTICAL_ACCOUNT) {
dmServiceImpl_->HandleIdentAccountLogout(item.first, userId, accountId);
peerUdids.emplace_back(item.first);
}
peerUdids.emplace_back(item.first);
}
if (!peerUdids.empty()) {
char accountIdHash[DM_MAX_DEVICE_ID_LEN] = {0};
@ -1680,14 +1635,78 @@ void DeviceManagerService::HandleAccountLogout(int32_t userId, const std::string
}
SendAccountLogoutBroadCast(peerUdids, std::string(accountIdHash), accountName, userId);
}
for (const auto &item : deviceMap) {
dmServiceImpl_->HandleIdentAccountLogout(localUdid, userId, item.first, item.second);
}
}
void DeviceManagerService::HandleUserRemoved(int32_t preUserId)
void DeviceManagerService::HandleUserSwitched(int32_t curUserId, int32_t preUserId)
{
LOGI("PreUserId %{public}d.", preUserId);
if (IsDMServiceImplReady()) {
dmServiceImpl_->HandleUserRemoved(preUserId);
LOGI("currentUserId: %{public}d. previousUserId: %{public}d", curUserId, preUserId);
if (!IsDMServiceImplReady()) {
LOGE("Init impl failed.");
return;
}
std::map<std::string, int32_t> curUserDeviceMap;
std::map<std::string, int32_t> preUserDeviceMap;
std::vector<std::string> peerUdids;
curUserDeviceMap = dmServiceImpl_->GetDeviceIdAndBindLevel(curUserId);
preUserDeviceMap = dmServiceImpl_->GetDeviceIdAndBindLevel(preUserId);
for (const auto &item : curUserDeviceMap) {
peerUdids.push_back(item.first);
}
for (const auto &item : preUserDeviceMap) {
if (find(peerUdids.begin(), peerUdids.end(), item.first) == peerUdids.end()) {
peerUdids.push_back(item.first);
}
}
if (!peerUdids.empty()) {
std::vector<int32_t> foregroundUserVec;
int32_t retFront = MultipleUserConnector::GetForegroundUserIds(foregroundUserVec);
std::vector<int32_t> backgroundUserVec;
int32_t retBack = MultipleUserConnector::GetBackgroundUserIds(backgroundUserVec);
if (retFront != DM_OK || retBack != DM_OK || foregroundUserVec.empty()) {
LOGE("Get userids failed, retFront: %{public}d, retBack: %{public}d, foreground user num: %{public}d",
retFront, retBack, static_cast<int32_t>(foregroundUserVec.size()));
} else {
LOGE("Send local foreground and background userids");
SendUserIdsBroadCast(peerUdids, foregroundUserVec, backgroundUserVec, true);
}
}
dmServiceImpl_->HandleUserSwitched(preUserDeviceMap, curUserId, preUserId);
}
void DeviceManagerService::HandleUserRemoved(int32_t removedUserId)
{
LOGI("PreUserId %{public}d.", removedUserId);
if (!IsDMServiceImplReady()) {
LOGE("Init impl failed.");
return;
}
std::multimap<std::string, int32_t> deviceMap = dmServiceImpl_->GetDeviceIdAndUserId(removedUserId);
std::vector<std::string> peerUdids;
for (const auto &item : deviceMap) {
if (find(peerUdids.begin(), peerUdids.end(), item.first) == peerUdids.end()) {
peerUdids.emplace_back(item.first);
}
}
if (!peerUdids.empty()) {
// Send UserId Removed broadcast
SendUserRemovedBroadCast(peerUdids, removedUserId);
}
dmServiceImpl_->HandleUserRemoved(removedUserId);
}
void DeviceManagerService::SendUserRemovedBroadCast(const std::vector<std::string> &peerUdids, int32_t userId)
{
LOGI("peerUdids: %{public}s, userId %{public}d.", GetAnonyStringList(peerUdids).c_str(), userId);
RelationShipChangeMsg msg;
msg.type = RelationShipChangeType::DEL_USER;
msg.userId = userId;
msg.peerUdids = peerUdids;
std::string broadCastMsg = ReleationShipSyncMgr::GetInstance().SyncTrustRelationShip(msg);
CHECK_NULL_VOID(softbusListener_);
softbusListener_->SendAclChangedBroadcast(broadCastMsg);
}
void DeviceManagerService::SendAccountLogoutBroadCast(const std::vector<std::string> &peerUdids,
@ -1706,6 +1725,92 @@ void DeviceManagerService::SendAccountLogoutBroadCast(const std::vector<std::str
softbusListener_->SendAclChangedBroadcast(broadCastMsg);
}
void DeviceManagerService::SendUserIdsBroadCast(const std::vector<std::string> &peerUdids,
const std::vector<int32_t> &foregroundUserIds, const std::vector<int32_t> &backgroundUserIds, bool isNeedResponse)
{
LOGI("peerUdids: %{public}s, foregroundUserIds: %{public}s, backgroundUserIds: %{public}s, isNeedRsp: %{public}s",
GetAnonyStringList(peerUdids).c_str(), GetIntegerList<int32_t>(foregroundUserIds).c_str(),
GetIntegerList<int32_t>(backgroundUserIds).c_str(), isNeedResponse ? "true" : "false");
RelationShipChangeMsg msg;
msg.type = RelationShipChangeType::SYNC_USERID;
msg.peerUdids = peerUdids;
msg.syncUserIdFlag = isNeedResponse;
for (const auto &userId : foregroundUserIds) {
msg.userIdInfos.push_back({ true, static_cast<uint16_t>(userId) });
}
for (auto const &userId : backgroundUserIds) {
msg.userIdInfos.push_back({ false, static_cast<uint16_t>(userId) });
}
std::string broadCastMsg = ReleationShipSyncMgr::GetInstance().SyncTrustRelationShip(msg);
CHECK_NULL_VOID(softbusListener_);
softbusListener_->SendAclChangedBroadcast(broadCastMsg);
}
void DeviceManagerService::HandleUserIdsBroadCast(const std::vector<UserIdInfo> &remoteUserIdInfos,
const std::string &remoteUdid, bool isNeedResponse)
{
LOGI("rmtUdid: %{public}s, rmtUserIds: %{public}s, isNeedResponse: %{public}s,",
GetAnonyString(remoteUdid).c_str(), GetUserIdInfoList(remoteUserIdInfos).c_str(),
isNeedResponse ? "true" : "false");
if (isNeedResponse) {
std::vector<int32_t> foregroundUserVec;
std::vector<int32_t> backgroundUserVec;
int32_t retFront = MultipleUserConnector::GetForegroundUserIds(foregroundUserVec);
int32_t retBack = MultipleUserConnector::GetBackgroundUserIds(backgroundUserVec);
if (retFront != DM_OK || retBack!= DM_OK || foregroundUserVec.empty()) {
LOGE("Get userid failed, retFront: %{public}d, retBack: %{public}d, frontUserNum:%{public}d,"
"backUserNum: %{public}d", retFront, retBack, static_cast<int32_t>(foregroundUserVec.size()),
static_cast<int32_t>(backgroundUserVec.size()));
} else {
LOGE("Send back local frontuserids: %{public}s, backuserids: %{public}s",
GetIntegerList(foregroundUserVec).c_str(), GetIntegerList(backgroundUserVec).c_str());
std::vector<std::string> remoteUdids = { remoteUdid };
SendUserIdsBroadCast(remoteUdids, foregroundUserVec, backgroundUserVec, false);
}
}
std::vector<UserIdInfo> foregroundUserIdInfos;
std::vector<UserIdInfo> backgroundUserIdInfos;
GetFrontAndBackUserIdInfos(remoteUserIdInfos, foregroundUserIdInfos, backgroundUserIdInfos);
if (foregroundUserIdInfos.empty()) {
LOGE("receive remote foreground userid empty");
} else {
LOGI("process foreground and background userids");
// Notify received remote foreground userids to dsoftbus
std::vector<uint32_t> foregroundUserIds;
for (const auto &u : foregroundUserIdInfos) {
foregroundUserIds.push_back(static_cast<uint32_t>(u.userId));
}
std::vector<uint32_t> backgroundUserIds;
for (const auto &u : backgroundUserIdInfos) {
backgroundUserIds.push_back(static_cast<uint32_t>(u.userId));
}
if (softbusListener_ != nullptr) {
softbusListener_->SetForegroundUserIdsToDSoftBus(remoteUdid, foregroundUserIds);
}
if (IsDMServiceImplReady()) {
dmServiceImpl_->HandleSyncUserIdEvent(foregroundUserIds, backgroundUserIds, remoteUdid);
}
}
}
void DeviceManagerService::ProcessSyncUserIds(const std::vector<uint32_t> &foregroundUserIds,
const std::vector<uint32_t> &backgroundUserIds, const std::string &remoteUdid)
{
LOGI("process sync foregroundUserIds: %{public}s, backgroundUserIds: %{public}s, remote udid: %{public}s",
GetIntegerList<uint32_t>(foregroundUserIds).c_str(), GetIntegerList<uint32_t>(backgroundUserIds).c_str(),
GetAnonyString(remoteUdid).c_str());
if (softbusListener_ != nullptr) {
softbusListener_->SetForegroundUserIdsToDSoftBus(remoteUdid, foregroundUserIds);
}
if (IsDMServiceImplReady()) {
dmServiceImpl_->HandleSyncUserIdEvent(foregroundUserIds, backgroundUserIds, remoteUdid);
}
}
void DeviceManagerService::ScreenCommonEventCallback(std::string commonEventType)
{
if (!IsDMImplSoLoaded()) {
@ -1893,7 +1998,6 @@ void DeviceManagerService::SendServiceUnBindBroadCast(const std::vector<std::str
CHECK_NULL_VOID(softbusListener_);
softbusListener_->SendAclChangedBroadcast(broadCastMsg);
}
#endif
void DeviceManagerService::HandleDeviceTrustedChange(const std::string &msg)
{
@ -1903,11 +2007,7 @@ void DeviceManagerService::HandleDeviceTrustedChange(const std::string &msg)
}
RelationShipChangeMsg relationShipMsg =
ReleationShipSyncMgr::GetInstance().ParseTrustRelationShipChange(msg);
std::string tokenIdStr = std::to_string(relationShipMsg.tokenId);
LOGI("EventType %{public}d, userId %{public}d, accountId %{public}s, tokenId %{public}s,"
"peerUdid %{public}s, accountName %{public}s.", relationShipMsg.type, relationShipMsg.userId,
GetAnonyString(relationShipMsg.accountId).c_str(), GetAnonyString(tokenIdStr).c_str(),
GetAnonyString(relationShipMsg.peerUdid).c_str(), GetAnonyString(relationShipMsg.accountName).c_str());
LOGI("Receive trust change msg: %{public}s", relationShipMsg.ToString().c_str());
if (!IsDMServiceImplReady()) {
LOGE("Imp instance not init or init failed.");
return;
@ -1924,6 +2024,13 @@ void DeviceManagerService::HandleDeviceTrustedChange(const std::string &msg)
dmServiceImpl_->HandleAppUnBindEvent(relationShipMsg.userId, relationShipMsg.peerUdid,
static_cast<int32_t>(relationShipMsg.tokenId));
break;
case RelationShipChangeType::SYNC_USERID:
HandleUserIdsBroadCast(relationShipMsg.userIdInfos,
relationShipMsg.peerUdid, relationShipMsg.syncUserIdFlag);
break;
case RelationShipChangeType::DEL_USER:
dmServiceImpl_->HandleRemoteUserRemoved(relationShipMsg.userId, relationShipMsg.peerUdid);
break;
default:
LOGI("Dm have not this event type.");
break;
@ -1931,11 +2038,104 @@ void DeviceManagerService::HandleDeviceTrustedChange(const std::string &msg)
return;
}
void DeviceManagerService::ClearDiscoveryCache(const std::string &pkgName)
int32_t DeviceManagerService::ParseCheckSumMsg(const std::string &msg, std::string &networkId, uint32_t &discoveryType)
{
LOGI("PkgName %{public}s.", pkgName.c_str());
nlohmann::json msgJsonObj = nlohmann::json::parse(msg, nullptr, false);
if (msgJsonObj.is_discarded()) {
LOGE("msg prase error.");
return ERR_DM_FAILED;
}
if (!IsString(msgJsonObj, USERID_CHECKSUM_NETWORKID_KEY)) {
LOGE("msg not contain networkId.");
return ERR_DM_FAILED;
}
if (!IsUint32(msgJsonObj, USERID_CHECKSUM_DISCOVER_TYPE_KEY)) {
LOGE("msg not contain discoveryType.");
return ERR_DM_FAILED;
}
networkId = msgJsonObj[USERID_CHECKSUM_NETWORKID_KEY].get<std::string>();
discoveryType = msgJsonObj[USERID_CHECKSUM_DISCOVER_TYPE_KEY].get<uint32_t>();
return DM_OK;
}
void DeviceManagerService::ProcessCheckSumByWifi(std::string networkId, std::vector<int32_t> foregroundUserIds,
std::vector<int32_t> backgroundUserIds)
{
// use connection to exchange foreground/background userid
LOGI("Try open softbus session to exchange foreground/background userid");
std::vector<uint32_t> foregroundUserIdsUInt;
for (auto const &u : foregroundUserIds) {
foregroundUserIdsUInt.push_back(static_cast<uint32_t>(u));
}
std::vector<uint32_t> backroundUserIdsUInt;
for (auto const &u : backgroundUserIds) {
backroundUserIdsUInt.push_back(static_cast<uint32_t>(u));
}
DMCommTool::GetInstance()->SendUserIds(networkId, foregroundUserIdsUInt, backroundUserIdsUInt);
}
void DeviceManagerService::ProcessCheckSumByBT(std::string networkId, std::vector<int32_t> foregroundUserIds,
std::vector<int32_t> backgroundUserIds)
{
LOGI("Try send brodcast to exchange foreground userid");
std::string udid = "";
SoftbusCache::GetInstance().GetUdidFromCache(networkId.c_str(), udid);
if (udid.empty()) {
LOGE("Can not get udid for networkid: %{public}s", GetAnonyString(networkId).c_str());
return;
}
std::vector<std::string> peerUdids = { udid };
if (!foregroundUserIds.empty()) {
LOGI("Send local foreground and background userids");
SendUserIdsBroadCast(peerUdids, foregroundUserIds, backgroundUserIds, true);
} else {
LOGE("local foreground userids empty");
}
}
void DeviceManagerService::HandleUserIdCheckSumChange(const std::string &msg)
{
if (msg.empty()) {
LOGE("Msg is empty.");
return;
}
LOGI("handle user trust change, msg: %{public}s", GetAnonyString(msg).c_str());
std::string remoteNetworkId = "";
uint32_t discoveryType = 0;
int32_t ret = ParseCheckSumMsg(msg, remoteNetworkId, discoveryType);
if (ret != DM_OK) {
LOGE("Parse checksum msg error");
return;
}
std::vector<int32_t> foregroundUserIds;
ret = MultipleUserConnector::GetForegroundUserIds(foregroundUserIds);
if (ret != DM_OK || foregroundUserIds.empty()) {
LOGE("Get foreground userids failed, ret: %{public}d", ret);
return;
}
std::vector<int32_t> backgroundUserIds;
ret = MultipleUserConnector::GetBackgroundUserIds(backgroundUserIds);
if (ret != DM_OK || backgroundUserIds.empty()) {
LOGI("Can not get background userids, ret: %{public}d, background userid num: %{public}d",
ret, static_cast<int32_t>(backgroundUserIds.size()));
}
if ((discoveryType & USERID_CHECKSUM_DISCOVERY_TYPE_WIFI_MASK) != 0x0) {
ProcessCheckSumByWifi(remoteNetworkId, foregroundUserIds, backgroundUserIds);
} else {
ProcessCheckSumByBT(remoteNetworkId, foregroundUserIds, backgroundUserIds);
}
}
#endif
void DeviceManagerService::ClearDiscoveryCache(const ProcessInfo &processInfo)
{
LOGI("PkgName %{public}s.", processInfo.pkgName.c_str());
CHECK_NULL_VOID(discoveryMgr_);
discoveryMgr_->ClearDiscoveryCache(pkgName);
discoveryMgr_->ClearDiscoveryCache(processInfo.pkgName);
}
void DeviceManagerService::HandleDeviceScreenStatusChange(DmDeviceInfo &deviceInfo)
@ -2024,5 +2224,12 @@ int32_t DeviceManagerService::SetLocalDeviceName(const std::string &localDeviceN
return DM_OK;
}
void DeviceManagerService::RemoveNotifyRecord(const ProcessInfo &processInfo)
{
LOGI("start");
CHECK_NULL_VOID(listener_);
listener_->OnProcessRemove(processInfo);
}
} // namespace DistributedHardware
} // namespace OHOS

542
services/service/src/device_manager_service_listener.cpp
View File

@ -13,6 +13,8 @@
* limitations under the License.
*/
#include <set>
#include "device_manager_service_listener.h"
#include "app_manager.h"
@ -39,17 +41,19 @@
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "datetime_ex.h"
#include "kv_adapter_manager.h"
#include "multiple_user_connector.h"
#endif
#include "parameter.h"
#include "permission_manager.h"
namespace OHOS {
namespace DistributedHardware {
std::mutex DeviceManagerServiceListener::alreadyOnlinePkgNameLock_;
std::unordered_map<std::string, DmDeviceInfo> DeviceManagerServiceListener::alreadyOnlinePkgName_ = {};
std::mutex DeviceManagerServiceListener::alreadyNotifyPkgNameLock_;
std::map<DmNotifyKey, DmDeviceInfo> DeviceManagerServiceListener::alreadyOnlinePkgName_ = {};
void DeviceManagerServiceListener::ConvertDeviceInfoToDeviceBasicInfo(const std::string &pkgName,
const DmDeviceInfo &info, DmDeviceBasicInfo &deviceBasicInfo)
{
(void)pkgName;
if (memset_s(&deviceBasicInfo, sizeof(DmDeviceBasicInfo), 0, sizeof(DmDeviceBasicInfo)) != DM_OK) {
LOGE("ConvertDeviceInfoToDeviceBasicInfo memset_s failed.");
return;
@ -77,21 +81,22 @@ void DeviceManagerServiceListener::ConvertDeviceInfoToDeviceBasicInfo(const std:
}
void DeviceManagerServiceListener::SetDeviceInfo(std::shared_ptr<IpcNotifyDeviceStateReq> pReq,
const std::string &pkgName, const DmDeviceState &state, const DmDeviceInfo &deviceInfo,
const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &deviceInfo,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGD("DeviceManagerServiceListener::SetDeviceInfo");
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetProcessInfo(processInfo);
pReq->SetDeviceState(state);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::string appId = "";
if (AppManager::GetInstance().GetAppIdByPkgName(pkgName, appId) != DM_OK) {
if (AppManager::GetInstance().GetAppIdByPkgName(processInfo.pkgName, appId) != DM_OK) {
pReq->SetDeviceInfo(deviceInfo);
pReq->SetDeviceBasicInfo(deviceBasicInfo);
return;
}
DmDeviceInfo dmDeviceInfo = deviceInfo;
ConvertUdidHashToAnoyAndSave(pkgName, dmDeviceInfo);
ConvertUdidHashToAnoyAndSave(processInfo.pkgName, dmDeviceInfo);
DmDeviceBasicInfo dmDeviceBasicInfo = deviceBasicInfo;
if (memset_s(dmDeviceBasicInfo.deviceId, DM_MAX_DEVICE_ID_LEN, 0, DM_MAX_DEVICE_ID_LEN) != DM_OK) {
LOGE("ConvertNodeBasicInfoToDmDevice memset failed.");
@ -110,160 +115,109 @@ void DeviceManagerServiceListener::SetDeviceInfo(std::shared_ptr<IpcNotifyDevice
pReq->SetDeviceBasicInfo(deviceBasicInfo);
}
std::string DeviceManagerServiceListener::ComposeOnlineKey(const std::string &pkgName, const std::string &devId)
{
return pkgName + "_" + devId;
}
void DeviceManagerServiceListener::ProcessDeviceStateChange(const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("In");
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
std::vector<std::string> PkgNameVec = ipcServerListener_.GetAllPkgName();
if (state == DEVICE_STATE_OFFLINE) {
RemoveOnlinePkgName(info);
for (const auto &it : PkgNameVec) {
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
if (state == DEVICE_STATE_ONLINE) {
for (const auto &it : PkgNameVec) {
std::string notifyKey = ComposeOnlineKey(it, std::string(info.deviceId));
DmDeviceState notifyState = state;
{
std::lock_guard<std::mutex> autoLock(alreadyOnlinePkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
notifyState = DmDeviceState::DEVICE_INFO_CHANGED;
} else {
alreadyOnlinePkgName_[notifyKey] = info;
}
}
SetDeviceInfo(pReq, it, notifyState, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
if (state == DEVICE_INFO_READY || state == DEVICE_INFO_CHANGED) {
for (const auto &it : PkgNameVec) {
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
}
void DeviceManagerServiceListener::ProcessAppStateChange(const std::string &pkgName, const DmDeviceState &state,
void DeviceManagerServiceListener::ProcessDeviceStateChange(const ProcessInfo &processInfo, const DmDeviceState &state,
const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("In");
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
std::unordered_set<std::string> notifyPkgnames = PermissionManager::GetInstance().GetSystemSA();
notifyPkgnames.insert(pkgName);
if (state == DEVICE_STATE_ONLINE) {
for (const auto &it : notifyPkgnames) {
std::string notifyKey = it + "_" + info.deviceId;
{
std::lock_guard<std::mutex> autoLock(alreadyOnlinePkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
continue;
}
alreadyOnlinePkgName_[notifyKey] = info;
}
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
if (state == DEVICE_STATE_OFFLINE) {
if (!SoftbusCache::GetInstance().CheckIsOnline(std::string(info.deviceId))) {
RemoveOnlinePkgName(info);
for (const auto &it : notifyPkgnames) {
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
} else {
std::string notifyKey = pkgName + "_" + info.deviceId;
{
std::lock_guard<std::mutex> autoLock(alreadyOnlinePkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
alreadyOnlinePkgName_.erase(notifyKey);
}
}
SetDeviceInfo(pReq, pkgName, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
if (state == DEVICE_INFO_READY || state == DEVICE_INFO_CHANGED) {
SetDeviceInfo(pReq, pkgName, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
std::vector<ProcessInfo> processInfoVec = GetNotifyProcessInfoByUserId(processInfo.userId);
switch (static_cast<int32_t>(state)) {
case static_cast<int32_t>(DmDeviceState::DEVICE_STATE_ONLINE):
ProcessDeviceOnline(processInfoVec, processInfo, state, info, deviceBasicInfo);
break;
case static_cast<int32_t>(DmDeviceState::DEVICE_STATE_OFFLINE):
ProcessDeviceOffline(processInfoVec, processInfo, state, info, deviceBasicInfo);
break;
case static_cast<int32_t>(DmDeviceState::DEVICE_INFO_READY):
case static_cast<int32_t>(DmDeviceState::DEVICE_INFO_CHANGED):
ProcessDeviceInfoChange(processInfoVec, processInfo, state, info, deviceBasicInfo);
break;
default:
break;
}
}
void DeviceManagerServiceListener::OnDeviceStateChange(const std::string &pkgName, const DmDeviceState &state,
void DeviceManagerServiceListener::ProcessAppStateChange(const ProcessInfo &processInfo, const DmDeviceState &state,
const DmDeviceInfo &info, const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("In");
std::vector<ProcessInfo> processInfoVec = GetWhiteListSAProcessInfo();
ProcessInfo bindProcessInfo = DealBindProcessInfo(processInfo);
processInfoVec.push_back(bindProcessInfo);
switch (static_cast<int32_t>(state)) {
case static_cast<int32_t>(DmDeviceState::DEVICE_STATE_ONLINE):
ProcessAppOnline(processInfoVec, processInfo, state, info, deviceBasicInfo);
break;
case static_cast<int32_t>(DmDeviceState::DEVICE_STATE_OFFLINE):
ProcessAppOffline(processInfoVec, processInfo, state, info, deviceBasicInfo);
break;
case static_cast<int32_t>(DmDeviceState::DEVICE_INFO_READY):
case static_cast<int32_t>(DmDeviceState::DEVICE_INFO_CHANGED):
ProcessDeviceInfoChange(processInfoVec, processInfo, state, info, deviceBasicInfo);
break;
default:
break;
}
}
void DeviceManagerServiceListener::OnDeviceStateChange(const ProcessInfo &processInfo, const DmDeviceState &state,
const DmDeviceInfo &info)
{
LOGI("OnDeviceStateChange, state = %{public}d", state);
DmDeviceBasicInfo deviceBasicInfo;
ConvertDeviceInfoToDeviceBasicInfo(pkgName, info, deviceBasicInfo);
if (pkgName == std::string(DM_PKG_NAME)) {
ProcessDeviceStateChange(state, info, deviceBasicInfo);
ConvertDeviceInfoToDeviceBasicInfo(processInfo.pkgName, info, deviceBasicInfo);
if (processInfo.pkgName == std::string(DM_PKG_NAME)) {
ProcessDeviceStateChange(processInfo, state, info, deviceBasicInfo);
} else {
ProcessAppStateChange(pkgName, state, info, deviceBasicInfo);
ProcessAppStateChange(processInfo, state, info, deviceBasicInfo);
}
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
KVAdapterManager::GetInstance().DeleteAgedEntry();
#endif
}
void DeviceManagerServiceListener::OnDeviceFound(const std::string &pkgName, uint16_t subscribeId,
void DeviceManagerServiceListener::OnDeviceFound(const ProcessInfo &processInfo, uint16_t subscribeId,
const DmDeviceInfo &info)
{
std::shared_ptr<IpcNotifyDeviceFoundReq> pReq = std::make_shared<IpcNotifyDeviceFoundReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
DmDeviceInfo deviceInfo = info;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
ConvertUdidHashToAnoyAndSave(pkgName, deviceInfo);
ConvertUdidHashToAnoyAndSave(processInfo.pkgName, deviceInfo);
#endif
DmDeviceBasicInfo devBasicInfo;
ConvertDeviceInfoToDeviceBasicInfo(pkgName, deviceInfo, devBasicInfo);
ConvertDeviceInfoToDeviceBasicInfo(processInfo.pkgName, deviceInfo, devBasicInfo);
pReq->SetDeviceBasicInfo(devBasicInfo);
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetSubscribeId(subscribeId);
pReq->SetDeviceInfo(deviceInfo);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_FOUND, pReq, pRsp);
}
void DeviceManagerServiceListener::OnDeviceFound(const std::string &pkgName, uint16_t subscribeId,
DmDeviceBasicInfo &info)
{
(void)pkgName;
(void)subscribeId;
(void)info;
}
void DeviceManagerServiceListener::OnDiscoveryFailed(const std::string &pkgName, uint16_t subscribeId,
void DeviceManagerServiceListener::OnDiscoveryFailed(const ProcessInfo &processInfo, uint16_t subscribeId,
int32_t failedReason)
{
LOGI("DeviceManagerServiceListener::OnDiscoveryFailed");
std::shared_ptr<IpcNotifyDiscoverResultReq> pReq = std::make_shared<IpcNotifyDiscoverResultReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetSubscribeId(subscribeId);
pReq->SetResult(failedReason);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_DISCOVER_FINISH, pReq, pRsp);
}
void DeviceManagerServiceListener::OnDiscoverySuccess(const std::string &pkgName, int32_t subscribeId)
void DeviceManagerServiceListener::OnDiscoverySuccess(const ProcessInfo &processInfo, int32_t subscribeId)
{
LOGI("DeviceManagerServiceListener::OnDiscoverySuccess");
std::shared_ptr<IpcNotifyDiscoverResultReq> pReq = std::make_shared<IpcNotifyDiscoverResultReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetSubscribeId((uint16_t)subscribeId);
pReq->SetResult(DM_OK);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_DISCOVER_FINISH, pReq, pRsp);
}
@ -279,7 +233,7 @@ void DeviceManagerServiceListener::OnPublishResult(const std::string &pkgName, i
ipcServerListener_.SendRequest(SERVER_PUBLISH_FINISH, pReq, pRsp);
}
void DeviceManagerServiceListener::OnAuthResult(const std::string &pkgName, const std::string &deviceId,
void DeviceManagerServiceListener::OnAuthResult(const ProcessInfo &processInfo, const std::string &deviceId,
const std::string &token, int32_t status, int32_t reason)
{
std::shared_ptr<IpcNotifyAuthResultReq> pReq = std::make_shared<IpcNotifyAuthResultReq>();
@ -290,42 +244,45 @@ void DeviceManagerServiceListener::OnAuthResult(const std::string &pkgName, cons
pReq->SetDeviceId(deviceId);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::string deviceIdTemp = "";
if (ConvertUdidHashToAnoyDeviceId(pkgName, deviceId, deviceIdTemp) == DM_OK) {
if (ConvertUdidHashToAnoyDeviceId(processInfo.pkgName, deviceId, deviceIdTemp) == DM_OK) {
pReq->SetDeviceId(deviceIdTemp);
}
#endif
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetToken(token);
pReq->SetStatus(status);
pReq->SetReason(reason);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_AUTH_RESULT, pReq, pRsp);
}
void DeviceManagerServiceListener::OnUiCall(std::string &pkgName, std::string &paramJson)
void DeviceManagerServiceListener::OnUiCall(const ProcessInfo &processInfo, std::string &paramJson)
{
LOGI("OnUiCall in");
std::shared_ptr<IpcNotifyDMFAResultReq> pReq = std::make_shared<IpcNotifyDMFAResultReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetJsonParam(paramJson);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_FA_NOTIFY, pReq, pRsp);
}
void DeviceManagerServiceListener::OnCredentialResult(const std::string &pkgName, int32_t action,
void DeviceManagerServiceListener::OnCredentialResult(const ProcessInfo &processInfo, int32_t action,
const std::string &resultInfo)
{
LOGI("call OnCredentialResult for %{public}s, action %{public}d", pkgName.c_str(), action);
LOGI("call OnCredentialResult for %{public}s, action %{public}d", processInfo.pkgName.c_str(), action);
std::shared_ptr<IpcNotifyCredentialReq> pReq = std::make_shared<IpcNotifyCredentialReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetCredentialAction(action);
pReq->SetCredentialResult(resultInfo);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_CREDENTIAL_RESULT, pReq, pRsp);
}
void DeviceManagerServiceListener::OnBindResult(const std::string &pkgName, const PeerTargetId &targetId,
void DeviceManagerServiceListener::OnBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId,
int32_t result, int32_t status, std::string content)
{
std::shared_ptr<IpcNotifyBindResultReq> pReq = std::make_shared<IpcNotifyBindResultReq>();
@ -337,20 +294,21 @@ void DeviceManagerServiceListener::OnBindResult(const std::string &pkgName, cons
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::string deviceIdTemp = "";
DmKVValue kvValue;
if (ConvertUdidHashToAnoyDeviceId(pkgName, targetId.deviceId, deviceIdTemp) == DM_OK &&
if (ConvertUdidHashToAnoyDeviceId(processInfo.pkgName, targetId.deviceId, deviceIdTemp) == DM_OK &&
KVAdapterManager::GetInstance().Get(deviceIdTemp, kvValue) == DM_OK) {
returnTargetId.deviceId = deviceIdTemp;
}
#endif
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetPeerTargetId(returnTargetId);
pReq->SetResult(result);
pReq->SetStatus(status);
pReq->SetContent(content);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(BIND_TARGET_RESULT, pReq, pRsp);
}
void DeviceManagerServiceListener::OnUnbindResult(const std::string &pkgName, const PeerTargetId &targetId,
void DeviceManagerServiceListener::OnUnbindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId,
int32_t result, std::string content)
{
std::shared_ptr<IpcNotifyBindResultReq> pReq = std::make_shared<IpcNotifyBindResultReq>();
@ -359,79 +317,85 @@ void DeviceManagerServiceListener::OnUnbindResult(const std::string &pkgName, co
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::string deviceIdTemp = "";
DmKVValue kvValue;
if (ConvertUdidHashToAnoyDeviceId(pkgName, targetId.deviceId, deviceIdTemp) == DM_OK &&
if (ConvertUdidHashToAnoyDeviceId(processInfo.pkgName, targetId.deviceId, deviceIdTemp) == DM_OK &&
KVAdapterManager::GetInstance().Get(deviceIdTemp, kvValue) == DM_OK) {
returnTargetId.deviceId = deviceIdTemp;
}
#endif
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetPeerTargetId(returnTargetId);
pReq->SetResult(result);
pReq->SetContent(content);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(UNBIND_TARGET_RESULT, pReq, pRsp);
}
void DeviceManagerServiceListener::OnPinHolderCreate(const std::string &pkgName, const std::string &deviceId,
void DeviceManagerServiceListener::OnPinHolderCreate(const ProcessInfo &processInfo, const std::string &deviceId,
DmPinType pinType, const std::string &payload)
{
LOGI("DeviceManagerServiceListener::OnPinHolderCreate : %{public}s", pkgName.c_str());
LOGI("DeviceManagerServiceListener::OnPinHolderCreate : %{public}s", processInfo.pkgName.c_str());
std::shared_ptr<IpcCreatePinHolderReq> pReq = std::make_shared<IpcCreatePinHolderReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetDeviceId(deviceId);
pReq->SetPinType(pinType);
pReq->SetPayload(payload);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_CREATE_PIN_HOLDER, pReq, pRsp);
}
void DeviceManagerServiceListener::OnPinHolderDestroy(const std::string &pkgName, DmPinType pinType,
void DeviceManagerServiceListener::OnPinHolderDestroy(const ProcessInfo &processInfo, DmPinType pinType,
const std::string &payload)
{
LOGI("DeviceManagerServiceListener::OnPinHolderDestroy : %{public}s", pkgName.c_str());
LOGI("DeviceManagerServiceListener::OnPinHolderDestroy : %{public}s", processInfo.pkgName.c_str());
std::shared_ptr<IpcDestroyPinHolderReq> pReq = std::make_shared<IpcDestroyPinHolderReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetPinType(pinType);
pReq->SetPayload(payload);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_DESTROY_PIN_HOLDER, pReq, pRsp);
}
void DeviceManagerServiceListener::OnCreateResult(const std::string &pkgName, int32_t result)
void DeviceManagerServiceListener::OnCreateResult(const ProcessInfo &processInfo, int32_t result)
{
LOGI("DeviceManagerServiceListener::OnCreateResult : %{public}d", result);
std::shared_ptr<IpcNotifyPublishResultReq> pReq = std::make_shared<IpcNotifyPublishResultReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetResult(result);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_CREATE_PIN_HOLDER_RESULT, pReq, pRsp);
}
void DeviceManagerServiceListener::OnDestroyResult(const std::string &pkgName, int32_t result)
void DeviceManagerServiceListener::OnDestroyResult(const ProcessInfo &processInfo, int32_t result)
{
LOGI("DeviceManagerServiceListener::OnDestroyResult : %{public}d", result);
std::shared_ptr<IpcNotifyPublishResultReq> pReq = std::make_shared<IpcNotifyPublishResultReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetResult(result);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_DESTROY_PIN_HOLDER_RESULT, pReq, pRsp);
}
void DeviceManagerServiceListener::OnPinHolderEvent(const std::string &pkgName, DmPinHolderEvent event,
void DeviceManagerServiceListener::OnPinHolderEvent(const ProcessInfo &processInfo, DmPinHolderEvent event,
int32_t result, const std::string &content)
{
LOGI("OnPinHolderEvent pkgName: %{public}s, event: %{public}d, result: %{public}d",
pkgName.c_str(), event, result);
processInfo.pkgName.c_str(), event, result);
std::shared_ptr<IpcNotifyPinHolderEventReq> pReq = std::make_shared<IpcNotifyPinHolderEventReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetPinHolderEvent(event);
pReq->SetResult(result);
pReq->SetContent(content);
pReq->SetProcessInfo(processInfo);
ipcServerListener_.SendRequest(SERVER_ON_PIN_HOLDER_EVENT, pReq, pRsp);
}
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
@ -485,55 +449,70 @@ void DeviceManagerServiceListener::OnDeviceTrustChange(const std::string &udid,
GetAnonyString(uuid).c_str(), authForm);
std::shared_ptr<IpcNotifyDevTrustChangeReq> pReq = std::make_shared<IpcNotifyDevTrustChangeReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
std::vector<std::string> PkgNameVec = ipcServerListener_.GetAllPkgName();
for (const auto &it : PkgNameVec) {
pReq->SetPkgName(it);
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
userId = MultipleUserConnector::GetFirstForegroundUserId();
#endif
std::vector<ProcessInfo> processInfoVec = GetNotifyProcessInfoByUserId(userId);
for (const auto &item : processInfoVec) {
pReq->SetPkgName(item.pkgName);
pReq->SetUdid(udid);
pReq->SetUuid(uuid);
pReq->SetAuthForm(authForm);
pReq->SetProcessInfo(item);
ipcServerListener_.SendRequest(REMOTE_DEVICE_TRUST_CHANGE, pReq, pRsp);
}
}
void DeviceManagerServiceListener::SetDeviceScreenInfo(std::shared_ptr<IpcNotifyDeviceStateReq> pReq,
const std::string &pkgName, const DmDeviceInfo &deviceInfo)
const ProcessInfo &processInfo, const DmDeviceInfo &deviceInfo)
{
LOGI("In");
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
pReq->SetProcessInfo(processInfo);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::string appId = "";
if (AppManager::GetInstance().GetAppIdByPkgName(pkgName, appId) != DM_OK) {
if (AppManager::GetInstance().GetAppIdByPkgName(processInfo.pkgName, appId) != DM_OK) {
pReq->SetDeviceInfo(deviceInfo);
return;
}
DmDeviceInfo dmDeviceInfo = deviceInfo;
ConvertUdidHashToAnoyAndSave(pkgName, dmDeviceInfo);
ConvertUdidHashToAnoyAndSave(processInfo.pkgName, dmDeviceInfo);
pReq->SetDeviceInfo(dmDeviceInfo);
return;
#endif
pReq->SetDeviceInfo(deviceInfo);
}
void DeviceManagerServiceListener::OnDeviceScreenStateChange(const std::string &pkgName, DmDeviceInfo &devInfo)
void DeviceManagerServiceListener::OnDeviceScreenStateChange(const ProcessInfo &processInfo, DmDeviceInfo &devInfo)
{
LOGI("In, pkgName = %{public}s", pkgName.c_str());
if (pkgName == std::string(DM_PKG_NAME)) {
LOGI("In, pkgName = %{public}s", processInfo.pkgName.c_str());
if (processInfo.pkgName == std::string(DM_PKG_NAME)) {
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
std::vector<std::string> PkgNameVec = ipcServerListener_.GetAllPkgName();
for (const auto &it : PkgNameVec) {
SetDeviceScreenInfo(pReq, it, devInfo);
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
userId = MultipleUserConnector::GetFirstForegroundUserId();
#endif
std::vector<ProcessInfo> processInfoVec =
GetNotifyProcessInfoByUserId(userId);
for (const auto &item : processInfoVec) {
SetDeviceScreenInfo(pReq, item, devInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_SCREEN_STATE_NOTIFY, pReq, pRsp);
}
} else {
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
std::unordered_set<std::string> notifyPkgnames = PermissionManager::GetInstance().GetSystemSA();
notifyPkgnames.insert(pkgName);
for (const auto &it : notifyPkgnames) {
SetDeviceScreenInfo(pReq, it, devInfo);
std::unordered_set<std::string> notifyPkgnames = PermissionManager::GetInstance().GetWhiteListSystemSA();
for (const auto &item : notifyPkgnames) {
ProcessInfo processInfo;
processInfo.pkgName = item;
processInfo.userId = 0;
SetDeviceScreenInfo(pReq, processInfo, devInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_SCREEN_STATE_NOTIFY, pReq, pRsp);
}
SetDeviceScreenInfo(pReq, processInfo, devInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_SCREEN_STATE_NOTIFY, pReq, pRsp);
}
}
@ -541,7 +520,7 @@ void DeviceManagerServiceListener::RemoveOnlinePkgName(const DmDeviceInfo &info)
{
LOGI("udidHash: %{public}s.", GetAnonyString(info.deviceId).c_str());
{
std::lock_guard<std::mutex> autoLock(alreadyOnlinePkgNameLock_);
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
for (auto item = alreadyOnlinePkgName_.begin(); item != alreadyOnlinePkgName_.end();) {
if (std::string(item->second.deviceId) == std::string(info.deviceId)) {
item = alreadyOnlinePkgName_.erase(item);
@ -552,33 +531,33 @@ void DeviceManagerServiceListener::RemoveOnlinePkgName(const DmDeviceInfo &info)
}
}
void DeviceManagerServiceListener::OnCredentialAuthStatus(const std::string &pkgName,
void DeviceManagerServiceListener::OnCredentialAuthStatus(const ProcessInfo &processInfo,
const std::string &deviceList, uint16_t deviceTypeId, int32_t errcode)
{
LOGI("In, pkgName = %{public}s", pkgName.c_str());
std::shared_ptr<IpcNotifyCredentialAuthStatusReq> pReq =
std::make_shared<IpcNotifyCredentialAuthStatusReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetDeviceList(deviceList);
pReq->SetDeviceTypeId(deviceTypeId);
pReq->SetErrCode(errcode);
if (pkgName == std::string(DM_PKG_NAME)) {
std::vector<std::string> PkgNameVec = ipcServerListener_.GetAllPkgName();
for (const auto &it : PkgNameVec) {
pReq->SetPkgName(it);
ipcServerListener_.SendRequest(SERVICE_CREDENTIAL_AUTH_STATUS_NOTIFY, pReq, pRsp);
}
} else {
pReq->SetPkgName(pkgName);
LOGI("In, pkgName = %{public}s", processInfo.pkgName.c_str());
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
userId = MultipleUserConnector::GetFirstForegroundUserId();
#endif
std::vector<ProcessInfo> processInfoVec =
GetNotifyProcessInfoByUserId(userId);
for (const auto &item : processInfoVec) {
std::shared_ptr<IpcNotifyCredentialAuthStatusReq> pReq = std::make_shared<IpcNotifyCredentialAuthStatusReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
pReq->SetDeviceList(deviceList);
pReq->SetDeviceTypeId(deviceTypeId);
pReq->SetErrCode(errcode);
pReq->SetPkgName(item.pkgName);
pReq->SetProcessInfo(item);
ipcServerListener_.SendRequest(SERVICE_CREDENTIAL_AUTH_STATUS_NOTIFY, pReq, pRsp);
}
}
void DeviceManagerServiceListener::OnAppUnintall(const std::string &pkgName)
{
std::lock_guard<std::mutex> autoLock(alreadyOnlinePkgNameLock_);
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
for (auto it = alreadyOnlinePkgName_.begin(); it != alreadyOnlinePkgName_.end();) {
if (it->first.find(pkgName) == 0) {
if (it->first.processPkgName == pkgName) {
it = alreadyOnlinePkgName_.erase(it);
} else {
++it;
@ -586,7 +565,7 @@ void DeviceManagerServiceListener::OnAppUnintall(const std::string &pkgName)
}
}
void DeviceManagerServiceListener::OnSinkBindResult(const std::string &pkgName, const PeerTargetId &targetId,
void DeviceManagerServiceListener::OnSinkBindResult(const ProcessInfo &processInfo, const PeerTargetId &targetId,
int32_t result, int32_t status, std::string content)
{
std::shared_ptr<IpcNotifyBindResultReq> pReq = std::make_shared<IpcNotifyBindResultReq>();
@ -598,17 +577,226 @@ void DeviceManagerServiceListener::OnSinkBindResult(const std::string &pkgName,
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::string deviceIdTemp = "";
DmKVValue kvValue;
if (ConvertUdidHashToAnoyDeviceId(pkgName, targetId.deviceId, deviceIdTemp) == DM_OK &&
if (ConvertUdidHashToAnoyDeviceId(processInfo.pkgName, targetId.deviceId, deviceIdTemp) == DM_OK &&
KVAdapterManager::GetInstance().Get(deviceIdTemp, kvValue) == DM_OK) {
returnTargetId.deviceId = deviceIdTemp;
}
#endif
pReq->SetPkgName(pkgName);
pReq->SetPkgName(processInfo.pkgName);
std::vector<ProcessInfo> processInfos = ipcServerListener_.GetAllProcessInfo();
ProcessInfo processInfoTemp;
for (auto item : processInfos) {
if (item.pkgName == processInfo.pkgName) {
processInfoTemp = item;
}
}
if (processInfoTemp.pkgName.empty()) {
LOGI("not register listener");
return;
}
pReq->SetProcessInfo(processInfoTemp);
pReq->SetPeerTargetId(returnTargetId);
pReq->SetResult(result);
pReq->SetStatus(status);
pReq->SetContent(content);
ipcServerListener_.SendRequest(SINK_BIND_TARGET_RESULT, pReq, pRsp);
}
std::vector<ProcessInfo> DeviceManagerServiceListener::GetWhiteListSAProcessInfo()
{
std::unordered_set<std::string> notifyPkgnames = PermissionManager::GetInstance().GetWhiteListSystemSA();
std::vector<ProcessInfo> processInfos;
for (const auto &it : notifyPkgnames) {
ProcessInfo processInfo;
processInfo.pkgName = it;
processInfo.userId = 0;
processInfos.push_back(processInfo);
}
return processInfos;
}
std::vector<ProcessInfo> DeviceManagerServiceListener::GetNotifyProcessInfoByUserId(int32_t userId)
{
std::vector<ProcessInfo> processInfos = ipcServerListener_.GetAllProcessInfo();
std::set<std::string> systemSA = ipcServerListener_.GetSystemSA();
std::vector<ProcessInfo> processInfosTemp;
for (auto item : processInfos) {
if (systemSA.find(item.pkgName) != systemSA.end()) {
item.userId = 0;
processInfosTemp.push_back(item);
} else if (item.userId == userId) {
processInfosTemp.push_back(item);
}
}
return processInfosTemp;
}
ProcessInfo DeviceManagerServiceListener::DealBindProcessInfo(const ProcessInfo &processInfo)
{
std::set<std::string> systemSA = ipcServerListener_.GetSystemSA();
if (systemSA.find(processInfo.pkgName) == systemSA.end()) {
return processInfo;
}
ProcessInfo bindProcessInfo = processInfo;
bindProcessInfo.userId = 0;
return bindProcessInfo;
}
void DeviceManagerServiceListener::ProcessDeviceOnline(const std::vector<ProcessInfo> procInfoVec,
const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("userId %{public}d, state %{public}d, udidhash %{public}s.", processInfo.userId, static_cast<int32_t>(state),
GetAnonyString(info.deviceId).c_str());
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
for (const auto &it : procInfoVec) {
DmNotifyKey notifyKey;
notifyKey.processPkgName = it.pkgName;
notifyKey.processUserId = it.userId;
notifyKey.notifyUserId = processInfo.userId;
notifyKey.udid = info.deviceId;
DmDeviceState notifyState = state;
{
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
notifyState = DmDeviceState::DEVICE_INFO_CHANGED;
} else {
alreadyOnlinePkgName_[notifyKey] = info;
}
}
SetDeviceInfo(pReq, it, notifyState, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
void DeviceManagerServiceListener::ProcessDeviceOffline(const std::vector<ProcessInfo> procInfoVec,
const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("userId %{public}d, state %{public}d, udidhash %{public}s.", processInfo.userId, static_cast<int32_t>(state),
GetAnonyString(info.deviceId).c_str());
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
RemoveNotExistProcess(procInfoVec);
if (!SoftbusCache::GetInstance().CheckIsOnline(std::string(info.deviceId))) {
RemoveOnlinePkgName(info);
}
for (const auto &it : procInfoVec) {
DmNotifyKey notifyKey;
notifyKey.processPkgName = it.pkgName;
notifyKey.processUserId = it.userId;
notifyKey.notifyUserId = processInfo.userId;
notifyKey.udid = info.deviceId;
{
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
alreadyOnlinePkgName_.erase(notifyKey);
}
}
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
void DeviceManagerServiceListener::ProcessDeviceInfoChange(const std::vector<ProcessInfo> procInfoVec,
const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("userId %{public}d, state %{public}d, udidhash %{public}s.", processInfo.userId, static_cast<int32_t>(state),
GetAnonyString(info.deviceId).c_str());
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
for (const auto &it : procInfoVec) {
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
void DeviceManagerServiceListener::ProcessAppOnline(const std::vector<ProcessInfo> procInfoVec,
const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("userId %{public}d, state %{public}d, udidhash %{public}s.", processInfo.userId, static_cast<int32_t>(state),
GetAnonyString(info.deviceId).c_str());
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
for (const auto &it : procInfoVec) {
DmNotifyKey notifyKey;
notifyKey.processPkgName = it.pkgName;
notifyKey.processUserId = it.userId;
notifyKey.notifyUserId = processInfo.userId;
notifyKey.udid = info.deviceId;
DmDeviceState notifyState = state;
{
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
notifyState = DmDeviceState::DEVICE_INFO_CHANGED;
} else {
alreadyOnlinePkgName_[notifyKey] = info;
}
}
SetDeviceInfo(pReq, it, notifyState, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
void DeviceManagerServiceListener::ProcessAppOffline(const std::vector<ProcessInfo> procInfoVec,
const ProcessInfo &processInfo, const DmDeviceState &state, const DmDeviceInfo &info,
const DmDeviceBasicInfo &deviceBasicInfo)
{
LOGI("userId %{public}d, state %{public}d, udidhash %{public}s.", processInfo.userId, static_cast<int32_t>(state),
GetAnonyString(info.deviceId).c_str());
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::make_shared<IpcNotifyDeviceStateReq>();
std::shared_ptr<IpcRsp> pRsp = std::make_shared<IpcRsp>();
if (!SoftbusCache::GetInstance().CheckIsOnline(std::string(info.deviceId))) {
RemoveOnlinePkgName(info);
for (const auto &it : procInfoVec) {
SetDeviceInfo(pReq, it, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
} else {
DmNotifyKey notifyKey;
notifyKey.processPkgName = processInfo.pkgName;
notifyKey.processUserId = processInfo.userId;
notifyKey.notifyUserId = processInfo.userId;
notifyKey.udid = info.deviceId;
{
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
if (alreadyOnlinePkgName_.find(notifyKey) != alreadyOnlinePkgName_.end()) {
alreadyOnlinePkgName_.erase(notifyKey);
}
}
SetDeviceInfo(pReq, processInfo, state, info, deviceBasicInfo);
ipcServerListener_.SendRequest(SERVER_DEVICE_STATE_NOTIFY, pReq, pRsp);
}
}
void DeviceManagerServiceListener::RemoveNotExistProcess(const std::vector<ProcessInfo> &procInfoVec)
{
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
for (auto it = alreadyOnlinePkgName_.begin(); it != alreadyOnlinePkgName_.end();) {
ProcessInfo processInfo;
processInfo.pkgName = it->first.processPkgName;
processInfo.userId = it->first.processUserId;
if (find(procInfoVec.begin(), procInfoVec.end(), processInfo) != procInfoVec.end()) {
it = alreadyOnlinePkgName_.erase(it);
} else {
++it;
}
}
}
void DeviceManagerServiceListener::OnProcessRemove(const ProcessInfo &processInfo)
{
std::lock_guard<std::mutex> autoLock(alreadyNotifyPkgNameLock_);
for (auto it = alreadyOnlinePkgName_.begin(); it != alreadyOnlinePkgName_.end();) {
if (processInfo.pkgName == it->first.processPkgName && processInfo.userId == it->first.processUserId) {
it = alreadyOnlinePkgName_.erase(it);
} else {
++it;
}
}
}
} // namespace DistributedHardware
} // namespace OHOS

134
services/service/src/discovery/discovery_manager.cpp
View File

@ -23,6 +23,9 @@
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "parameter.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "multiple_user_connector.h"
#endif
namespace OHOS {
namespace DistributedHardware {
@ -62,6 +65,7 @@ int32_t DiscoveryManager::EnableDiscoveryListener(const std::string &pkgName,
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
std::string pkgNameTemp = AddMultiUserIdentify(pkgName);
DmSubscribeInfo dmSubInfo;
dmSubInfo.subscribeId = DM_INVALID_FLAG_ID;
dmSubInfo.mode = DmDiscoverMode::DM_DISCOVER_MODE_PASSIVE;
@ -82,7 +86,7 @@ int32_t DiscoveryManager::EnableDiscoveryListener(const std::string &pkgName,
dmSubInfo.subscribeId = std::atoi((discoverParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
{
std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
pkgName2SubIdMap_[pkgName] = dmSubInfo.subscribeId;
pkgName2SubIdMap_[pkgNameTemp] = dmSubInfo.subscribeId;
}
}
if (discoverParam.find(PARAM_KEY_DISC_CAPABILITY) != discoverParam.end()) {
@ -95,7 +99,7 @@ int32_t DiscoveryManager::EnableDiscoveryListener(const std::string &pkgName,
LOGI("EnableDiscoveryListener capability = %{public}s,", std::string(dmSubInfo.capability).c_str());
{
std::lock_guard<std::mutex> capLock(capabilityMapLocks_);
capabilityMap_[pkgName] = std::string(dmSubInfo.capability);
capabilityMap_[pkgNameTemp] = std::string(dmSubInfo.capability);
}
int32_t ret = softbusListener_->RefreshSoftbusLNN(DM_PKG_NAME, dmSubInfo, LNN_DISC_CAPABILITY);
@ -103,7 +107,7 @@ int32_t DiscoveryManager::EnableDiscoveryListener(const std::string &pkgName,
LOGE("EnableDiscoveryListener failed, softbus refresh lnn ret: %{public}d.", ret);
return ret;
}
softbusListener_->RegisterSoftbusLnnOpsCbk(pkgName, shared_from_this());
softbusListener_->RegisterSoftbusLnnOpsCbk(pkgNameTemp, shared_from_this());
return DM_OK;
}
@ -115,7 +119,7 @@ int32_t DiscoveryManager::DisableDiscoveryListener(const std::string &pkgName,
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
std::string pkgNameTemp = RemoveMultiUserIdentify(pkgName);
if (extraParam.find(PARAM_KEY_META_TYPE) != extraParam.end()) {
LOGI("DisableDiscoveryListener, input MetaType = %{public}s",
(extraParam.find(PARAM_KEY_META_TYPE)->second).c_str());
@ -125,16 +129,16 @@ int32_t DiscoveryManager::DisableDiscoveryListener(const std::string &pkgName,
subscribeId = std::atoi((extraParam.find(PARAM_KEY_SUBSCRIBE_ID)->second).c_str());
{
std::lock_guard<std::mutex> autoLock(subIdMapLocks_);
pkgName2SubIdMap_.erase(pkgName);
pkgName2SubIdMap_.erase(pkgNameTemp);
}
}
{
std::lock_guard<std::mutex> capLock(capabilityMapLocks_);
if (capabilityMap_.find(pkgName) != capabilityMap_.end()) {
capabilityMap_.erase(pkgName);
if (capabilityMap_.find(pkgNameTemp) != capabilityMap_.end()) {
capabilityMap_.erase(pkgNameTemp);
}
}
softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgName);
softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgNameTemp);
return softbusListener_->StopRefreshSoftbusLNN(subscribeId);
}
@ -146,9 +150,10 @@ int32_t DiscoveryManager::StartDiscovering(const std::string &pkgName,
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
std::string pkgNameTemp = AddMultiUserIdentify(pkgName);
DmSubscribeInfo dmSubInfo;
ConfigDiscParam(discoverParam, &dmSubInfo);
if (HandleDiscoveryQueue(pkgName, dmSubInfo.subscribeId, filterOptions) != DM_OK) {
if (HandleDiscoveryQueue(pkgNameTemp, dmSubInfo.subscribeId, filterOptions) != DM_OK) {
return ERR_DM_DISCOVERY_REPEATED;
}
@ -158,17 +163,17 @@ int32_t DiscoveryManager::StartDiscovering(const std::string &pkgName,
isStandardMetaNode = (metaType == MetaNodeType::PROXY_TRANSMISION);
}
softbusListener_->RegisterSoftbusLnnOpsCbk(pkgName, shared_from_this());
StartDiscoveryTimer(pkgName);
softbusListener_->RegisterSoftbusLnnOpsCbk(pkgNameTemp, shared_from_this());
StartDiscoveryTimer(pkgNameTemp);
auto it = filterOptions.find(PARAM_KEY_FILTER_OPTIONS);
nlohmann::json jsonObject = nlohmann::json::parse(it->second, nullptr, false);
if (!jsonObject.is_discarded() && jsonObject.contains(TYPE_MINE)) {
return StartDiscovering4MineLibary(pkgName, dmSubInfo, it->second);
return StartDiscovering4MineLibary(pkgNameTemp, dmSubInfo, it->second);
}
int32_t ret = isStandardMetaNode ? StartDiscoveringNoMetaType(pkgName, dmSubInfo, discoverParam) :
StartDiscovering4MetaType(pkgName, dmSubInfo, discoverParam);
int32_t ret = isStandardMetaNode ? StartDiscoveringNoMetaType(pkgNameTemp, dmSubInfo, discoverParam) :
StartDiscovering4MetaType(pkgNameTemp, dmSubInfo, discoverParam);
if (ret != DM_OK) {
LOGE("StartDiscovering for meta node process failed, ret = %{public}d", ret);
return ret;
@ -307,24 +312,25 @@ int32_t DiscoveryManager::StopDiscovering(const std::string &pkgName, uint16_t s
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
std::string pkgNameTemp = RemoveMultiUserIdentify(pkgName);
{
std::lock_guard<std::mutex> autoLock(locks_);
if (pkgNameSet_.find(pkgName) != pkgNameSet_.end()) {
pkgNameSet_.erase(pkgName);
if (pkgNameSet_.find(pkgNameTemp) != pkgNameSet_.end()) {
pkgNameSet_.erase(pkgNameTemp);
}
if (discoveryContextMap_.find(pkgName) != discoveryContextMap_.end()) {
discoveryContextMap_.erase(pkgName);
timer_->DeleteTimer(pkgName);
if (discoveryContextMap_.find(pkgNameTemp) != discoveryContextMap_.end()) {
discoveryContextMap_.erase(pkgNameTemp);
timer_->DeleteTimer(pkgNameTemp);
}
}
{
std::lock_guard<std::mutex> capLock(capabilityMapLocks_);
if (capabilityMap_.find(pkgName) != capabilityMap_.end()) {
capabilityMap_.erase(pkgName);
if (capabilityMap_.find(pkgNameTemp) != capabilityMap_.end()) {
capabilityMap_.erase(pkgNameTemp);
}
}
softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgName);
softbusListener_->UnRegisterSoftbusLnnOpsCbk(pkgNameTemp);
#if (defined(MINE_HARMONY))
return mineSoftbusListener_->StopRefreshSoftbusLNN(subscribeId);
#else
@ -334,12 +340,16 @@ int32_t DiscoveryManager::StopDiscovering(const std::string &pkgName, uint16_t s
void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const DmDeviceInfo &info, bool isOnline)
{
int32_t userId = -1;
std::string callerPkgName = "";
GetPkgNameAndUserId(pkgName, callerPkgName, userId);
DeviceFilterPara filterPara;
filterPara.isOnline = false;
filterPara.range = info.range;
filterPara.deviceType = info.deviceTypeId;
std::string deviceIdHash = static_cast<std::string>(info.deviceId);
if (isOnline && GetDeviceAclParam(pkgName, deviceIdHash, filterPara.isOnline, filterPara.authForm) != DM_OK) {
if (isOnline && GetDeviceAclParam(callerPkgName, userId, deviceIdHash, filterPara.isOnline,
filterPara.authForm) != DM_OK) {
LOGE("The found device get online param failed.");
}
nlohmann::json jsonObject = nlohmann::json::parse(info.extraData, nullptr, false);
@ -358,6 +368,12 @@ void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const DmDeviceI
void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const uint32_t capabilityType,
const DmDeviceInfo &info, const DeviceFilterPara &filterPara)
{
int32_t userId = -1;
std::string callerPkgName = "";
GetPkgNameAndUserId(pkgName, callerPkgName, userId);
ProcessInfo processInfo;
processInfo.userId = userId;
processInfo.pkgName = callerPkgName;
bool isIndiscoveryContextMap = false;
DiscoveryContext discoveryContext;
{
@ -382,7 +398,7 @@ void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const uint32_t
subscribeId = pkgName2SubIdMap_[pkgName];
}
LOGD("OnDeviceFound, pkgName = %{public}s, cabability = %{public}d", pkgName.c_str(), capabilityType);
listener_->OnDeviceFound(pkgName, subscribeId, info);
listener_->OnDeviceFound(processInfo, subscribeId, info);
return;
}
DiscoveryFilter filter;
@ -395,7 +411,7 @@ void DiscoveryManager::OnDeviceFound(const std::string &pkgName, const uint32_t
}
}
LOGD("OnDeviceFound, pkgName = %{public}s, cabability = %{public}d", pkgName.c_str(), capabilityType);
listener_->OnDeviceFound(pkgName, discoveryContext.subscribeId, info);
listener_->OnDeviceFound(processInfo, discoveryContext.subscribeId, info);
}
}
@ -413,6 +429,12 @@ bool DiscoveryManager::CompareCapability(uint32_t capabilityType, const std::str
void DiscoveryManager::OnDiscoveringResult(const std::string &pkgName, int32_t subscribeId, int32_t result)
{
LOGI("DiscoveryManager::OnDiscoveringResult, subscribeId = %{public}d, result = %{public}d.", subscribeId, result);
int32_t userId = -1;
std::string callerPkgName = "";
GetPkgNameAndUserId(pkgName, callerPkgName, userId);
ProcessInfo processInfo;
processInfo.userId = userId;
processInfo.pkgName = callerPkgName;
if (pkgName.empty() || (listener_ == nullptr)) {
LOGE("DiscoveryManager::OnDiscoveringResult failed, IDeviceManagerServiceListener is null.");
return;
@ -420,7 +442,7 @@ void DiscoveryManager::OnDiscoveringResult(const std::string &pkgName, int32_t s
if (result == 0) {
std::lock_guard<std::mutex> autoLock(locks_);
discoveryContextMap_[pkgName].subscribeId = (uint32_t)subscribeId;
listener_->OnDiscoverySuccess(pkgName, subscribeId);
listener_->OnDiscoverySuccess(processInfo, subscribeId);
return;
}
{
@ -439,7 +461,7 @@ void DiscoveryManager::OnDiscoveringResult(const std::string &pkgName, int32_t s
capabilityMap_.erase(pkgName);
}
}
listener_->OnDiscoveryFailed(pkgName, (uint32_t)subscribeId, result);
listener_->OnDiscoveryFailed(processInfo, (uint32_t)subscribeId, result);
softbusListener_->StopRefreshSoftbusLNN(subscribeId);
}
@ -513,7 +535,7 @@ void DiscoveryManager::UpdateInfoFreq(
}
}
int32_t DiscoveryManager::GetDeviceAclParam(const std::string &pkgName, std::string deviceId,
int32_t DiscoveryManager::GetDeviceAclParam(const std::string &pkgName, int32_t userId, std::string deviceId,
bool &isOnline, int32_t &authForm)
{
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
@ -524,6 +546,7 @@ int32_t DiscoveryManager::GetDeviceAclParam(const std::string &pkgName, std::str
discoveryInfo.pkgname = pkgName;
discoveryInfo.localDeviceId = requestDeviceId;
discoveryInfo.remoteDeviceIdHash = deviceId;
discoveryInfo.userId = userId;
if (DiscoveryManager::IsCommonDependencyReady() && DiscoveryManager::GetCommonDependencyObj() != nullptr) {
if (DiscoveryManager::GetCommonDependencyObj()->GetDeviceAclParam(discoveryInfo, isOnline, authForm) != DM_OK) {
LOGE("GetDeviceAclParam failed.");
@ -619,5 +642,60 @@ void DiscoveryManager::ClearDiscoveryCache(const std::string &pkgName)
CHECK_NULL_VOID(timer_);
timer_->DeleteTimer(pkgName);
}
std::string DiscoveryManager::AddMultiUserIdentify(const std::string &pkgName)
{
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
MultipleUserConnector::GetCallerUserId(userId);
#endif
if (userId == -1) {
LOGE("Get caller userId failed.");
return pkgName;
}
MultiUserDiscovery multiUserDisc;
multiUserDisc.pkgName = pkgName;
multiUserDisc.userId = userId;
std::string pkgNameTemp = ComposeStr(pkgName, userId);
{
std::lock_guard<std::mutex> autoLock(multiUserDiscLocks_);
multiUserDiscMap_[pkgNameTemp] = multiUserDisc;
}
return pkgNameTemp;
}
std::string DiscoveryManager::RemoveMultiUserIdentify(const std::string &pkgName)
{
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
MultipleUserConnector::GetCallerUserId(userId);
#endif
if (userId == -1) {
LOGE("Get caller userId failed.");
return pkgName;
}
std::string pkgNameTemp = ComposeStr(pkgName, userId);
{
std::lock_guard<std::mutex> autoLock(multiUserDiscLocks_);
if (multiUserDiscMap_.find(pkgNameTemp) != multiUserDiscMap_.end()) {
multiUserDiscMap_.erase(pkgNameTemp);
}
}
return pkgNameTemp;
}
void DiscoveryManager::GetPkgNameAndUserId(const std::string &pkgName, std::string &callerPkgName,
int32_t &userId)
{
{
std::lock_guard<std::mutex> autoLock(multiUserDiscLocks_);
if (multiUserDiscMap_.find(pkgName) != multiUserDiscMap_.end()) {
callerPkgName = GetCallerPkgName(multiUserDiscMap_[pkgName].pkgName);
userId = multiUserDiscMap_[pkgName].userId;
return;
}
}
LOGE("find failed.");
}
} // namespace DistributedHardware
} // namespace OHOS

21
services/service/src/ipc/lite/ipc_cmd_parser.cpp
View File

@ -159,27 +159,6 @@ ON_IPC_SERVER_CMD(GET_TRUST_DEVICE_LIST, IpcIo &req, IpcIo &reply)
}
}
ON_IPC_SERVER_CMD(START_DEVICE_DISCOVERY, IpcIo &req, IpcIo &reply)
{
LOGI("StartDeviceDiscovery service listener.");
std::string pkgName = (const char *)ReadString(&req, nullptr);
std::string extra = (const char *)ReadString(&req, nullptr);
uint16_t subscribeId = 0;
ReadUint16(&req, &subscribeId);
int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, extra);
WriteInt32(&reply, ret);
}
ON_IPC_SERVER_CMD(STOP_DEVICE_DISCOVER, IpcIo &req, IpcIo &reply)
{
LOGI("StopDeviceDiscovery service listener.");
std::string pkgName = (const char *)ReadString(&req, nullptr);
uint16_t subscribeId = 0;
ReadUint16(&req, &subscribeId);
int32_t ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
WriteInt32(&reply, ret);
}
ON_IPC_SERVER_CMD(REQUEST_CREDENTIAL, IpcIo &req, IpcIo &reply)
{
LOGI("request credential service listener.");

37
services/service/src/ipc/lite/ipc_server_listener.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* 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
@ -66,40 +66,21 @@ int32_t IpcServerListener::SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq>
return DM_OK;
}
int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp)
std::vector<ProcessInfo> IpcServerListener::GetAllProcessInfo()
{
std::vector<ProcessInfo> processInfoVec;
const std::map<std::string, CommonSvcId> &listenerMap = IpcServerListenermgr::GetInstance().GetAllListeners();
for (const auto &kv : listenerMap) {
SvcIdentity svc;
IpcIo io;
uint8_t data[MAX_DM_IPC_LEN] = {0};
std::string pkgName = kv.first;
req->SetPkgName(pkgName);
if (IpcCmdRegister::GetInstance().SetRequest(cmdCode, req, io, data, MAX_DM_IPC_LEN) != DM_OK) {
LOGE("SetRequest failed cmdCode:%{public}d", cmdCode);
continue;
}
CommonSvcId svcId = kv.second;
CommonSvcToIdentity(&svcId, &svc);
MessageOption option;
MessageOptionInit(&option);
option.flags = TF_OP_ASYNC;
if (::SendRequest(svc, cmdCode, &io, nullptr, option, nullptr) != DM_OK) {
LOGI("SendRequest failed cmdCode:%{public}d", cmdCode);
}
ProcessInfo processInfo;
processInfo.pkgName = kv.first;
processInfoVec.push_back(processInfo);
}
return DM_OK;
return processInfoVec;
}
std::vector<std::string> IpcServerListener::GetAllPkgName()
std::set<std::string> IpcServerListener::GetSystemSA()
{
std::vector<std::string> pkgNameList;
const std::map<std::string, CommonSvcId> &listenerMap = IpcServerListenermgr::GetInstance().GetAllListeners();
for (const auto &kv : listenerMap) {
pkgNameList.push_back(kv.first);
}
return pkgNameList;
return {};
}
} // namespace DistributedHardware
} // namespace OHOS

59
services/service/src/ipc/standard/ipc_cmd_parser.cpp
View File

@ -43,9 +43,12 @@
#include "ipc_notify_pin_holder_event_req.h"
#include "ipc_server_client_proxy.h"
#include "ipc_server_stub.h"
#include "multiple_user_connector.h"
#include "nlohmann/json.hpp"
#include "parameter.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "multiple_user_connector.h"
#endif
namespace OHOS {
namespace DistributedHardware {
const unsigned int XCOLLIE_TIMEOUT_S = 5;
@ -419,8 +422,11 @@ ON_IPC_CMD(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel
OHOS::HiviewDFX::XCollie::GetInstance().CancelTimer(id);
return ERR_DM_POINT_NULL;
}
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
MultipleUserConnector::GetCallerUserId(processInfo.userId);
DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName);
int32_t result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, callback);
int32_t result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(processInfo, callback);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
OHOS::HiviewDFX::XCollie::GetInstance().CancelTimer(id);
@ -433,8 +439,11 @@ ON_IPC_CMD(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel
ON_IPC_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
MultipleUserConnector::GetCallerUserId(processInfo.userId);
DeviceManagerService::GetInstance().UnRegisterCallerAppId(pkgName);
int32_t result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
int32_t result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(processInfo);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
@ -442,48 +451,6 @@ ON_IPC_CMD(UNREGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParce
return DM_OK;
}
ON_IPC_CMD(START_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string extra = data.ReadString();
DmSubscribeInfo *subscribeInfo =
static_cast<DmSubscribeInfo *>(const_cast<void *>(data.ReadRawData(sizeof(DmSubscribeInfo))));
int32_t result = ERR_DM_POINT_NULL;
if (subscribeInfo != nullptr) {
result = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, *subscribeInfo, extra);
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(START_DEVICE_DISCOVERY, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string filterOption = data.ReadString();
uint16_t subscribeId = data.ReadUint16();
int32_t result = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOption);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(STOP_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
uint16_t subscribeId = data.ReadUint16();
int32_t result = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(PUBLISH_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply)
{

27
services/service/src/ipc/standard/ipc_server_listener.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* 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
@ -31,36 +31,27 @@ int32_t IpcServerListener::SendRequest(int32_t cmdCode, std::shared_ptr<IpcReq>
LOGE("IpcServerListener::SendRequest cmdCode param invalid!");
return ERR_DM_UNSUPPORTED_IPC_COMMAND;
}
std::string pkgName = req->GetPkgName();
if (pkgName.empty()) {
ProcessInfo processInfo = req->GetProcessInfo();
if (processInfo.pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
sptr<IpcRemoteBroker> listener = IpcServerStub::GetInstance().GetDmListener(pkgName);
sptr<IpcRemoteBroker> listener = IpcServerStub::GetInstance().GetDmListener(processInfo);
if (listener == nullptr) {
LOGI("cannot get listener for package:%{public}s.", pkgName.c_str());
LOGI("cannot get listener for package:%{public}s.", processInfo.pkgName.c_str());
return ERR_DM_POINT_NULL;
}
return listener->SendCmd(cmdCode, req, rsp);
}
std::vector<std::string> IpcServerListener::GetAllPkgName()
std::vector<ProcessInfo> IpcServerListener::GetAllProcessInfo()
{
return IpcServerStub::GetInstance().GetAllPkgName();
return IpcServerStub::GetInstance().GetAllProcessInfo();
}
int32_t IpcServerListener::SendAll(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp)
std::set<std::string> IpcServerListener::GetSystemSA()
{
if (cmdCode < 0 || cmdCode >= IPC_MSG_BUTT) {
LOGE("IpcServerListener::SendAll cmdCode param invalid!");
return ERR_DM_UNSUPPORTED_IPC_COMMAND;
}
int32_t ret = IpcServerStub::GetInstance().SendALL(cmdCode, req, rsp);
if (ret != DM_OK) {
LOGE("IpcServerListener::SendAll failed!");
return ret;
}
return DM_OK;
return IpcServerStub::GetInstance().GetSystemSA();
}
} // namespace DistributedHardware
} // namespace OHOS

114
services/service/src/ipc/standard/ipc_server_stub.cpp
View File

@ -33,8 +33,10 @@
#include "device_manager_ipc_interface_code.h"
#include "device_manager_service.h"
#include "dm_constants.h"
#include "dm_device_info.h"
#include "dm_log.h"
#include "multiple_user_connector.h"
#include "permission_manager.h"
namespace OHOS {
namespace DistributedHardware {
@ -213,31 +215,30 @@ ServiceRunningState IpcServerStub::QueryServiceState() const
return state_;
}
int32_t IpcServerStub::RegisterDeviceManagerListener(std::string &pkgName, sptr<IpcRemoteBroker> listener)
int32_t IpcServerStub::RegisterDeviceManagerListener(const ProcessInfo &processInfo, sptr<IpcRemoteBroker> listener)
{
if (pkgName.empty() || listener == nullptr) {
if (processInfo.pkgName.empty() || listener == nullptr) {
LOGE("RegisterDeviceManagerListener error: input parameter invalid.");
return ERR_DM_POINT_NULL;
}
LOGI("Register device manager listener for package name: %{public}s", pkgName.c_str());
LOGI("Register device manager listener for package name: %{public}s", processInfo.pkgName.c_str());
std::lock_guard<std::mutex> autoLock(listenerLock_);
auto iter = dmListener_.find(pkgName);
auto iter = dmListener_.find(processInfo);
if (iter != dmListener_.end()) {
LOGI("Listener already exists");
auto recipientIter = appRecipient_.find(pkgName);
auto recipientIter = appRecipient_.find(processInfo);
if (recipientIter == appRecipient_.end()) {
LOGI("AppRecipient not exists");
dmListener_.erase(pkgName);
dmListener_.erase(processInfo);
} else {
auto listener = iter->second;
auto appRecipient = recipientIter->second;
listener->AsObject()->RemoveDeathRecipient(appRecipient);
appRecipient_.erase(pkgName);
dmListener_.erase(pkgName);
appRecipient_.erase(processInfo);
dmListener_.erase(processInfo);
}
}
sptr<AppDeathRecipient> appRecipient = sptr<AppDeathRecipient>(new AppDeathRecipient());
if (!listener->AsObject()->AddDeathRecipient(appRecipient)) {
LOGE("AddDeathRecipient Failed");
@ -246,90 +247,77 @@ int32_t IpcServerStub::RegisterDeviceManagerListener(std::string &pkgName, sptr<
LOGE("dmListener_ or appRecipient_ size exceed the limit!");
return ERR_DM_FAILED;
}
dmListener_[pkgName] = listener;
appRecipient_[pkgName] = appRecipient;
LOGD("Register listener complete.");
dmListener_[processInfo] = listener;
appRecipient_[processInfo] = appRecipient;
AddSystemSA(processInfo.pkgName);
LOGI("Register listener complete.");
return DM_OK;
}
int32_t IpcServerStub::UnRegisterDeviceManagerListener(std::string &pkgName)
int32_t IpcServerStub::UnRegisterDeviceManagerListener(const ProcessInfo &processInfo)
{
if (pkgName.empty()) {
if (processInfo.pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("IpcServerStub::UnRegisterDeviceManagerListener In, pkgName: %{public}s", pkgName.c_str());
LOGI("IpcServerStub::UnRegisterDeviceManagerListener In, pkgName: %{public}s", processInfo.pkgName.c_str());
std::lock_guard<std::mutex> autoLock(listenerLock_);
auto listenerIter = dmListener_.find(pkgName);
auto listenerIter = dmListener_.find(processInfo);
if (listenerIter == dmListener_.end()) {
LOGI("Listener not exists");
return DM_OK;
}
auto recipientIter = appRecipient_.find(pkgName);
auto recipientIter = appRecipient_.find(processInfo);
if (recipientIter == appRecipient_.end()) {
LOGI("AppRecipient not exists");
dmListener_.erase(pkgName);
dmListener_.erase(processInfo);
return DM_OK;
}
auto listener = listenerIter->second;
auto appRecipient = recipientIter->second;
listener->AsObject()->RemoveDeathRecipient(appRecipient);
appRecipient_.erase(pkgName);
dmListener_.erase(pkgName);
appRecipient_.erase(processInfo);
dmListener_.erase(processInfo);
RemoveSystemSA(processInfo.pkgName);
DeviceManagerService::GetInstance().RemoveNotifyRecord(processInfo);
return DM_OK;
}
int32_t IpcServerStub::SendALL(int32_t cmdCode, std::shared_ptr<IpcReq> req, std::shared_ptr<IpcRsp> rsp)
std::vector<ProcessInfo> IpcServerStub::GetAllProcessInfo()
{
std::vector<ProcessInfo> processInfoVec;
std::lock_guard<std::mutex> autoLock(listenerLock_);
for (const auto &iter : dmListener_) {
auto pkgName = iter.first;
auto listener = iter.second;
req->SetPkgName(pkgName);
if (listener == nullptr) {
LOGE("IpcServerStub::SendALL, listener is nullptr, pkgName : %{public}s.", pkgName.c_str());
continue;
}
listener->SendCmd(cmdCode, req, rsp);
processInfoVec.push_back(iter.first);
}
return DM_OK;
return processInfoVec;
}
std::vector<std::string> IpcServerStub::GetAllPkgName()
const sptr<IpcRemoteBroker> IpcServerStub::GetDmListener(ProcessInfo processInfo) const
{
std::vector<std::string> PkgNameVec;
std::lock_guard<std::mutex> autoLock(listenerLock_);
for (const auto &iter : dmListener_) {
PkgNameVec.push_back(iter.first);
}
return PkgNameVec;
}
const sptr<IpcRemoteBroker> IpcServerStub::GetDmListener(std::string pkgName) const
{
if (pkgName.empty()) {
if (processInfo.pkgName.empty()) {
LOGE("Invalid parameter, pkgName is empty.");
return nullptr;
}
std::lock_guard<std::mutex> autoLock(listenerLock_);
auto iter = dmListener_.find(pkgName);
auto iter = dmListener_.find(processInfo);
if (iter == dmListener_.end()) {
return nullptr;
}
return iter->second;
}
const std::string IpcServerStub::GetDmListenerPkgName(const wptr<IRemoteObject> &remote) const
const ProcessInfo IpcServerStub::GetDmListenerPkgName(const wptr<IRemoteObject> &remote) const
{
std::string pkgName = "";
ProcessInfo processInfo;
std::lock_guard<std::mutex> autoLock(listenerLock_);
for (const auto &iter : dmListener_) {
if ((iter.second)->AsObject() == remote.promote()) {
pkgName = iter.first;
processInfo = iter.first;
break;
}
}
return pkgName;
return processInfo;
}
int32_t IpcServerStub::Dump(int32_t fd, const std::vector<std::u16string>& args)
@ -356,10 +344,34 @@ int32_t IpcServerStub::Dump(int32_t fd, const std::vector<std::u16string>& args)
void AppDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
{
std::string pkgName = IpcServerStub::GetInstance().GetDmListenerPkgName(remote);
LOGI("AppDeathRecipient: OnRemoteDied for %{public}s", pkgName.c_str());
IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
DeviceManagerService::GetInstance().ClearDiscoveryCache(pkgName);
ProcessInfo processInfo = IpcServerStub::GetInstance().GetDmListenerPkgName(remote);
LOGI("AppDeathRecipient: OnRemoteDied for %{public}s", processInfo.pkgName.c_str());
IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(processInfo);
DeviceManagerService::GetInstance().ClearDiscoveryCache(processInfo);
}
void IpcServerStub::AddSystemSA(const std::string &pkgName)
{
if (PermissionManager::GetInstance().CheckSystemSA(pkgName)) {
systemSA_.insert(pkgName);
}
}
void IpcServerStub::RemoveSystemSA(const std::string &pkgName)
{
if (PermissionManager::GetInstance().CheckSystemSA(pkgName) || systemSA_.find(pkgName) != systemSA_.end()) {
systemSA_.erase(pkgName);
}
}
std::set<std::string> IpcServerStub::GetSystemSA()
{
std::lock_guard<std::mutex> autoLock(listenerLock_);
std::set<std::string> systemSA;
for (const auto &item : systemSA_) {
systemSA.insert(item);
}
return systemSA;
}
} // namespace DistributedHardware
} // namespace OHOS

10
services/service/src/permission/lite/permission_manager.cpp
View File

@ -54,17 +54,23 @@ bool PermissionManager::CheckProcessNameValidOnPinHolder(const std::string &proc
return true;
}
bool PermissionManager::CheckSystemSA(const std::string &pkgName)
bool PermissionManager::CheckWhiteListSystemSA(const std::string &pkgName)
{
(void)pkgName;
return true;
}
std::unordered_set<std::string> PermissionManager::GetSystemSA()
std::unordered_set<std::string> PermissionManager::GetWhiteListSystemSA()
{
return std::unordered_set<std::string>{};
}
bool PermissionManager::CheckSystemSA(const std::string &pkgName)
{
(void)pkgName;
return true;
}
bool PermissionManager::CheckProcessNameValidOnSetDnPolicy(const std::string &processName)
{
(void)processName;

18
services/service/src/permission/standard/permission_manager.cpp
View File

@ -197,7 +197,7 @@ bool PermissionManager::CheckProcessNameValidOnPinHolder(const std::string &proc
return false;
}
bool PermissionManager::CheckSystemSA(const std::string &pkgName)
bool PermissionManager::CheckWhiteListSystemSA(const std::string &pkgName)
{
for (uint16_t index = 0; index < SYSTEM_SA_WHITE_LIST_NUM; ++index) {
std::string tmp(systemSaWhiteList[index]);
@ -208,7 +208,7 @@ bool PermissionManager::CheckSystemSA(const std::string &pkgName)
return false;
}
std::unordered_set<std::string> PermissionManager::GetSystemSA()
std::unordered_set<std::string> PermissionManager::GetWhiteListSystemSA()
{
std::unordered_set<std::string> systemSA;
for (uint16_t index = 0; index < SYSTEM_SA_WHITE_LIST_NUM; ++index) {
@ -218,6 +218,20 @@ std::unordered_set<std::string> PermissionManager::GetSystemSA()
return systemSA;
}
bool PermissionManager::CheckSystemSA(const std::string &pkgName)
{
AccessTokenID tokenCaller = IPCSkeleton::GetCallingTokenID();
if (tokenCaller == 0) {
LOGE("CheckMonitorPermission GetCallingTokenID error.");
return false;
}
ATokenTypeEnum tokenTypeFlag = AccessTokenKit::GetTokenTypeFlag(tokenCaller);
if (tokenTypeFlag == ATokenTypeEnum::TOKEN_NATIVE) {
return true;
}
return false;
}
bool PermissionManager::CheckProcessNameValidOnSetDnPolicy(const std::string &processName)
{
if (processName.empty()) {

88
services/service/src/pinholder/pin_holder.cpp
View File

@ -20,6 +20,9 @@
#include "dm_log.h"
#include "dm_radar_helper.h"
#include "nlohmann/json.hpp"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "multiple_user_connector.h"
#endif
namespace OHOS {
namespace DistributedHardware {
@ -84,7 +87,12 @@ int32_t PinHolder::RegisterPinHolderCallback(const std::string &pkgName)
LOGE("RegisterPinHolderCallback session is nullptr.");
return ERR_DM_FAILED;
}
registerPkgName_ = pkgName;
int32_t userId = -1;
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
MultipleUserConnector::GetCallerUserId(userId);
#endif
processInfo_.userId = userId;
processInfo_.pkgName = pkgName;
session_->RegisterSessionCallback(shared_from_this());
return DM_OK;
}
@ -93,7 +101,7 @@ int32_t PinHolder::CreatePinHolder(const std::string &pkgName,
const PeerTargetId &targetId, DmPinType pinType, const std::string &payload)
{
LOGI("CreatePinHolder.");
if (registerPkgName_.empty() || registerPkgName_ != pkgName) {
if (processInfo_.pkgName.empty() || processInfo_.pkgName != pkgName) {
LOGE("CreatePinHolder pkgName: %{public}s is not register callback.", pkgName.c_str());
return ERR_DM_FAILED;
}
@ -120,11 +128,11 @@ int32_t PinHolder::CreatePinHolder(const std::string &pkgName,
int32_t stageRes =
sessionId_ > 0 ? static_cast<int32_t>(StageRes::STAGE_SUCC) : static_cast<int32_t>(StageRes::STAGE_FAIL);
DmRadarHelper::GetInstance().ReportCreatePinHolder(
registerPkgName_, sessionId_, targetId.deviceId, sessionId_, stageRes);
processInfo_.pkgName, sessionId_, targetId.deviceId, sessionId_, stageRes);
if (sessionId_ < 0) {
LOGE("[SOFTBUS]open session error, sessionId: %{public}d.", sessionId_);
listener_->OnCreateResult(registerPkgName_, sessionId_);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE_RESULT,
listener_->OnCreateResult(processInfo_, sessionId_);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE_RESULT,
sessionId_, "");
sessionId_ = SESSION_ID_INVALID;
return sessionId_;
@ -142,7 +150,7 @@ int32_t PinHolder::DestroyPinHolder(const std::string &pkgName, const PeerTarget
LOGE("DestroyPinHolder listener or session is nullptr.");
return ERR_DM_FAILED;
}
if (registerPkgName_.empty() || pkgName != registerPkgName_) {
if (processInfo_.pkgName.empty() || pkgName != processInfo_.pkgName) {
LOGE("DestroyPinHolder pkgName: %{public}s is not register callback.", pkgName.c_str());
return ERR_DM_FAILED;
}
@ -153,8 +161,8 @@ int32_t PinHolder::DestroyPinHolder(const std::string &pkgName, const PeerTarget
}
if (sessionId_ == SESSION_ID_INVALID) {
LOGI("DestroyPinHolder session already destroy.");
listener_->OnDestroyResult(registerPkgName_, ret);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY_RESULT, ret, "");
listener_->OnDestroyResult(processInfo_, ret);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY_RESULT, ret, "");
return ret;
}
if (sourceState_ != SOURCE_CREATE) {
@ -175,11 +183,11 @@ int32_t PinHolder::DestroyPinHolder(const std::string &pkgName, const PeerTarget
ret = session_->SendData(sessionId_, message);
int32_t stageRes =
ret == DM_OK ? static_cast<int32_t>(StageRes::STAGE_SUCC) : static_cast<int32_t>(StageRes::STAGE_FAIL);
DmRadarHelper::GetInstance().ReportDestroyPinHolder(registerPkgName_, targetId.deviceId, ret, stageRes);
DmRadarHelper::GetInstance().ReportDestroyPinHolder(processInfo_.pkgName, targetId.deviceId, ret, stageRes);
if (ret != DM_OK) {
LOGE("[SOFTBUS]SendBytes failed, ret: %{public}d.", ret);
listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY_RESULT, ERR_DM_FAILED, "");
listener_->OnDestroyResult(processInfo_, ERR_DM_FAILED);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY_RESULT, ERR_DM_FAILED, "");
return ret;
}
return ret;
@ -211,8 +219,8 @@ int32_t PinHolder::CreateGeneratePinHolderMsg()
std::string("CreateGeneratePinHolderMsg"), "");
if (ret != DM_OK) {
LOGE("[SOFTBUS]SendBytes failed, ret: %{public}d.", ret);
listener_->OnCreateResult(registerPkgName_, ret);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE_RESULT, ret, "");
listener_->OnCreateResult(processInfo_, ret);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE_RESULT, ret, "");
return ret;
}
return ret;
@ -244,7 +252,7 @@ void PinHolder::ProcessCloseSessionMsg(const std::string &message)
sessionId_ = SESSION_ID_INVALID;
sourceState_ = SOURCE_INIT;
sinkState_ = SINK_INIT;
listener_->OnCreateResult(registerPkgName_, ERR_DM_CREATE_PIN_HOLDER_BUSY);
listener_->OnCreateResult(processInfo_, ERR_DM_CREATE_PIN_HOLDER_BUSY);
}
void PinHolder::ProcessCreateMsg(const std::string &message)
@ -275,13 +283,13 @@ void PinHolder::ProcessCreateMsg(const std::string &message)
jsonObj[TAG_REPLY] = REPLY_SUCCESS;
sinkState_ = SINK_CREATE;
sourceState_ = SOURCE_CREATE;
listener_->OnPinHolderCreate(registerPkgName_, remoteDeviceId_, pinType, payload);
listener_->OnPinHolderCreate(processInfo_, remoteDeviceId_, pinType, payload);
nlohmann::json jsonContent;
jsonContent[TAG_PIN_TYPE] = pinType;
jsonContent[TAG_PAYLOAD] = payload;
jsonContent[TAG_REMOTE_DEVICE_ID] = remoteDeviceId_;
std::string content = jsonContent.dump();
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE, DM_OK, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE, DM_OK, content);
}
jsonObj[TAG_DM_VERSION] = "";
@ -312,14 +320,14 @@ void PinHolder::ProcessCreateRespMsg(const std::string &message)
return;
}
if (reply == REPLY_SUCCESS) {
listener_->OnCreateResult(registerPkgName_, DM_OK);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE_RESULT, DM_OK, "");
listener_->OnCreateResult(processInfo_, DM_OK);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE_RESULT, DM_OK, "");
sourceState_ = SOURCE_CREATE;
sinkState_ = SINK_CREATE;
} else {
LOGE("ProcessCreateRespMsg remote state is wrong.");
listener_->OnCreateResult(registerPkgName_, ERR_DM_FAILED);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE_RESULT, ERR_DM_FAILED, "");
listener_->OnCreateResult(processInfo_, ERR_DM_FAILED);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE_RESULT, ERR_DM_FAILED, "");
session_->CloseSessionServer(sessionId_);
sessionId_ = SESSION_ID_INVALID;
destroyState_ = STATE_REMOTE_WRONG;
@ -356,12 +364,12 @@ void PinHolder::ProcessDestroyMsg(const std::string &message)
sinkState_ = SINK_INIT;
sourceState_ = SOURCE_INIT;
if (!isDestroy_.load()) {
listener_->OnPinHolderDestroy(registerPkgName_, pinType, payload);
listener_->OnPinHolderDestroy(processInfo_, pinType, payload);
nlohmann::json jsonContent;
jsonContent[TAG_PIN_TYPE] = pinType;
jsonContent[TAG_PAYLOAD] = payload;
std::string content = jsonContent.dump();
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY, DM_OK, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY, DM_OK, content);
isDestroy_.store(true);
}
}
@ -386,12 +394,12 @@ void PinHolder::CloseSession(const std::string &name)
jsonObj[DM_CONNECTION_DISCONNECTED] = true;
std::string payload = jsonObj.dump();
if (listener_ != nullptr && !isDestroy_.load()) {
listener_->OnPinHolderDestroy(registerPkgName_, pinType_, payload);
listener_->OnPinHolderDestroy(processInfo_, pinType_, payload);
nlohmann::json jsonContent;
jsonContent[TAG_PIN_TYPE] = pinType_;
jsonContent[TAG_PAYLOAD] = payload;
std::string content = jsonContent.dump();
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY, ERR_DM_TIME_OUT, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY, ERR_DM_TIME_OUT, content);
isDestroy_.store(true);
}
session_->CloseSessionServer(sessionId_);
@ -421,15 +429,15 @@ void PinHolder::ProcessDestroyResMsg(const std::string &message)
return;
}
if (reply == REPLY_SUCCESS) {
listener_->OnDestroyResult(registerPkgName_, DM_OK);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY_RESULT, DM_OK, "");
listener_->OnDestroyResult(processInfo_, DM_OK);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY_RESULT, DM_OK, "");
sourceState_ = SOURCE_INIT;
sinkState_ = SINK_INIT;
timer_->DeleteAll();
} else {
LOGE("ProcessDestroyResMsg remote state is wrong.");
listener_->OnDestroyResult(registerPkgName_, ERR_DM_FAILED);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY_RESULT, ERR_DM_FAILED, "");
listener_->OnDestroyResult(processInfo_, ERR_DM_FAILED);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY_RESULT, ERR_DM_FAILED, "");
sinkState_ = SINK_INIT;
sourceState_ = SOURCE_INIT;
}
@ -451,7 +459,7 @@ void PinHolder::OnDataReceived(int32_t sessionId, std::string message)
int32_t ret = session_->SendData(sessionId, msg);
if (ret != DM_OK) {
LOGE("[SOFTBUS] SendBytes failed. ret: %{public}d.", ret);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE_RESULT, ERR_DM_FAILED, "");
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE_RESULT, ERR_DM_FAILED, "");
}
return;
}
@ -530,8 +538,8 @@ void PinHolder::OnSessionOpened(int32_t sessionId, int32_t sessionSide, int32_t
LOGE("[SOFTBUS]onSesssionOpened failed. sessionId: %{public}d.", sessionId);
sessionId_ = SESSION_ID_INVALID;
if (listener_ != nullptr) {
listener_->OnCreateResult(registerPkgName_, result);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::CREATE_RESULT, result, "");
listener_->OnCreateResult(processInfo_, result);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::CREATE_RESULT, result, "");
}
return;
}
@ -551,17 +559,17 @@ void PinHolder::OnSessionClosed(int32_t sessionId)
jsonObj[DM_CONNECTION_DISCONNECTED] = true;
std::string payload = jsonObj.dump();
if (listener_ != nullptr && !isDestroy_.load()) {
listener_->OnPinHolderDestroy(registerPkgName_, pinType_, payload);
listener_->OnPinHolderDestroy(processInfo_, pinType_, payload);
nlohmann::json jsonContent;
jsonContent[TAG_PIN_TYPE] = pinType_;
jsonContent[TAG_PAYLOAD] = payload;
std::string content = jsonContent.dump();
if (destroyState_ == STATE_UNKNOW) {
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY, sessionId, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY, sessionId, content);
} else if (destroyState_ == STATE_REMOTE_WRONG) {
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY, ERR_DM_FAILED, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY, ERR_DM_FAILED, content);
} else if (destroyState_ == STATE_TIME_OUT) {
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::DESTROY, ERR_DM_TIME_OUT, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::DESTROY, ERR_DM_TIME_OUT, content);
}
isDestroy_.store(true);
}
@ -587,7 +595,7 @@ int32_t PinHolder::NotifyPinHolderEvent(const std::string &pkgName, const std::s
LOGE("NotifyPinHolderEvent listener or session is nullptr.");
return ERR_DM_FAILED;
}
if (registerPkgName_.empty() || pkgName != registerPkgName_ || event.empty()) {
if (processInfo_.pkgName.empty() || pkgName != processInfo_.pkgName || event.empty()) {
LOGE("NotifyPinHolderEvent pkgName: %{public}s is not register callback.", pkgName.c_str());
return ERR_DM_FAILED;
}
@ -619,7 +627,7 @@ int32_t PinHolder::NotifyPinHolderEvent(const std::string &pkgName, const std::s
int32_t ret = session_->SendData(sessionId_, message);
if (ret != DM_OK) {
LOGE("[SOFTBUS]SendBytes failed, ret: %{public}d.", ret);
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::PIN_TYPE_CHANGE_RESULT, ERR_DM_FAILED, "");
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::PIN_TYPE_CHANGE_RESULT, ERR_DM_FAILED, "");
return ERR_DM_FAILED;
}
return ret;
@ -651,7 +659,7 @@ void PinHolder::ProcessChangeMsg(const std::string &message)
nlohmann::json jsonContent;
jsonContent[TAG_PIN_TYPE] = pinType;
std::string content = jsonContent.dump();
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::PIN_TYPE_CHANGE, DM_OK, content);
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::PIN_TYPE_CHANGE, DM_OK, content);
timer_->DeleteAll();
timer_->StartTimer(std::string(PINHOLDER_CREATE_TIMEOUT_TASK), PIN_HOLDER_SESSION_CREATE_TIMEOUT,
[this] (std::string name) {
@ -685,10 +693,10 @@ void PinHolder::ProcessChangeRespMsg(const std::string &message)
return;
}
if (reply == REPLY_SUCCESS) {
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::PIN_TYPE_CHANGE_RESULT, DM_OK, "");
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::PIN_TYPE_CHANGE_RESULT, DM_OK, "");
} else {
LOGE("ProcessChangeRespMsg remote state is wrong.");
listener_->OnPinHolderEvent(registerPkgName_, DmPinHolderEvent::PIN_TYPE_CHANGE_RESULT, ERR_DM_FAILED, "");
listener_->OnPinHolderEvent(processInfo_, DmPinHolderEvent::PIN_TYPE_CHANGE_RESULT, ERR_DM_FAILED, "");
}
}
} // namespace DistributedHardware

32
services/service/src/publishcommonevent/dm_account_common_event.cpp
View File

@ -136,27 +136,35 @@ bool DmAccountCommonEventManager::UnsubscribeAccountCommonEvent()
void DmAccountEventSubscriber::OnReceiveEvent(const CommonEventData &data)
{
std::string receiveEvent = data.GetWant().GetAction();
LOGI("Received account event: %{public}s", receiveEvent.c_str());
int32_t userId = data.GetCode();
bool accountValiedEvent = false;
if (receiveEvent == EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED ||
receiveEvent == EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED) {
userId = data.GetCode();
accountValiedEvent = true;
int32_t currentUserId = -1;
int32_t beforeUserId = -1;
bool accountValidEvent = false;
if (receiveEvent == EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED) {
currentUserId = data.GetCode();
beforeUserId = std::atoi(data.GetWant().GetStringParam("oldId").c_str());
accountValidEvent = true;
}
if (receiveEvent == EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED) {
beforeUserId = data.GetCode();
accountValidEvent = true;
}
if (receiveEvent == EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT ||
receiveEvent == EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGIN) {
userId = data.GetWant().GetIntParam("userId", 0);
accountValiedEvent = true;
currentUserId = data.GetWant().GetIntParam("userId", 0);
beforeUserId = currentUserId;
accountValidEvent = true;
}
if (userId <= 0 || !accountValiedEvent) {
LOGI("Received account event: %{public}s, currentUserId: %{public}d, beforeUserId: %{public}d",
receiveEvent.c_str(), currentUserId, beforeUserId);
if (!accountValidEvent) {
LOGE("Invalied account type event.");
return;
}
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
ffrt::submit([=]() { callback_(userId, receiveEvent); });
ffrt::submit([=]() { callback_(receiveEvent, currentUserId, beforeUserId); });
#else
std::thread dealThread([=]() { callback_(userId, receiveEvent); });
std::thread dealThread([=]() { callback_(receiveEvent, currentUserId, beforeUserId); });
int32_t ret = pthread_setname_np(dealThread.native_handle(), DEAL_THREAD);
if (ret != DM_OK) {
LOGE("dealThread setname failed.");

259
services/service/src/relationshipsyncmgr/dm_comm_tool.cpp Normal file
View File

@ -0,0 +1,259 @@
/*
* Copyright (c) 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 "dm_comm_tool.h"
#include "cJSON.h"
#include "device_manager_service.h"
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "dm_transport.h"
#include "dm_transport_msg.h"
#include "dm_log.h"
#include "dm_softbus_cache.h"
#include "multiple_user_connector.h"
namespace OHOS {
namespace DistributedHardware {
DMCommTool::DMCommTool() : dmTransportPtr_(nullptr)
{
LOGI("Ctor DMCommTool");
}
void DMCommTool::Init()
{
LOGI("Init DMCommTool");
dmTransportPtr_ = std::make_shared<DMTransport>(shared_from_this());
std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(true);
eventHandler_ = std::make_shared<DMCommTool::DMCommToolEventHandler>(runner, shared_from_this());
dmTransportPtr_->Init();
}
void DMCommTool::UnInit()
{
LOGI("UnInit DMCommTool");
if (dmTransportPtr_ == nullptr) {
LOGI("dmTransportPtr_ is null");
return;
}
dmTransportPtr_->UnInit();
}
std::shared_ptr<DMCommTool> DMCommTool::GetInstance()
{
static std::shared_ptr<DMCommTool> instance = std::make_shared<DMCommTool>();
return instance;
}
void DMCommTool::SendUserIds(const std::string rmtNetworkId,
const std::vector<uint32_t> &foregroundUserIds, const std::vector<uint32_t> &backgroundUserIds)
{
if (!IsIdLengthValid(rmtNetworkId) || foregroundUserIds.empty() || dmTransportPtr_ == nullptr) {
LOGE("param invalid, networkId: %{public}s, foreground userids size: %{public}d",
GetAnonyString(rmtNetworkId).c_str(), static_cast<int32_t>(foregroundUserIds.size()));
return;
}
if (dmTransportPtr_->StartSocket(rmtNetworkId) != DM_OK) {
LOGE("Start socket error");
return;
}
UserIdsMsg userIdsMsg(foregroundUserIds, backgroundUserIds);
cJSON *root = cJSON_CreateObject();
if (root == nullptr) {
LOGE("Create cJSON object failed.");
return;
}
ToJson(root, userIdsMsg);
char *msg = cJSON_PrintUnformatted(root);
if (msg == nullptr) {
cJSON_Delete(root);
return;
}
std::string msgStr(msg);
cJSON_Delete(root);
CommMsg commMsg(DM_COMM_SEND_LOCAL_USERIDS, msgStr);
std::string payload = GetCommMsgString(commMsg);
int32_t ret = dmTransportPtr_->Send(rmtNetworkId, payload);
if (ret != DM_OK) {
LOGE("Send local foreground userids failed, ret: %{public}d", ret);
return;
}
LOGI("Send local foreground userids success");
}
void DMCommTool::RspLocalFrontOrBackUserIds(const std::string rmtNetworkId,
const std::vector<uint32_t> &foregroundUserIds, const std::vector<uint32_t> &backgroundUserIds)
{
UserIdsMsg userIdsMsg(foregroundUserIds, backgroundUserIds);
cJSON *root = cJSON_CreateObject();
if (root == nullptr) {
LOGE("Create cJSON object failed.");
return;
}
ToJson(root, userIdsMsg);
char *msg = cJSON_PrintUnformatted(root);
if (msg == nullptr) {
cJSON_Delete(root);
return;
}
std::string msgStr(msg);
cJSON_Delete(root);
CommMsg commMsg(DM_COMM_RSP_LOCAL_USERIDS, msgStr);
std::string payload = GetCommMsgString(commMsg);
int32_t ret = dmTransportPtr_->Send(rmtNetworkId, payload);
if (ret != DM_OK) {
LOGE("Response local foreground userids failed, ret: %{public}d", ret);
return;
}
LOGI("Response local foreground userids success");
}
DMCommTool::DMCommToolEventHandler::DMCommToolEventHandler(const std::shared_ptr<AppExecFwk::EventRunner> runner,
std::shared_ptr<DMCommTool> dmCommToolPtr) : AppExecFwk::EventHandler(runner), dmCommToolWPtr_(dmCommToolPtr)
{
LOGI("Ctor DMCommToolEventHandler");
}
void DMCommTool::DMCommToolEventHandler::ProcessEvent(
const AppExecFwk::InnerEvent::Pointer &event)
{
uint32_t eventId = event->GetInnerEventId();
std::shared_ptr<InnerCommMsg> commMsg = event->GetSharedObject<InnerCommMsg>();
if (commMsg == nullptr) {
LOGE("ProcessEvent commMsg is null");
return;
}
if (dmCommToolWPtr_.expired()) {
LOGE("dmCommToolWPtr_ is expired");
return;
}
std::shared_ptr<DMCommTool> dmCommToolPtr = dmCommToolWPtr_.lock();
if (dmCommToolPtr == nullptr) {
LOGE("dmCommToolPtr is null");
return;
}
switch (eventId) {
case DM_COMM_SEND_LOCAL_USERIDS: {
// Process remote foreground userids and send back local user ids
dmCommToolPtr->ProcessReceiveUserIdsEvent(commMsg);
break;
}
case DM_COMM_RSP_LOCAL_USERIDS: {
// Process remote foreground userids and close session
dmCommToolPtr->ProcessResponseUserIdsEvent(commMsg);
break;
}
default:
LOGE("event is undefined, id is %{public}d", eventId);
break;
}
}
void DMCommTool::ProcessReceiveUserIdsEvent(const std::shared_ptr<InnerCommMsg> commMsg)
{
LOGI("Receive remote userids, process and rsp local userid");
std::string rmtUdid = "";
SoftbusCache::GetInstance().GetUdidFromCache(commMsg->remoteNetworkId.c_str(), rmtUdid);
if (rmtUdid.empty()) {
LOGE("Can not find remote udid by networkid: %{public}s", commMsg->remoteNetworkId.c_str());
return;
}
std::string payload = commMsg->commMsg->msg;
cJSON *root = cJSON_Parse(payload.c_str());
if (root == NULL) {
LOGE("the msg is not json format");
return;
}
UserIdsMsg userIdsMsg;
FromJson(root, userIdsMsg);
cJSON_Delete(root);
uint32_t totalUserNum = static_cast<uint32_t>(userIdsMsg.foregroundUserIds.size()) +
static_cast<uint32_t>(userIdsMsg.backgroundUserIds.size());
if (userIdsMsg.foregroundUserIds.empty()) {
LOGE("Parse but get none remote foreground userids");
} else {
// step1: process remote foreground/background userids
DeviceManagerService::GetInstance().ProcessSyncUserIds(userIdsMsg.foregroundUserIds,
userIdsMsg.backgroundUserIds, rmtUdid);
}
// step2: send back local userids
std::vector<int32_t> foregroundUserIds;
std::vector<int32_t> backgroundUserIds;
MultipleUserConnector::GetForegroundUserIds(foregroundUserIds);
MultipleUserConnector::GetBackgroundUserIds(backgroundUserIds);
std::vector<uint32_t> foregroundUserIdsU32;
std::vector<uint32_t> backgroundUserIdsU32;
for (auto const &u : foregroundUserIds) {
foregroundUserIdsU32.push_back(static_cast<uint32_t>(u));
}
for (auto const &u : backgroundUserIds) {
backgroundUserIdsU32.push_back(static_cast<uint32_t>(u));
}
RspLocalFrontOrBackUserIds(commMsg->remoteNetworkId, foregroundUserIdsU32, backgroundUserIdsU32);
}
void DMCommTool::ProcessResponseUserIdsEvent(const std::shared_ptr<InnerCommMsg> commMsg)
{
LOGI("process receive remote userids response");
// step1: close socket
this->dmTransportPtr_->StopSocket(commMsg->remoteNetworkId);
std::string rmtUdid = "";
SoftbusCache::GetInstance().GetUdidFromCache(commMsg->remoteNetworkId.c_str(), rmtUdid);
if (rmtUdid.empty()) {
LOGE("Can not find remote udid by networkid: %{public}s", commMsg->remoteNetworkId.c_str());
return;
}
std::string payload = commMsg->commMsg->msg;
cJSON *root = cJSON_Parse(payload.c_str());
if (root == NULL) {
LOGE("the msg is not json format");
return;
}
UserIdsMsg userIdsMsg;
FromJson(root, userIdsMsg);
cJSON_Delete(root);
if (userIdsMsg.foregroundUserIds.empty()) {
LOGE("Parse but get none remote userids");
return;
}
// step2: process remote foreground/background userids
if (!userIdsMsg.foregroundUserIds.empty()) {
DeviceManagerService::GetInstance().ProcessSyncUserIds(userIdsMsg.foregroundUserIds,
userIdsMsg.backgroundUserIds, rmtUdid);
} else {
LOGE("Receive remote foreground userid empty");
}
}
std::shared_ptr<DMCommTool::DMCommToolEventHandler> DMCommTool::GetEventHandler()
{
return this->eventHandler_;
}
const std::shared_ptr<DMTransport> DMCommTool::GetDMTransportPtr()
{
return this->dmTransportPtr_;
}
} // DistributedHardware
} // OHOS

454
services/service/src/relationshipsyncmgr/dm_transport.cpp Normal file
View File

@ -0,0 +1,454 @@
/*
* Copyright (c) 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 "dm_transport.h"
#include <cinttypes>
#include "cJSON.h"
#include <securec.h>
#include "dm_anonymous.h"
#include "dm_comm_tool.h"
#include "dm_constants.h"
#include "dm_log.h"
#include "dm_softbus_cache.h"
#include "dm_transport_msg.h"
namespace OHOS {
namespace DistributedHardware {
namespace {
// Dsoftbus sendBytes max message length: 4MB
constexpr uint32_t MAX_SEND_MSG_LENGTH = 4 * 1024 * 1024;
constexpr uint32_t INTERCEPT_STRING_LENGTH = 20;
constexpr uint32_t MAX_ROUND_SIZE = 1000;
static QosTV g_qosInfo[] = {
{ .qos = QOS_TYPE_MIN_BW, .value = 256 * 1024},
{ .qos = QOS_TYPE_MAX_LATENCY, .value = 8000 },
{ .qos = QOS_TYPE_MIN_LATENCY, .value = 2000 }
};
static uint32_t g_qosTvParamIndex = static_cast<uint32_t>(sizeof(g_qosInfo) / sizeof(g_qosInfo[0]));
static std::weak_ptr<DMCommTool> g_dmCommToolWPtr_;
}
DMTransport::DMTransport(std::shared_ptr<DMCommTool> dmCommToolPtr) : remoteDevSocketIds_({}), localServerSocket_(-1),
localSocketName_(""), isSocketSvrCreateFlag_(false), dmCommToolWPtr_(dmCommToolPtr)
{
LOGI("Ctor DMTransport");
g_dmCommToolWPtr_ = dmCommToolPtr;
}
int32_t DMTransport::OnSocketOpened(int32_t socketId, const PeerSocketInfo &info)
{
LOGI("OnSocketOpened, socket: %{public}d, peerSocketName: %{public}s, peerNetworkId: %{public}s, "
"peerPkgName: %{public}s", socketId, info.name, GetAnonyString(info.networkId).c_str(), info.pkgName);
std::lock_guard<std::mutex> lock(rmtSocketIdMtx_);
remoteDevSocketIds_[info.networkId] = socketId;
return DM_OK;
}
void DMTransport::OnSocketClosed(int32_t socketId, ShutdownReason reason)
{
LOGI("OnSocketClosed, socket: %{public}d, reason: %{public}d", socketId, (int32_t)reason);
std::lock_guard<std::mutex> lock(rmtSocketIdMtx_);
for (auto iter = remoteDevSocketIds_.begin(); iter != remoteDevSocketIds_.end(); ++iter) {
if (iter->second == socketId) {
remoteDevSocketIds_.erase(iter);
break;
}
}
}
void DMTransport::OnBytesReceived(int32_t socketId, const void *data, uint32_t dataLen)
{
if (socketId < 0 || data == nullptr || dataLen == 0 || dataLen > MAX_SEND_MSG_LENGTH) {
LOGE("OnBytesReceived param check failed");
return;
}
std::string remoteNeworkId = GetRemoteNetworkIdBySocketId(socketId);
if (remoteNeworkId.empty()) {
LOGE("Can not find the remote network id by socketId: %{public}d", socketId);
return;
}
uint8_t *buf = reinterpret_cast<uint8_t *>(calloc(dataLen + 1, sizeof(uint8_t)));
if (buf == nullptr) {
LOGE("OnBytesReceived: malloc memory failed");
return;
}
if (memcpy_s(buf, dataLen + 1, reinterpret_cast<const uint8_t *>(data), dataLen) != EOK) {
LOGE("OnBytesReceived: memcpy memory failed");
free(buf);
return;
}
std::string message(buf, buf + dataLen);
LOGI("Receive message size: %{public}" PRIu32, dataLen);
HandleReceiveMessage(socketId, message);
free(buf);
return;
}
void DMTransport::HandleReceiveMessage(const int32_t socketId, const std::string &payload)
{
std::string rmtNetworkId = GetRemoteNetworkIdBySocketId(socketId);
if (rmtNetworkId.empty()) {
LOGE("Can not find networkId by socketId: %{public}d", socketId);
return;
}
if (payload.empty() || payload.size() > MAX_SEND_MSG_LENGTH) {
LOGE("payload invalid");
return;
}
LOGI("Receive msg: %{public}s", payload.c_str());
cJSON *root = cJSON_Parse(payload.c_str());
if (root == NULL) {
LOGE("the msg is not json format");
return;
}
std::shared_ptr<CommMsg> commMsg = std::make_shared<CommMsg>();
FromJson(root, *commMsg);
cJSON_Delete(root);
std::shared_ptr<InnerCommMsg> innerMsg = std::make_shared<InnerCommMsg>(rmtNetworkId, commMsg);
LOGI("Receive DM msg, code: %{public}d, msg: %{public}s", commMsg->code, GetAnonyString(commMsg->msg).c_str());
AppExecFwk::InnerEvent::Pointer msgEvent = AppExecFwk::InnerEvent::Get(commMsg->code, innerMsg);
std::shared_ptr<DMCommTool> dmCommToolSPtr = dmCommToolWPtr_.lock();
if (dmCommToolSPtr == nullptr) {
LOGE("Can not get DMCommTool ptr");
return;
}
if (dmCommToolSPtr->GetEventHandler() == nullptr) {
LOGE("Can not get eventHandler");
return;
}
dmCommToolSPtr->GetEventHandler()->SendEvent(msgEvent, 0, AppExecFwk::EventQueue::Priority::IMMEDIATE);
}
std::shared_ptr<DMCommTool> GetDMCommToolPtr()
{
if (g_dmCommToolWPtr_.expired()) {
LOGE("DMCommTool Weak ptr expired");
return nullptr;
}
std::shared_ptr<DMCommTool> dmCommToolSPtr = g_dmCommToolWPtr_.lock();
if (dmCommToolSPtr == nullptr) {
LOGE("Can not get DMCommTool ptr");
return nullptr;
}
return dmCommToolSPtr;
}
void OnBind(int32_t socket, PeerSocketInfo info)
{
std::shared_ptr<DMCommTool> dmCommToolSPtr = GetDMCommToolPtr();
if (dmCommToolSPtr == nullptr) {
LOGE("Can not get DMCommTool ptr");
return;
}
dmCommToolSPtr->GetDMTransportPtr()->OnSocketOpened(socket, info);
}
void OnShutdown(int32_t socket, ShutdownReason reason)
{
std::shared_ptr<DMCommTool> dmCommToolSPtr = GetDMCommToolPtr();
if (dmCommToolSPtr == nullptr) {
LOGE("Can not get DMCommTool ptr");
return;
}
dmCommToolSPtr->GetDMTransportPtr()->OnSocketClosed(socket, reason);
}
void OnBytes(int32_t socket, const void *data, uint32_t dataLen)
{
std::shared_ptr<DMCommTool> dmCommToolSPtr = GetDMCommToolPtr();
if (dmCommToolSPtr == nullptr) {
LOGE("Can not get DMCommTool ptr");
return;
}
dmCommToolSPtr->GetDMTransportPtr()->OnBytesReceived(socket, data, dataLen);
}
void OnMessage(int32_t socket, const void *data, uint32_t dataLen)
{
(void)socket;
(void)data;
(void)dataLen;
LOGI("socket: %{public}d, dataLen:%{public}" PRIu32, socket, dataLen);
}
void OnStream(int32_t socket, const StreamData *data, const StreamData *ext,
const StreamFrameInfo *param)
{
(void)socket;
(void)data;
(void)ext;
(void)param;
LOGI("socket: %{public}d", socket);
}
void OnFile(int32_t socket, FileEvent *event)
{
(void)event;
LOGI("socket: %{public}d", socket);
}
void OnQos(int32_t socket, QoSEvent eventId, const QosTV *qos, uint32_t qosCount)
{
if (qosCount == 0 || qosCount > MAX_ROUND_SIZE) {
LOGE("qosCount is invalid!");
return;
}
LOGI("OnQos, socket: %{public}d, QoSEvent: %{public}d, qosCount: %{public}" PRIu32,
socket, (int32_t)eventId, qosCount);
for (uint32_t idx = 0; idx < qosCount; idx++) {
LOGI("QosTV: type: %{public}d, value: %{public}d", (int32_t)qos[idx].qos, qos[idx].value);
}
}
ISocketListener iSocketListener = {
.OnBind = OnBind,
.OnShutdown = OnShutdown,
.OnBytes = OnBytes,
.OnMessage = OnMessage,
.OnStream = OnStream,
.OnFile = OnFile,
.OnQos = OnQos
};
int32_t DMTransport::CreateServerSocket()
{
LOGI("CreateServerSocket start");
localSocketName_ = DM_SYNC_USERID_SESSION_NAME;
LOGI("CreateServerSocket , local socketName: %{public}s", localSocketName_.c_str());
std::string dmPkgName(DM_PKG_NAME);
SocketInfo info = {
.name = const_cast<char*>(localSocketName_.c_str()),
.pkgName = const_cast<char*>(dmPkgName.c_str()),
.dataType = DATA_TYPE_BYTES
};
int32_t socket = Socket(info);
LOGI("CreateServerSocket Finish, socket: %{public}d", socket);
return socket;
}
int32_t DMTransport::CreateClientSocket(const std::string &rmtNetworkId)
{
if (!IsIdLengthValid(rmtNetworkId)) {
return ERR_DM_INPUT_PARA_INVALID;
}
LOGI("CreateClientSocket start, peerNetworkId: %{public}s", GetAnonyString(rmtNetworkId).c_str());
std::string peerSocketName = DM_SYNC_USERID_SESSION_NAME;
std::string dmPkgName(DM_PKG_NAME);
SocketInfo info = {
.name = const_cast<char*>(localSocketName_.c_str()),
.peerName = const_cast<char*>(peerSocketName.c_str()),
.peerNetworkId = const_cast<char*>(rmtNetworkId.c_str()),
.pkgName = const_cast<char*>(dmPkgName.c_str()),
.dataType = DATA_TYPE_BYTES
};
int32_t socket = Socket(info);
LOGI("Bind Socket server, socket: %{public}d, localSocketName: %{public}s, peerSocketName: %{public}s",
socket, localSocketName_.c_str(), peerSocketName.c_str());
return socket;
}
int32_t DMTransport::Init()
{
LOGI("Init DMTransport");
if (isSocketSvrCreateFlag_.load()) {
LOGI("SocketServer already create success.");
return DM_OK;
}
int32_t socket = CreateServerSocket();
if (socket < DM_OK) {
LOGE("CreateSocketServer failed, ret: %{public}d", socket);
return ERR_DM_FAILED;
}
int32_t ret = Listen(socket, g_qosInfo, g_qosTvParamIndex, &iSocketListener);
if (ret != DM_OK) {
LOGE("Socket Listen failed, error code %{public}d.", ret);
return ERR_DM_FAILED;
}
isSocketSvrCreateFlag_.store(true);
localServerSocket_ = socket;
LOGI("Finish Init DSoftBus Server Socket, socket: %{public}d", socket);
return DM_OK;
}
int32_t DMTransport::UnInit()
{
{
std::lock_guard<std::mutex> lock(rmtSocketIdMtx_);
for (auto iter = remoteDevSocketIds_.begin(); iter != remoteDevSocketIds_.end(); ++iter) {
LOGI("Shutdown client socket: %{public}d to remote dev: %{public}s", iter->second,
GetAnonyString(iter->first).c_str());
Shutdown(iter->second);
}
remoteDevSocketIds_.clear();
}
if (!isSocketSvrCreateFlag_.load()) {
LOGI("DSoftBus Server Socket already remove success.");
} else {
LOGI("Shutdown DSoftBus Server Socket, socket: %{public}d", localServerSocket_.load());
Shutdown(localServerSocket_.load());
localServerSocket_ = -1;
isSocketSvrCreateFlag_.store(false);
}
return DM_OK;
}
bool DMTransport::IsDeviceSessionOpened(const std::string &rmtNetworkId, int32_t &socketId)
{
if (!IsIdLengthValid(rmtNetworkId)) {
return false;
}
std::lock_guard<std::mutex> lock(rmtSocketIdMtx_);
if (remoteDevSocketIds_.find(rmtNetworkId) == remoteDevSocketIds_.end()) {
return false;
}
socketId = remoteDevSocketIds_.at(rmtNetworkId);
LOGI("DeviceSession has opened, rmtNetworkId: %{public}s, socketId: %{public}d",
GetAnonyString(rmtNetworkId).c_str(), socketId);
return true;
}
std::string DMTransport::GetRemoteNetworkIdBySocketId(int32_t socketId)
{
std::lock_guard<std::mutex> lock(rmtSocketIdMtx_);
std::string networkId = "";
for (auto const &item : remoteDevSocketIds_) {
if (item.second == socketId) {
networkId = item.first;
break;
}
}
return networkId;
}
void DMTransport::ClearDeviceSocketOpened(const std::string &remoteDevId)
{
if (!IsIdLengthValid(remoteDevId)) {
return;
}
std::lock_guard<std::mutex> lock(rmtSocketIdMtx_);
remoteDevSocketIds_.erase(remoteDevId);
}
int32_t DMTransport::StartSocket(const std::string &rmtNetworkId)
{
if (!IsIdLengthValid(rmtNetworkId)) {
return ERR_DM_INPUT_PARA_INVALID;
}
int32_t socketId = -1;
if (IsDeviceSessionOpened(rmtNetworkId, socketId)) {
LOGE("Softbus session has already opened, deviceId: %{public}s", GetAnonyString(rmtNetworkId).c_str());
return DM_OK;
}
int32_t socket = CreateClientSocket(rmtNetworkId);
if (socket < DM_OK) {
LOGE("StartSocket failed, ret: %{public}d", socket);
return ERR_DM_FAILED;
}
int32_t ret = Bind(socket, g_qosInfo, g_qosTvParamIndex, &iSocketListener);
if (ret < DM_OK) {
LOGE("OpenSession fail, rmtNetworkId: %{public}s, socket: %{public}d, ret: %{public}d",
GetAnonyString(rmtNetworkId).c_str(), socket, ret);
Shutdown(socket);
return ERR_DM_FAILED;
}
LOGI("Bind Socket success, rmtNetworkId:%{public}s, socketId: %{public}d",
GetAnonyString(rmtNetworkId).c_str(), socket);
std::string peerSocketName = DM_SYNC_USERID_SESSION_NAME;
std::string dmPkgName(DM_PKG_NAME);
PeerSocketInfo peerSocketInfo = {
.name = const_cast<char*>(peerSocketName.c_str()),
.networkId = const_cast<char*>(rmtNetworkId.c_str()),
.pkgName = const_cast<char*>(dmPkgName.c_str()),
.dataType = DATA_TYPE_BYTES
};
OnSocketOpened(socket, peerSocketInfo);
return DM_OK;
}
int32_t DMTransport::StopSocket(const std::string &rmtNetworkId)
{
if (!IsIdLengthValid(rmtNetworkId)) {
return ERR_DM_INPUT_PARA_INVALID;
}
int32_t socketId = -1;
if (!IsDeviceSessionOpened(rmtNetworkId, socketId)) {
LOGI("remote dev may be not opened, rmtNetworkId: %{public}s", GetAnonyString(rmtNetworkId).c_str());
return ERR_DM_FAILED;
}
LOGI("StopSocket rmtNetworkId: %{public}s, socketId: %{public}d",
GetAnonyString(rmtNetworkId).c_str(), socketId);
Shutdown(socketId);
ClearDeviceSocketOpened(rmtNetworkId);
return DM_OK;
}
int32_t DMTransport::Send(const std::string &rmtNetworkId, const std::string &payload)
{
if (!IsIdLengthValid(rmtNetworkId) || !IsMessageLengthValid(payload)) {
return ERR_DM_INPUT_PARA_INVALID;
}
int32_t socketId = -1;
if (!IsDeviceSessionOpened(rmtNetworkId, socketId)) {
LOGI("The session is not open, target networkId: %{public}s", GetAnonyString(rmtNetworkId).c_str());
return ERR_DM_FAILED;
}
uint32_t payLoadSize = payload.size();
LOGI("Send payload size: %{public}" PRIu32 ", target networkId: %{public}s, socketId: %{public}d",
static_cast<uint32_t>(payload.size()), GetAnonyString(rmtNetworkId).c_str(), socketId);
if (payLoadSize > MAX_SEND_MSG_LENGTH) {
LOGE("Send error: msg size: %{public}" PRIu32 " too long", payLoadSize);
return ERR_DM_FAILED;
}
uint8_t *buf = reinterpret_cast<uint8_t *>(calloc((payLoadSize), sizeof(uint8_t)));
if (buf == nullptr) {
LOGE("Send: malloc memory failed");
return ERR_DM_FAILED;
}
if (memcpy_s(buf, payLoadSize, reinterpret_cast<const uint8_t *>(payload.c_str()),
payLoadSize) != EOK) {
LOGE("Send: memcpy memory failed");
free(buf);
return ERR_DM_FAILED;
}
int32_t ret = SendBytes(socketId, buf, payLoadSize);
free(buf);
if (ret != DM_OK) {
LOGE("dsoftbus send error, ret: %{public}d", ret);
return ERR_DM_FAILED;
}
LOGI("Send payload success");
return DM_OK;
}
} // DistributedHardware
} // OHOS

208
services/service/src/relationshipsyncmgr/dm_transport_msg.cpp Normal file
View File

@ -0,0 +1,208 @@
/*
* Copyright (c) 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 "dm_transport_msg.h"
#include "dm_anonymous.h"
#include "dm_log.h"
namespace OHOS {
namespace DistributedHardware {
namespace {
const int32_t MAX_USER_ID_NUM = 5;
const int32_t MAX_BACKGROUND_USER_ID_NUM = 5;
}
void ToJson(cJSON *jsonObject, const UserIdsMsg &userIdsMsg)
{
if (jsonObject == nullptr) {
LOGE("Json pointer is nullptr!");
return;
}
cJSON *foregroundUserIdArr = cJSON_CreateArray();
if (foregroundUserIdArr == nullptr) {
return;
}
for (auto const &userId : userIdsMsg.foregroundUserIds) {
cJSON_AddItemToArray(foregroundUserIdArr, cJSON_CreateNumber(userId));
}
cJSON_AddItemToObject(jsonObject, FOREGROUND_USERIDS_MSG_USERIDS_KEY, foregroundUserIdArr);
cJSON *backgroundUserIdArr = cJSON_CreateArray();
if (backgroundUserIdArr == nullptr) {
return;
}
for (auto const &userId : userIdsMsg.backgroundUserIds) {
cJSON_AddItemToArray(backgroundUserIdArr, cJSON_CreateNumber(userId));
}
cJSON_AddItemToObject(jsonObject, BACKGROUND_USERIDS_MSG_USERIDS_KEY, backgroundUserIdArr);
}
void FromJson(const cJSON *jsonObject, UserIdsMsg &userIdsMsg)
{
if (jsonObject == nullptr) {
LOGE("Json pointer is nullptr!");
return;
}
cJSON *foregroundUserIdsArr = cJSON_GetObjectItem(jsonObject, FOREGROUND_USERIDS_MSG_USERIDS_KEY);
if (cJSON_IsArray(foregroundUserIdsArr)) {
int32_t arrSize = cJSON_GetArraySize(foregroundUserIdsArr);
if (arrSize > MAX_USER_ID_NUM) {
LOGE("Receive too many foreground userids, %{public}d", arrSize);
return;
}
for (int32_t i = 0; i < arrSize; i++) {
cJSON *userIdItem = cJSON_GetArrayItem(foregroundUserIdsArr, i);
if (cJSON_IsNumber(userIdItem)) {
uint32_t userId = static_cast<uint32_t>(userIdItem->valueint);
userIdsMsg.foregroundUserIds.push_back(userId);
}
}
}
cJSON *backgroundUserIdsArr = cJSON_GetObjectItem(jsonObject, BACKGROUND_USERIDS_MSG_USERIDS_KEY);
if (cJSON_IsArray(backgroundUserIdsArr)) {
int32_t arrSize = cJSON_GetArraySize(backgroundUserIdsArr);
if (arrSize > MAX_BACKGROUND_USER_ID_NUM) {
LOGE("Receive too many background userids, %{public}d", arrSize);
return;
}
for (int32_t i = 0; i < arrSize; i++) {
cJSON *userIdItem = cJSON_GetArrayItem(backgroundUserIdsArr, i);
if (cJSON_IsNumber(userIdItem)) {
uint32_t userId = static_cast<uint32_t>(userIdItem->valueint);
userIdsMsg.backgroundUserIds.push_back(userId);
}
}
}
}
void ToJson(cJSON *jsonObject, const CommMsg &commMsg)
{
if (jsonObject == nullptr) {
LOGE("Json pointer is nullptr!");
return;
}
cJSON_AddNumberToObject(jsonObject, COMM_MSG_CODE_KEY, commMsg.code);
const char *msg = commMsg.msg.c_str();
cJSON_AddStringToObject(jsonObject, COMM_MSG_MSG_KEY, msg);
}
void FromJson(const cJSON *jsonObject, CommMsg &commMsg)
{
if (jsonObject == nullptr) {
LOGE("Json pointer is nullptr!");
return;
}
cJSON *codeObj = cJSON_GetObjectItem(jsonObject, COMM_MSG_CODE_KEY);
if (cJSON_IsNumber(codeObj)) {
commMsg.code = codeObj->valueint;
}
cJSON *msgObj = cJSON_GetObjectItem(jsonObject, COMM_MSG_MSG_KEY);
if (cJSON_IsString(msgObj)) {
commMsg.msg = msgObj->valuestring;
}
}
std::string GetCommMsgString(const CommMsg &commMsg)
{
cJSON *rootMsg = cJSON_CreateObject();
if (rootMsg == nullptr) {
LOGE("Create cJSON object failed.");
return "";
}
ToJson(rootMsg, commMsg);
char *msg = cJSON_PrintUnformatted(rootMsg);
if (msg == nullptr) {
cJSON_Delete(rootMsg);
return "";
}
std::string msgStr = std::string(msg);
cJSON_free(msg);
cJSON_Delete(rootMsg);
return msgStr;
}
void ToJson(cJSON *jsonObject, const NotifyUserIds &notifyUserIds)
{
if (jsonObject == nullptr) {
LOGE("Json pointer is nullptr!");
return;
}
cJSON_AddStringToObject(jsonObject, DSOFTBUS_NOTIFY_USERIDS_UDIDKEY, notifyUserIds.remoteUdid.c_str());
cJSON *userIdArr = cJSON_CreateArray();
if (userIdArr == nullptr) {
return;
}
for (auto const &userId : notifyUserIds.userIds) {
cJSON_AddItemToArray(userIdArr, cJSON_CreateNumber(userId));
}
cJSON_AddItemToObject(jsonObject, DSOFTBUS_NOTIFY_USERIDS_USERIDKEY, userIdArr);
}
void FromJson(const cJSON *jsonObject, NotifyUserIds &notifyUserIds)
{
if (jsonObject == nullptr) {
LOGE("Json pointer is nullptr!");
return;
}
cJSON *msgObj = cJSON_GetObjectItem(jsonObject, DSOFTBUS_NOTIFY_USERIDS_UDIDKEY);
if (cJSON_IsString(msgObj)) {
notifyUserIds.remoteUdid = msgObj->valuestring;
}
cJSON *userIdsArr = cJSON_GetObjectItem(jsonObject, DSOFTBUS_NOTIFY_USERIDS_USERIDKEY);
if (cJSON_IsArray(userIdsArr)) {
int32_t arrSize = cJSON_GetArraySize(userIdsArr);
if (arrSize > MAX_USER_ID_NUM) {
LOGE("Receive too many userids, %{public}d", arrSize);
return;
}
for (int32_t i = 0; i < arrSize; i++) {
cJSON *userIdItem = cJSON_GetArrayItem(userIdsArr, i);
if (cJSON_IsNumber(userIdItem)) {
uint32_t userId = static_cast<uint32_t>(userIdItem->valueint);
notifyUserIds.userIds.push_back(userId);
}
}
}
}
std::string NotifyUserIds::ToString()
{
cJSON *msg = cJSON_CreateObject();
if (msg == NULL) {
LOGE("failed to create cjson object");
return "";
}
ToJson(msg, *this);
char *retStr = cJSON_PrintUnformatted(msg);
if (retStr == nullptr) {
LOGE("to json is nullptr.");
cJSON_Delete(msg);
return "";
}
std::string ret = std::string(retStr);
cJSON_Delete(msg);
cJSON_free(retStr);
return ret;
}
} // DistributedHardware
} // OHOS

276
services/service/src/relationshipsyncmgr/relationship_sync_mgr.cpp
View File

@ -17,44 +17,82 @@
#include <cstdint>
#include <vector>
#include "dm_anonymous.h"
#include "dm_crypto.h"
#include "dm_log.h"
#include "multiple_user_connector.h"
namespace OHOS {
namespace DistributedHardware {
DM_IMPLEMENT_SINGLE_INSTANCE(ReleationShipSyncMgr);
namespace {
/**
* @brief account logout payload length 8
* @brief account logout payload length 8 bytes
* | 2 bytes | 6 bytes |
* | userid lower 2 bytes | account id first 6 bytes |
*/
const int32_t ACCOUNT_LOGOUT_PAYLOAD_LEN = 8;
/**
* @brief device unbind payload length 2
* @brief device unbind payload length 2 bytes
* | 2 bytes |
* | userid lower 2 bytes |
*/
const int32_t DEVICE_UNBIND_PAYLOAD_LEN = 2;
/**
* @brief app unbind payload length 6
* @brief app unbind payload length 6 bytes
* | 2 bytes | 4 bytes |
* | userid lower 2 bytes | token id lower 4 bytes |
*/
const int32_t APP_UNBIND_PAYLOAD_LEN = 6;
/**
* @brief delete user payload length 2 bytes
* | 2 bytes |
* | userid lower 2 bytes |
*/
const int32_t DEL_USER_PAYLOAD_LEN = 2;
/**
* @brief the userid payload cost 2 bytes.
*
*/
const int32_t USERID_PAYLOAD_LEN = 2;
const int32_t ACCOUNTID_PAYLOAD_LEN = 6;
const int32_t BIT_PER_BYTES = 8;
const int32_t SYNC_FRONT_OR_BACK_USERID_PAYLOAD_MAX_LEN = 11;
const int32_t SYNC_FRONT_OR_BACK_USERID_PAYLOAD_MIN_LEN = 3;
const int32_t USERID_BYTES = 2;
const int32_t BITS_PER_BYTE = 8;
const int32_t INVALIED_PAYLOAD_SIZE = 12;
const char * const MSG_TYPE = "TYPE";
const char * const MSG_VALUE = "VALUE";
const char * const MSG_PEER_UDID = "PEER_UDID";
const char * const MSG_ACCOUNTID = "ACCOUNTID";
// The need response mask offset, the 8th bit.
const int32_t NEED_RSP_MASK_OFFSET = 7;
/**
* @brief The userid cost 2 byte, the heigher part set on the 2th byte.
* The Max user id is just above 10000+, cost 15bits. We use the first bit
* to mark the user id foreground or background.
* 1 means foreground user, 0 means background user.
* @example foreground userid: 100 -> 0000 0000 0110 0100
* we save it in payload:
* |----first byte----|----second byte----|
* ----------------------------------------
* | 0110 0100 | 1000 0000 |
*/
const int32_t FRONT_OR_BACK_USER_FLAG_OFFSET = 7;
const uint8_t FRONT_OR_BACK_USER_FLAG_MASK = 0b01111111;
const uint8_t FRONT_OR_BACK_FLAG_MASK = 0b10000000;
// The total number of foreground and background userids offset, the 3th ~ 5th bits.
const uint16_t ALL_USERID_NUM_MASK_OFFSET = 3;
const uint16_t FOREGROUND_USERID_LEN_MASK = 0b00000111;
const uint16_t ALL_USERID_NUM_MASK = 0b00111000;
const uint32_t MAX_MEM_MALLOC_SIZE = 4 * 1024;
}
RelationShipChangeMsg::RelationShipChangeMsg() : type(RelationShipChangeType::TYPE_MAX),
userId(UINT32_MAX), accountId(""), tokenId(UINT64_MAX), peerUdid("")
userId(UINT32_MAX), accountId(""), tokenId(UINT64_MAX), peerUdids({}), peerUdid(""), accountName(""),
syncUserIdFlag(false), userIdInfos({})
{
}
@ -79,6 +117,13 @@ bool RelationShipChangeMsg::ToBroadcastPayLoad(uint8_t *&msg, uint32_t &len) con
ToAppUnbindPayLoad(msg, len);
ret = true;
break;
case RelationShipChangeType::SYNC_USERID:
ret = ToSyncFrontOrBackUserIdPayLoad(msg, len);
break;
case RelationShipChangeType::DEL_USER:
ToDelUserPayLoad(msg, len);
ret = true;
break;
default:
LOGE("RelationShipChange type invalid");
break;
@ -104,6 +149,12 @@ bool RelationShipChangeMsg::FromBroadcastPayLoad(const cJSON *payloadJson, Relat
case RelationShipChangeType::APP_UNBIND:
ret = FromAppUnbindPayLoad(payloadJson);
break;
case RelationShipChangeType::SYNC_USERID:
ret = FromSyncFrontOrBackUserIdPayLoad(payloadJson);
break;
case RelationShipChangeType::DEL_USER:
ret = FromDelUserPayLoad(payloadJson);
break;
default:
LOGE("RelationShipChange type invalid");
break;
@ -124,12 +175,18 @@ bool RelationShipChangeMsg::IsValid() const
case RelationShipChangeType::APP_UNBIND:
ret = (userId != UINT32_MAX && tokenId != UINT64_MAX);
break;
case RelationShipChangeType::SERVICE_UNBIND:
case RelationShipChangeType::DEL_USER:
ret = (userId != UINT32_MAX);
break;
case RelationShipChangeType::SERVICE_UNBIND:
case RelationShipChangeType::APP_UNINSTALL:
// current NOT support
ret = false;
break;
case RelationShipChangeType::SYNC_USERID:
ret = (!userIdInfos.empty() &&
(static_cast<uint32_t>(userIdInfos.size()) <= MAX_USER_ID_NUM));
break;
case RelationShipChangeType::TYPE_MAX:
ret = false;
break;
@ -143,21 +200,24 @@ bool RelationShipChangeMsg::IsValid() const
bool RelationShipChangeMsg::IsChangeTypeValid()
{
return (type == RelationShipChangeType::ACCOUNT_LOGOUT) || (type == RelationShipChangeType::DEVICE_UNBIND) ||
(type == RelationShipChangeType::APP_UNBIND);
(type == RelationShipChangeType::APP_UNBIND) || (type == RelationShipChangeType::SYNC_USERID) ||
(type == RelationShipChangeType::DEL_USER);
}
bool RelationShipChangeMsg::IsChangeTypeValid(uint32_t type)
{
return (type == (uint32_t)RelationShipChangeType::ACCOUNT_LOGOUT) ||
(type == (uint32_t)RelationShipChangeType::DEVICE_UNBIND) ||
(type == (uint32_t)RelationShipChangeType::APP_UNBIND);
(type == (uint32_t)RelationShipChangeType::APP_UNBIND) ||
(type == (uint32_t)RelationShipChangeType::SYNC_USERID) ||
(type == (uint32_t)RelationShipChangeType::DEL_USER);
}
void RelationShipChangeMsg::ToAccountLogoutPayLoad(uint8_t *&msg, uint32_t &len) const
{
msg = new uint8_t[ACCOUNT_LOGOUT_PAYLOAD_LEN]();
for (int i = 0; i < USERID_PAYLOAD_LEN; i++) {
msg[i] |= (userId >> (i * BIT_PER_BYTES)) & 0xFF;
msg[i] |= (userId >> (i * BITS_PER_BYTE)) & 0xFF;
}
for (int j = USERID_PAYLOAD_LEN; j < ACCOUNT_LOGOUT_PAYLOAD_LEN; j++) {
@ -170,7 +230,7 @@ void RelationShipChangeMsg::ToDeviceUnbindPayLoad(uint8_t *&msg, uint32_t &len)
{
msg = new uint8_t[DEVICE_UNBIND_PAYLOAD_LEN]();
for (int i = 0; i < USERID_PAYLOAD_LEN; i++) {
msg[i] |= (userId >> (i * BIT_PER_BYTES)) & 0xFF;
msg[i] |= (userId >> (i * BITS_PER_BYTE)) & 0xFF;
}
len = DEVICE_UNBIND_PAYLOAD_LEN;
}
@ -179,16 +239,60 @@ void RelationShipChangeMsg::ToAppUnbindPayLoad(uint8_t *&msg, uint32_t &len) con
{
msg = new uint8_t[APP_UNBIND_PAYLOAD_LEN]();
for (int i = 0; i < USERID_PAYLOAD_LEN; i++) {
msg[i] |= (userId >> (i * BIT_PER_BYTES)) & 0xFF;
msg[i] |= (userId >> (i * BITS_PER_BYTE)) & 0xFF;
}
for (int i = USERID_PAYLOAD_LEN; i < APP_UNBIND_PAYLOAD_LEN; i++) {
msg[i] |= (tokenId >> ((i - USERID_PAYLOAD_LEN) * BIT_PER_BYTES)) & 0xFF;
msg[i] |= (tokenId >> ((i - USERID_PAYLOAD_LEN) * BITS_PER_BYTE)) & 0xFF;
}
len = APP_UNBIND_PAYLOAD_LEN;
}
bool RelationShipChangeMsg::ToSyncFrontOrBackUserIdPayLoad(uint8_t *&msg, uint32_t &len) const
{
uint32_t userIdNum = static_cast<uint32_t>(userIdInfos.size());
if (userIdNum > MAX_USER_ID_NUM) {
LOGE("userIdNum too many, %{public}u", userIdNum);
return false;
}
len = userIdNum * USERID_BYTES + 1;
if (len > MAX_MEM_MALLOC_SIZE) {
LOGE("len too long");
return false;
}
msg = new uint8_t[len]();
if (syncUserIdFlag) {
msg[0] |= 0x1 << NEED_RSP_MASK_OFFSET;
} else {
msg[0] |= 0x0 << NEED_RSP_MASK_OFFSET;
}
msg[0] |= userIdNum;
int32_t userIdIdx = 0;
for (uint32_t idx = 1; idx <= (len - USERID_BYTES);) {
msg[idx] |= userIdInfos[userIdIdx].userId & 0xFF;
msg[idx + 1] |= (userIdInfos[userIdIdx].userId >> BITS_PER_BYTE) & 0xFF;
if (userIdInfos[userIdIdx].isForeground) {
msg[idx + 1] |= (0x1 << FRONT_OR_BACK_USER_FLAG_OFFSET);
}
idx += USERID_BYTES;
userIdIdx++;
}
return true;
}
void RelationShipChangeMsg::ToDelUserPayLoad(uint8_t *&msg, uint32_t &len) const
{
len = DEL_USER_PAYLOAD_LEN;
msg = new uint8_t[DEL_USER_PAYLOAD_LEN]();
for (int i = 0; i < DEL_USER_PAYLOAD_LEN; i++) {
msg[i] |= (userId >> (i * BITS_PER_BYTE)) & 0xFF;
}
}
bool RelationShipChangeMsg::FromAccountLogoutPayLoad(const cJSON *payloadJson)
{
if (payloadJson == NULL) {
@ -196,7 +300,7 @@ bool RelationShipChangeMsg::FromAccountLogoutPayLoad(const cJSON *payloadJson)
return false;
}
int32_t arraySize = cJSON_GetArraySize(payloadJson);
if (arraySize < ACCOUNT_LOGOUT_PAYLOAD_LEN || arraySize > INVALIED_PAYLOAD_SIZE) {
if (arraySize < ACCOUNT_LOGOUT_PAYLOAD_LEN || arraySize >= INVALIED_PAYLOAD_SIZE) {
LOGE("Payload invalied,the size is %{public}d.", arraySize);
return false;
}
@ -205,7 +309,7 @@ bool RelationShipChangeMsg::FromAccountLogoutPayLoad(const cJSON *payloadJson)
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, i);
CHECK_NULL_RETURN(payloadItem, false);
if (cJSON_IsNumber(payloadItem)) {
userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BIT_PER_BYTES);
userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BITS_PER_BYTE);
}
}
accountId = "";
@ -226,7 +330,7 @@ bool RelationShipChangeMsg::FromDeviceUnbindPayLoad(const cJSON *payloadJson)
return false;
}
int32_t arraySize = cJSON_GetArraySize(payloadJson);
if (arraySize < ACCOUNT_LOGOUT_PAYLOAD_LEN || arraySize > INVALIED_PAYLOAD_SIZE) {
if (arraySize < ACCOUNT_LOGOUT_PAYLOAD_LEN || arraySize >= INVALIED_PAYLOAD_SIZE) {
LOGE("Payload invalied,the size is %{public}d.", arraySize);
return false;
}
@ -235,7 +339,7 @@ bool RelationShipChangeMsg::FromDeviceUnbindPayLoad(const cJSON *payloadJson)
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, i);
CHECK_NULL_RETURN(payloadItem, false);
if (cJSON_IsNumber(payloadItem)) {
userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BIT_PER_BYTES);
userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BITS_PER_BYTE);
}
}
return true;
@ -248,7 +352,7 @@ bool RelationShipChangeMsg::FromAppUnbindPayLoad(const cJSON *payloadJson)
return false;
}
int32_t arraySize = cJSON_GetArraySize(payloadJson);
if (arraySize < ACCOUNT_LOGOUT_PAYLOAD_LEN || arraySize > INVALIED_PAYLOAD_SIZE) {
if (arraySize < ACCOUNT_LOGOUT_PAYLOAD_LEN || arraySize >= INVALIED_PAYLOAD_SIZE) {
LOGE("Payload invalied,the size is %{public}d.", arraySize);
return false;
}
@ -257,7 +361,7 @@ bool RelationShipChangeMsg::FromAppUnbindPayLoad(const cJSON *payloadJson)
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, i);
CHECK_NULL_RETURN(payloadItem, false);
if (cJSON_IsNumber(payloadItem)) {
userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BIT_PER_BYTES);
userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BITS_PER_BYTE);
}
}
tokenId = 0;
@ -265,13 +369,91 @@ bool RelationShipChangeMsg::FromAppUnbindPayLoad(const cJSON *payloadJson)
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, j);
CHECK_NULL_RETURN(payloadItem, false);
if (cJSON_IsNumber(payloadItem)) {
tokenId |= (static_cast<uint8_t>(payloadItem->valueint)) << ((j - USERID_PAYLOAD_LEN) * BIT_PER_BYTES);
tokenId |= (static_cast<uint8_t>(payloadItem->valueint)) << ((j - USERID_PAYLOAD_LEN) * BITS_PER_BYTE);
}
}
return true;
}
cJSON *RelationShipChangeMsg::ToArrayJson() const
bool RelationShipChangeMsg::FromSyncFrontOrBackUserIdPayLoad(const cJSON *payloadJson)
{
if (payloadJson == NULL) {
LOGE("payloadJson is null.");
return false;
}
int32_t arraySize = cJSON_GetArraySize(payloadJson);
if (arraySize < SYNC_FRONT_OR_BACK_USERID_PAYLOAD_MIN_LEN ||
arraySize > SYNC_FRONT_OR_BACK_USERID_PAYLOAD_MAX_LEN) {
LOGE("Payload invalid, the size is %{public}d.", arraySize);
return false;
}
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, 0);
CHECK_NULL_RETURN(payloadItem, false);
uint32_t userIdNum = 0;
if (cJSON_IsNumber(payloadItem)) {
uint8_t val = static_cast<uint8_t>(payloadItem->valueint);
this->syncUserIdFlag = (((val >> NEED_RSP_MASK_OFFSET) & 0x1) == 0x1);
userIdNum = ((static_cast<uint8_t>(payloadItem->valueint)) & FOREGROUND_USERID_LEN_MASK);
}
int32_t effectiveLen = userIdNum * USERID_BYTES + 1;
if (effectiveLen > arraySize) {
LOGE("payload userIdNum invalid, userIdNum: %{public}u, arraySize: %{public}d", userIdNum, arraySize);
return false;
}
uint16_t tempUserId = 0;
bool isForegroundUser = false;
for (int32_t idx = 1; idx < effectiveLen; idx++) {
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, idx);
CHECK_NULL_RETURN(payloadItem, false);
if (!cJSON_IsNumber(payloadItem)) {
LOGE("Payload invalid, user id not integer");
return false;
}
if ((idx - 1) % USERID_BYTES == 0) {
tempUserId |= (static_cast<uint8_t>(payloadItem->valueint));
}
if ((idx - 1) % USERID_BYTES == 1) {
tempUserId |= (static_cast<uint8_t>(payloadItem->valueint) << BITS_PER_BYTE);
tempUserId &= FRONT_OR_BACK_USER_FLAG_MASK;
isForegroundUser = (((static_cast<uint8_t>(payloadItem->valueint) & FRONT_OR_BACK_FLAG_MASK) >>
FRONT_OR_BACK_USER_FLAG_OFFSET) == 0b1);
UserIdInfo userIdInfo(isForegroundUser, tempUserId);
this->userIdInfos.push_back(userIdInfo);
tempUserId = 0;
isForegroundUser = false;
}
}
return true;
}
bool RelationShipChangeMsg::FromDelUserPayLoad(const cJSON *payloadJson)
{
if (payloadJson == NULL) {
LOGE("FromDelUserPayLoad payloadJson is null.");
return false;
}
int32_t arraySize = cJSON_GetArraySize(payloadJson);
if (arraySize < DEL_USER_PAYLOAD_LEN) {
LOGE("Payload invalid, the size is %{public}d.", arraySize);
return false;
}
this->userId = 0;
for (uint32_t i = 0; i < USERID_PAYLOAD_LEN; i++) {
cJSON *payloadItem = cJSON_GetArrayItem(payloadJson, i);
CHECK_NULL_RETURN(payloadItem, false);
if (cJSON_IsNumber(payloadItem)) {
this->userId |= (static_cast<uint8_t>(payloadItem->valueint)) << (i * BITS_PER_BYTE);
}
}
return true;
}
cJSON *RelationShipChangeMsg::ToPayLoadJson() const
{
uint8_t *payload = nullptr;
uint32_t len = 0;
@ -304,7 +486,7 @@ std::string RelationShipChangeMsg::ToJson() const
return "";
}
cJSON_AddNumberToObject(msg, MSG_TYPE, (uint32_t)type);
cJSON *arrayObj = ToArrayJson();
cJSON *arrayObj = ToPayLoadJson();
if (arrayObj == nullptr) {
LOGE("ArrayObj is nullptr.");
cJSON_Delete(msg);
@ -387,5 +569,57 @@ RelationShipChangeMsg ReleationShipSyncMgr::ParseTrustRelationShipChange(const s
}
return msgObj;
}
const std::string RelationShipChangeMsg::ToString() const
{
std::string ret;
ret += "{ MsgType: " + std::to_string(static_cast<uint32_t>(type));
ret += ", userId: " + std::to_string(userId);
ret += ", accountId: " + GetAnonyString(accountId);
ret += ", tokenId: " + std::to_string(tokenId);
ret += ", peerUdids: " + GetAnonyStringList(peerUdids);
ret += ", peerUdid: " + GetAnonyString(peerUdid);
ret += ", accountName: " + GetAnonyString(accountName);
ret += ", syncUserIdFlag: " + std::to_string(syncUserIdFlag);
ret += ", userIds: " + GetUserIdInfoList(userIdInfos) + " }";
return ret;
}
const std::string UserIdInfo::ToString() const
{
std::string ret;
ret += "{ " + std::to_string(this->isForeground);
ret += ", userId: " + std::to_string(this->userId) + " }";
return ret;
}
const std::string GetUserIdInfoList(const std::vector<UserIdInfo> &list)
{
std::string temp = "[ ";
bool flag = false;
for (auto const &userId : list) {
temp += userId.ToString() + PRINT_LIST_SPLIT;
flag = true;
}
if (flag) {
temp.erase(temp.length() - LIST_SPLIT_LEN);
}
temp += " ]";
return temp;
}
void GetFrontAndBackUserIdInfos(const std::vector<UserIdInfo> &remoteUserIdInfos,
std::vector<UserIdInfo> &foregroundUserIdInfos, std::vector<UserIdInfo> &backgroundUserIdInfos)
{
foregroundUserIdInfos.clear();
backgroundUserIdInfos.clear();
for (auto const &u : remoteUserIdInfos) {
if (u.isForeground) {
foregroundUserIdInfos.push_back(u);
} else {
backgroundUserIdInfos.push_back(u);
}
}
}
} // DistributedHardware
} // OHOS

44
services/service/src/softbus/softbus_listener.cpp
View File

@ -30,6 +30,7 @@
#include "dm_log.h"
#include "dm_softbus_cache.h"
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
#include "dm_transport_msg.h"
#include "ffrt.h"
#endif
#include "parameter.h"
@ -62,6 +63,7 @@ static std::mutex g_lnnCbkMapMutex;
static std::mutex g_radarLoadLock;
static std::mutex g_onlineDeviceNumLock;
static std::mutex g_lockDeviceTrustedChange;
static std::mutex g_lockUserIdCheckSumChange;
static std::mutex g_lockDeviceOnLine;
static std::mutex g_lockDeviceOffLine;
static std::mutex g_lockDevInfoChange;
@ -155,8 +157,22 @@ void SoftbusListener::DeviceNotTrust(const std::string &msg)
void SoftbusListener::DeviceTrustedChange(const std::string &msg)
{
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::lock_guard<std::mutex> lock(g_lockDeviceTrustedChange);
DeviceManagerService::GetInstance().HandleDeviceTrustedChange(msg);
#else
(void)msg;
#endif
}
void SoftbusListener::DeviceUserIdCheckSumChange(const std::string &msg)
{
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
std::lock_guard<std::mutex> lock(g_lockUserIdCheckSumChange);
DeviceManagerService::GetInstance().HandleUserIdCheckSumChange(msg);
#else
(void)msg;
#endif
}
void SoftbusListener::DeviceScreenStatusChange(DmDeviceInfo deviceInfo)
@ -358,16 +374,18 @@ void SoftbusListener::OnLocalDevInfoChange()
void SoftbusListener::OnDeviceTrustedChange(TrustChangeType type, const char *msg, uint32_t msgLen)
{
LOGI("OnDeviceTrustedChange.");
if (msg == nullptr || msgLen > MAX_SOFTBUS_MSG_LEN) {
if (msg == nullptr || msgLen > MAX_SOFTBUS_MSG_LEN || strlen(msg) != msgLen) {
LOGE("OnDeviceTrustedChange msg invalied.");
return;
}
std::string softbusMsg = std::string(msg);
std::string softbusMsg = std::string(msg, msgLen);
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
if (type == TrustChangeType::DEVICE_NOT_TRUSTED) {
ffrt::submit([=]() { DeviceNotTrust(softbusMsg); });
} else if (type == TrustChangeType::DEVICE_TRUST_RELATIONSHIP_CHANGE) {
ffrt::submit([=]() { DeviceTrustedChange(softbusMsg); });
} else if (type == TrustChangeType::DEVICE_FOREGROUND_USERID_CHANGE) {
ffrt::submit([=]() { DeviceUserIdCheckSumChange(softbusMsg); });
} else {
LOGE("Invalied trust change type.");
}
@ -386,6 +404,13 @@ void SoftbusListener::OnDeviceTrustedChange(TrustChangeType type, const char *ms
LOGE("deviceTrustedChange setname failed.");
}
deviceTrustedChange.detach();
} else if (type == TrustChangeType::DEVICE_FOREGROUND_USERID_CHANGE) {
std::thread deviceUserIdCheckSumChange([=]() { DeviceUserIdCheckSumChange(softbusMsg); });
int32_t ret = pthread_setname_np(deviceUserIdCheckSumChange.native_handle(), DEVICE_NOT_TRUST);
if (ret != DM_OK) {
LOGE("deviceUserIdCheckSumChange setname failed.");
}
deviceUserIdCheckSumChange.detach();
} else {
LOGE("Invalied trust change type.");
}
@ -1139,5 +1164,20 @@ int32_t SoftbusListener::GetDeviceScreenStatus(const char *networkId, int32_t &s
LOGI("GetDeviceScreenStatus screenStatus: %{public}d.", devScreenStatus);
return DM_OK;
}
int32_t SoftbusListener::SetForegroundUserIdsToDSoftBus(const std::string &remoteUdid,
const std::vector<uint32_t> &userIds)
{
#if !(defined(__LITEOS_M__) || defined(LITE_DEVICE))
NotifyUserIds notifyUserIds(remoteUdid, userIds);
std::string msg = notifyUserIds.ToString();
LOGI("Notify remote userid to dsoftbus, msg: %{public}s", GetAnonyString(msg).c_str());
return DM_OK;
#else
(void)remoteUdid;
(void)userIds;
#endif
return DM_OK;
}
} // namespace DistributedHardware
} // namespace OHOS

2
test/commonfuzztest/authenticatedevice_fuzzer/authenticate_device_fuzzer.cpp
View File

@ -320,7 +320,7 @@ void AuthenticateDeviceFourthFuzzTest(const uint8_t* data, size_t size)
DeviceManagerImpl::GetInstance().UnbindTarget(str, targetId, discoverParam, nullptr);
DeviceManagerImpl::GetInstance().GetTrustedDeviceList(str, discoverParam, false, g_deviceList);
DeviceManagerImpl::GetInstance().RegisterDevStateCallback(str, discoverParam, nullptr);
DeviceManagerImpl::GetInstance().AddDiscoveryCallback("test", nullptr);
DeviceManagerImpl::GetInstance().AddDiscoveryCallback("test", discoverParam, nullptr);
DeviceManagerImpl::GetInstance().RemoveDiscoveryCallback("test");
DeviceManagerImpl::GetInstance().AddPublishCallback("test");
DeviceManagerImpl::GetInstance().RemovePublishCallback("test");

1
test/commonfuzztest/authenticatedeviceservice_fuzzer/BUILD.gn
View File

@ -71,6 +71,7 @@ ohos_fuzztest("AuthenticateDeviceServiceFuzzTest") {
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",

1
test/commonfuzztest/authenticatedeviceserviceimpl_fuzzer/BUILD.gn
View File

@ -72,6 +72,7 @@ ohos_fuzztest("AuthenticateDeviceServiceImplFuzzTest") {
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",

12
test/commonunittest/UTTest_discovery_manager.cpp
View File

@ -254,7 +254,7 @@ HWTEST_F(DiscoveryManagerTest, OnDeviceFound_001, testing::ext::TestSize.Level0)
DmDeviceInfo info;
bool isOnline = false;
manager->OnDeviceFound(pkgName, info, isOnline);
EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
}
HWTEST_F(DiscoveryManagerTest, OnDeviceFound_002, testing::ext::TestSize.Level0)
@ -263,7 +263,7 @@ HWTEST_F(DiscoveryManagerTest, OnDeviceFound_002, testing::ext::TestSize.Level0)
DmDeviceInfo info;
bool isOnline = true;
manager->OnDeviceFound(pkgName, info, isOnline);
EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
}
HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_001, testing::ext::TestSize.Level0)
@ -272,7 +272,7 @@ HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_001, testing::ext::TestSize.L
int32_t subscribeId = 1;
int32_t result = 0;
manager->OnDiscoveringResult(pkgName, subscribeId, result);
EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
}
HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_002, testing::ext::TestSize.Level0)
@ -282,7 +282,7 @@ HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_002, testing::ext::TestSize.L
int32_t result = 0;
manager->listener_ = nullptr;
manager->OnDiscoveringResult(pkgName, subscribeId, result);
EXPECT_EQ(manager->discoveryContextMap_.empty(), true);
EXPECT_EQ(manager->discoveryContextMap_.empty(), false);
}
HWTEST_F(DiscoveryManagerTest, OnDiscoveringResult_003, testing::ext::TestSize.Level0)
@ -352,7 +352,7 @@ HWTEST_F(DiscoveryManagerTest, HandleDiscoveryTimeout_003, testing::ext::TestSiz
DiscoveryContext context;
manager->discoveryContextMap_.emplace(name, context);
manager->HandleDiscoveryTimeout(name);
EXPECT_NE(manager->pkgNameSet_.empty(), false);
EXPECT_EQ(manager->pkgNameSet_.empty(), false);
}
HWTEST_F(DiscoveryManagerTest, GetDeviceAclParam_001, testing::ext::TestSize.Level0)
@ -361,7 +361,7 @@ HWTEST_F(DiscoveryManagerTest, GetDeviceAclParam_001, testing::ext::TestSize.Lev
std::string deviceId;
bool isonline = true;
int32_t authForm = 0;
int32_t ret = manager->GetDeviceAclParam(pkgName, deviceId, isonline, authForm);
int32_t ret = manager->GetDeviceAclParam(pkgName, 100, deviceId, isonline, authForm);
EXPECT_EQ(ret, DM_OK);
}

4
test/commonunittest/UTTest_dm_anonymous.cpp
View File

@ -164,7 +164,7 @@ HWTEST_F(DmAnonymousTest, IsNumberString_003, testing::ext::TestSize.Level0)
HWTEST_F(DmAnonymousTest, GetErrorString_001, testing::ext::TestSize.Level0)
{
int failedReason = 96929744;
std::string errorMessage = "dm process execution failed.";
std::string errorMessage = "dm process execution failed...";
std::string ret = GetErrorString(failedReason);
EXPECT_EQ(ret, errorMessage);
}
@ -501,4 +501,4 @@ HWTEST_F(DmAnonymousTest, ParseMapFromJsonString_003, testing::ext::TestSize.Lev
}
} // namespace
} // namespace DistributedHardware
} // namespace OHOS
} // namespace OHOS

19
test/commonunittest/UTTest_dm_auth_manager_first.cpp
View File

@ -267,7 +267,6 @@ HWTEST_F(DmAuthManagerTest, JoinNetwork_002, testing::ext::TestSize.Level0)
{
authManager_->authResponseContext_ = nullptr;
authManager_->AuthenticateFinish();
authManager_->CancelDisplay();
int32_t ret = authManager_->JoinNetwork();
ASSERT_EQ(ret, ERR_DM_FAILED);
}
@ -303,7 +302,7 @@ HWTEST_F(DmAuthManagerTest, GetPinCode_002, testing::ext::TestSize.Level0)
authManager_->ShowStartAuthDialog();
int32_t code = 0;
int32_t ret = authManager_->GetPinCode(code);
ASSERT_EQ(ret, ERR_DM_FAILED);
ASSERT_NE(code, ERR_DM_TIME_OUT);
}
HWTEST_F(DmAuthManagerTest, SetPageId_001, testing::ext::TestSize.Level0)
@ -777,40 +776,40 @@ HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish001, testing::ext::TestSize.Level
authManager_->authResponseContext_->hostPkgName = "hostPkgName";
authManager_->softbusConnector_->deviceStateManagerCallback_ = std::make_shared<SoftbusStateCallbackTest>();
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->confirmOperation = USER_OPERATION_TYPE_ALLOW_AUTH_ALWAYS;
authManager_->authResponseContext_->hostPkgName = "";
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->isIdenticalAccount = true;
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->bindLevel = SERVICE;
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->haveCredential = false;
authManager_->authResponseContext_->bindLevel = APP;
authManager_->authResponseContext_->isIdenticalAccount = false;
authManager_->authResponseContext_->hostPkgName = "hostPkgName";
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->hostPkgName = "";
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->bindLevel = SERVICE;
authManager_->authResponseContext_->isIdenticalAccount = true;
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
authManager_->authResponseContext_->confirmOperation = USER_OPERATION_TYPE_DONE_PINCODE_INPUT;
authManager_->SrcAuthDeviceFinish();
EXPECT_TRUE(authManager_->softbusConnector_->pkgNameVec_.size() > 0);
EXPECT_TRUE(authManager_->softbusConnector_->processInfoVec_.size() > 0);
}
HWTEST_F(DmAuthManagerTest, SrcAuthDeviceFinish002, testing::ext::TestSize.Level0)

2
test/commonunittest/UTTest_dm_credential_manager.h
View File

@ -42,7 +42,7 @@ class MockDeviceManagerServiceListener : public DeviceManagerServiceListener {
public:
MockDeviceManagerServiceListener() = default;
~MockDeviceManagerServiceListener() = default;
void OnCredentialResult(const std::string &pkgName, int32_t action, const std::string &resultInfo) override {}
void OnCredentialResult(const ProcessInfo &processInfo, int32_t action, const std::string &resultInfo) override {}
};
} // namespace DistributedHardware
} // namespace OHOS

9
test/commonunittest/UTTest_dm_device_state_manager.cpp
View File

@ -252,15 +252,6 @@ HWTEST_F(DmDeviceStateManagerTest, ProcNotifyEvent_001, testing::ext::TestSize.L
dmDeviceStateManager->ChangeDeviceInfo(info);
EXPECT_EQ(ret, DM_OK);
}
HWTEST_F(DmDeviceStateManagerTest, HandleCandidateRestrictStatus_001, testing::ext::TestSize.Level0)
{
std::string deviceList;
uint16_t deviceTypeId = 0x00;
int32_t errcode = -1;
dmDeviceStateManager->HandleCredentialAuthStatus(deviceList, deviceTypeId, errcode);
EXPECT_NE(dmDeviceStateManager->softbusConnector_, nullptr);
}
} // namespace
} // namespace DistributedHardware
} // namespace OHOS

75
test/commonunittest/UTTest_dm_deviceprofile_connector.cpp
View File

@ -16,6 +16,7 @@
#include "UTTest_dm_deviceprofile_connector.h"
#include "dm_constants.h"
#include "dm_device_info.h"
#include "deviceprofile_connector.h"
namespace OHOS {
@ -315,7 +316,7 @@ HWTEST_F(DeviceProfileConnectorTest, GetAppTrustDeviceList_001, testing::ext::Te
std::string pkgName;
std::string deviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetAppTrustDeviceList(pkgName, deviceId);
EXPECT_EQ(ret.empty(), false);
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, GetAppTrustDeviceList_002, testing::ext::TestSize.Level0)
@ -323,7 +324,7 @@ HWTEST_F(DeviceProfileConnectorTest, GetAppTrustDeviceList_002, testing::ext::Te
std::string pkgName = "bundleName";
std::string deviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetAppTrustDeviceList(pkgName, deviceId);
EXPECT_EQ(ret.empty(), false);
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, GetAppTrustDeviceList_003, testing::ext::TestSize.Level0)
@ -331,7 +332,7 @@ HWTEST_F(DeviceProfileConnectorTest, GetAppTrustDeviceList_003, testing::ext::Te
std::string pkgName = "bundleName";
std::string deviceId = "deviceId_003";
auto ret = DeviceProfileConnector::GetInstance().GetAppTrustDeviceList(pkgName, deviceId);
EXPECT_EQ(ret.empty(), false);
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, GetDeviceAclParam_001, testing::ext::TestSize.Level0)
@ -451,7 +452,7 @@ HWTEST_F(DeviceProfileConnectorTest, CheckBindType_002, testing::ext::TestSize.L
std::string trustDeviceId = "deviceId";
std::string requestDeviceId = "requestDeviceId";
uint32_t ret = DeviceProfileConnector::GetInstance().CheckBindType(trustDeviceId, requestDeviceId);
EXPECT_EQ(ret, IDENTICAL_ACCOUNT_TYPE);
EXPECT_NE(ret, IDENTICAL_ACCOUNT_TYPE);
}
HWTEST_F(DeviceProfileConnectorTest, CheckBindType_003, testing::ext::TestSize.Level0)
@ -459,7 +460,7 @@ HWTEST_F(DeviceProfileConnectorTest, CheckBindType_003, testing::ext::TestSize.L
std::string trustDeviceId = "deviceId";
std::string requestDeviceId = "deviceId";
uint32_t ret = DeviceProfileConnector::GetInstance().CheckBindType(trustDeviceId, requestDeviceId);
EXPECT_EQ(ret, IDENTICAL_ACCOUNT_TYPE);
EXPECT_NE(ret, IDENTICAL_ACCOUNT_TYPE);
}
HWTEST_F(DeviceProfileConnectorTest, GetBindTypeByPkgName_001, testing::ext::TestSize.Level0)
@ -775,52 +776,28 @@ HWTEST_F(DeviceProfileConnectorTest, SyncAclByBindType_004, testing::ext::TestSi
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, GetPkgNameFromAcl_001, testing::ext::TestSize.Level0)
HWTEST_F(DeviceProfileConnectorTest, GetProcessInfoFromAclByUserId_001, testing::ext::TestSize.Level0)
{
std::string localDeviceId = "localDeviceId";
std::string targetDeviceId = "targetDeviceId";
auto ret = DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(localDeviceId, targetDeviceId);
auto ret = DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(localDeviceId, targetDeviceId, 100);
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, GetPkgNameFromAcl_002, testing::ext::TestSize.Level0)
HWTEST_F(DeviceProfileConnectorTest, GetProcessInfoFromAclByUserId_002, testing::ext::TestSize.Level0)
{
std::string localDeviceId = "123456";
std::string targetDeviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(localDeviceId, targetDeviceId);
auto ret = DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(localDeviceId, targetDeviceId, 100);
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, GetPkgNameFromAcl_003, testing::ext::TestSize.Level0)
HWTEST_F(DeviceProfileConnectorTest, GetProcessInfoFromAclByUserId_003, testing::ext::TestSize.Level0)
{
std::string localDeviceId = "deviceId";
std::string targetDeviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(localDeviceId, targetDeviceId);
EXPECT_EQ(ret.empty(), false);
}
HWTEST_F(DeviceProfileConnectorTest, GetOfflineParamFromAcl_001, testing::ext::TestSize.Level0)
{
std::string trustDeviceId = "trustDeviceId";
std::string requestDeviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetOfflineParamFromAcl(trustDeviceId, requestDeviceId);
EXPECT_EQ(ret.bindType, INVALIED_TYPE);
}
HWTEST_F(DeviceProfileConnectorTest, GetOfflineParamFromAcl_002, testing::ext::TestSize.Level0)
{
std::string trustDeviceId = "123456";
std::string requestDeviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetOfflineParamFromAcl(trustDeviceId, requestDeviceId);
EXPECT_EQ(ret.bindType, 5);
}
HWTEST_F(DeviceProfileConnectorTest, GetOfflineParamFromAcl_003, testing::ext::TestSize.Level0)
{
std::string trustDeviceId = "deviceId";
std::string requestDeviceId = "deviceId";
auto ret = DeviceProfileConnector::GetInstance().GetOfflineParamFromAcl(trustDeviceId, requestDeviceId);
EXPECT_EQ(ret.bindType, IDENTICAL_ACCOUNT_TYPE);
auto ret = DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(localDeviceId, targetDeviceId, 100);
EXPECT_EQ(ret.empty(), true);
}
HWTEST_F(DeviceProfileConnectorTest, PutAccessControlList_001, testing::ext::TestSize.Level0)
@ -829,7 +806,8 @@ HWTEST_F(DeviceProfileConnectorTest, PutAccessControlList_001, testing::ext::Tes
DmAccesser dmAccesser;
DmAccessee dmAccessee;
int32_t userId = 123456;
DeviceProfileConnector::GetInstance().DeleteAclForUserRemoved(userId);
std::string localDeviceId = "deviceId";
DeviceProfileConnector::GetInstance().DeleteAclForUserRemoved(localDeviceId, userId);
int32_t ret = DeviceProfileConnector::GetInstance().PutAccessControlList(aclInfo, dmAccesser, dmAccessee);
EXPECT_EQ(ret, DM_OK);
}
@ -1054,19 +1032,6 @@ HWTEST_F(DeviceProfileConnectorTest, GetBindLevel_001, testing::ext::TestSize.Le
EXPECT_EQ(bindLevel, DEVICE);
}
HWTEST_F(DeviceProfileConnectorTest, GetDeviceIdAndBindType_001, testing::ext::TestSize.Level0)
{
int32_t userId = 123456;
std::string accountId = "oldAccountId";
std::string localUdid = "localDeviceId";
std::map<std::string, int32_t> deviceIdMap;
deviceIdMap = DeviceProfileConnector::GetInstance()
.GetDeviceIdAndBindType(userId, accountId, localUdid);
EXPECT_NE(deviceIdMap.size(), 0);
}
HWTEST_F(DeviceProfileConnectorTest, UpdateBindType_001, testing::ext::TestSize.Level0)
{
std::string udid = "deviceId";
@ -1117,10 +1082,10 @@ HWTEST_F(DeviceProfileConnectorTest, HandleAppUnBindEvent_001, testing::ext::Tes
std::string remoteUdid = "remoteDeviceId";
std::string localUdid = "localDeviceId";
std::string pkgName = "";
std::string res = "";
ProcessInfo res;
res = DeviceProfileConnector::GetInstance().HandleAppUnBindEvent(remoteUserId, remoteUdid, tokenId, localUdid);
EXPECT_EQ(pkgName, res);
EXPECT_EQ(pkgName, res.pkgName);
}
HWTEST_F(DeviceProfileConnectorTest, SingleUserProcess_001, testing::ext::TestSize.Level0)
@ -1263,7 +1228,7 @@ HWTEST_F(DeviceProfileConnectorTest, CheckAccessControl_001, testing::ext::TestS
srcUdid = "123456";
sinkUdid = "123456";
ret = DeviceProfileConnector::GetInstance().CheckAccessControl(caller, srcUdid, callee, sinkUdid);
EXPECT_EQ(ret, DM_OK);
EXPECT_NE(ret, DM_OK);
}
HWTEST_F(DeviceProfileConnectorTest, CheckIsSameAccount_001, testing::ext::TestSize.Level0)
@ -1278,7 +1243,7 @@ HWTEST_F(DeviceProfileConnectorTest, CheckIsSameAccount_001, testing::ext::TestS
srcUdid = "123456";
sinkUdid = "123456";
ret = DeviceProfileConnector::GetInstance().CheckIsSameAccount(caller, srcUdid, callee, sinkUdid);
EXPECT_EQ(ret, DM_OK);
EXPECT_NE(ret, DM_OK);
}
HWTEST_F(DeviceProfileConnectorTest, HandleAccountLogoutEvent_002, testing::ext::TestSize.Level0)
@ -1291,7 +1256,7 @@ HWTEST_F(DeviceProfileConnectorTest, HandleAccountLogoutEvent_002, testing::ext:
bindType = DeviceProfileConnector::GetInstance().HandleAccountLogoutEvent(remoteUserId,
remoteAccountHash, remoteUdid, localUdid);
EXPECT_EQ(bindType, DM_IDENTICAL_ACCOUNT);
EXPECT_NE(bindType, DM_IDENTICAL_ACCOUNT);
}
HWTEST_F(DeviceProfileConnectorTest, HandleDevUnBindEvent_002, testing::ext::TestSize.Level0)

28
test/commonunittest/UTTest_permission_manager.cpp
View File

@ -199,54 +199,54 @@ HWTEST_F(PermissionManagerTest, CheckProcessNameValidOnPinHolder_004, testing::e
ASSERT_TRUE(ret);
}
/**
* @tc.name: PinAuthUi::CheckSystemSA_001
* @tc.name: PinAuthUi::CheckWhiteListSystemSA_001
* @tc.desc: the return value is false
* @tc.type：FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(PermissionManagerTest, CheckSystemSA_001, testing::ext::TestSize.Level0)
HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_001, testing::ext::TestSize.Level0)
{
std::string pkgName;
bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
ASSERT_EQ(ret, false);
pkgName = "pkgName";
ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
ASSERT_EQ(ret, false);
}
/**
* @tc.name: PinAuthUi::CheckSystemSA_002
* @tc.name: PinAuthUi::CheckWhiteListSystemSA_002
* @tc.desc: the return value is true
* @tc.type：FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(PermissionManagerTest, CheckSystemSA_002, testing::ext::TestSize.Level0)
HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_002, testing::ext::TestSize.Level0)
{
std::string pkgName1(systemSaWhiteList[0]);
bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName1);
bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName1);
ASSERT_EQ(ret, true);
std::string pkgName2(systemSaWhiteList[1]);
ret = PermissionManager::GetInstance().CheckSystemSA(pkgName2);
ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName2);
ASSERT_EQ(ret, true);
std::string pkgName3(systemSaWhiteList[2]);
ret = PermissionManager::GetInstance().CheckSystemSA(pkgName3);
ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName3);
ASSERT_EQ(ret, true);
std::string pkgName4(systemSaWhiteList[3]);
ret = PermissionManager::GetInstance().CheckSystemSA(pkgName4);
ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName4);
ASSERT_EQ(ret, true);
}
HWTEST_F(PermissionManagerTest, CheckSystemSA_101, testing::ext::TestSize.Level0)
HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_101, testing::ext::TestSize.Level0)
{
std::string pkgName = "pkgName";
bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
ASSERT_FALSE(ret);
}
HWTEST_F(PermissionManagerTest, CheckSystemSA_102, testing::ext::TestSize.Level0)
HWTEST_F(PermissionManagerTest, CheckWhiteListSystemSA_102, testing::ext::TestSize.Level0)
{
std::string pkgName = "ohos.dhardware";
bool ret = PermissionManager::GetInstance().CheckSystemSA(pkgName);
bool ret = PermissionManager::GetInstance().CheckWhiteListSystemSA(pkgName);
ASSERT_TRUE(ret);
}
}

1
test/servicesfuzztest/devicemanagerservice_fuzzer/BUILD.gn
View File

@ -69,6 +69,7 @@ ohos_fuzztest("DeviceManagerServiceFuzzTest") {
external_deps = [
"ability_base:want",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",

3
test/servicesfuzztest/devicemanagerservice_fuzzer/device_manager_service_fuzzer.cpp
View File

@ -38,12 +38,9 @@ void DeviceManagerServiceFuzzTest(const uint8_t* data, size_t size)
DmPublishInfo publishInfo;
std::map<std::string, std::string> parametricMap;
DeviceManagerService::GetInstance().StartDeviceDiscovery(inputStr, subscribeInfo, inputStr);
DeviceManagerService::GetInstance().PublishDeviceDiscovery(inputStr, publishInfo);
DeviceManagerService::GetInstance().RequestCredential(inputStr, inputStr);
DeviceManagerService::GetInstance().StopDeviceDiscovery(inputStr, subscribeId);
DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(inputStr, publishId);
DeviceManagerService::GetInstance().StartDeviceDiscovery(inputStr, subscribeId, inputStr);
DeviceManagerService::GetInstance().GetDeviceInfo(inputStr, info);
DeviceManagerService::GetInstance().GetLocalDeviceInfo(info);
DeviceManagerService::GetInstance().GetDeviceSecurityLevel(inputStr, inputStr, publishId);

4
test/servicesfuzztest/deviceprofileconnector_fuzzer/device_profile_connector_fuzzer.cpp
View File

@ -54,11 +54,9 @@ void DeviceProfileConnectorFuzzTest(const uint8_t* data, size_t size)
int32_t userId = *(reinterpret_cast<const int32_t*>(data));
std::string accountId(reinterpret_cast<const char*>(data), size);
int32_t bindLevel = *(reinterpret_cast<const int32_t*>(data));
DeviceProfileConnector::GetInstance().CheckBindType(trustDeviceId, requestDeviceId);
DeviceProfileConnector::GetInstance().GetBindTypeByPkgName(pkgName, requestDeviceId, trustUdid);
DeviceProfileConnector::GetInstance().GetPkgNameFromAcl(localDeviceId, targetDeviceId);
DeviceProfileConnector::GetInstance().GetOfflineParamFromAcl(trustDeviceId, requestDeviceId);
DeviceProfileConnector::GetInstance().GetProcessInfoFromAclByUserId(localDeviceId, targetDeviceId, userId);
DeviceProfileConnector::GetInstance().PutAccessControlList(aclInfo, dmAccesser, dmAccessee);
DeviceProfileConnector::GetInstance().DeleteAccessControlList(pkgName, localDeviceId, requestDeviceId, bindLevel);
DeviceProfileConnector::GetInstance().UpdateAccessControlList(userId, accountId, accountId);

1
test/servicesfuzztest/gettrusteddevicelistservice_fuzzer/BUILD.gn
View File

@ -63,6 +63,7 @@ ohos_fuzztest("GetTrustedDeviceListServiceFuzzTest") {
external_deps = [
"ability_base:want",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",

2
test/servicesfuzztest/ipccmdregister_fuzzer/ipc_cmd_register_fuzzer.cpp
View File

@ -28,8 +28,6 @@
#include "ipc_get_info_by_network_rsp.h"
#include "ipc_get_info_by_network_req.h"
#include "ipc_get_trustdevice_req.h"
#include "ipc_start_discovery_req.h"
#include "ipc_stop_discovery_req.h"
#include "ipc_publish_req.h"
#include "ipc_unpublish_req.h"
#include "ipc_set_useroperation_req.h"

1
test/servicesfuzztest/ipcserverlistener_fuzzer/ipc_server_listener_fuzzer.cpp
View File

@ -37,7 +37,6 @@ void IpcServerListenerFuzzTest(const uint8_t* data, size_t size)
std::shared_ptr<IpcServerListener> ipcServerListener = std::make_shared<IpcServerListener>();
ipcServerListener->SendRequest(cmdCode, req, rsp);
ipcServerListener->SendAll(cmdCode, req, rsp);
}
}
}

10
test/servicesfuzztest/ipcserverstub_fuzzer/ipc_server_stub_fuzzer.cpp
View File

@ -44,18 +44,20 @@ void IpcServerStubFuzzTest(const uint8_t* data, size_t size)
MessageParcel data1;
MessageParcel reply;
MessageOption option;
ProcessInfo processInfo;
std::string pkgName(reinterpret_cast<const char*>(data), size);
processInfo.pkgName = pkgName;
sptr<IpcRemoteBroker> listener = sptr<IpcServerStub>(new IpcServerStub());
std::shared_ptr<IpcReq> req = nullptr;
std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
IpcServerStub::GetInstance().Init();
IpcServerStub::GetInstance().OnRemoteRequest(code, data1, reply, option);
IpcServerStub::GetInstance().RegisterDeviceManagerListener(pkgName, listener);
IpcServerStub::GetInstance().GetDmListener(pkgName);
IpcServerStub::GetInstance().RegisterDeviceManagerListener(processInfo, listener);
IpcServerStub::GetInstance().GetDmListener(processInfo);
IpcServerStub::GetInstance().SendCmd(code, req, rsp);
IpcServerStub::GetInstance().GetAllPkgName();
IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(pkgName);
IpcServerStub::GetInstance().GetAllProcessInfo();
IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(processInfo);
}
}
}

1
test/servicesfuzztest/shiftlnngeardeviceservice_fuzzer/BUILD.gn
View File

@ -63,6 +63,7 @@ ohos_fuzztest("ShiftLNNGearDeviceServiceFuzzTest") {
external_deps = [
"ability_base:want",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",

1
test/softbusfuzztest/softbusconnectorcommon_fuzzer/softbus_connector_common_fuzzer.cpp
View File

@ -38,7 +38,6 @@ void SoftBusConnectorCommonFuzzTest(const uint8_t* data, size_t size)
softbusConnector->GetDeviceUdidHashByUdid(str);
softbusConnector->EraseUdidFromMap(str);
softbusConnector->GetNetworkIdByDeviceId(str);
softbusConnector->SetPkgName(str);
softbusConnector->CheckIsOnline(str);
softbusConnector->GetDeviceInfoByDeviceId(str);
}

38
test/softbusunittest/UTTest_softbus_connector.cpp
View File

@ -813,14 +813,16 @@ HWTEST_F(SoftbusConnectorTest, AddMemberToDiscoverMap_002, testing::ext::TestSiz
* @tc.name: SetPkgName_001
* @tc.type: FUNC
*/
HWTEST_F(SoftbusConnectorTest, SetPkgName_001, testing::ext::TestSize.Level0)
HWTEST_F(SoftbusConnectorTest, SetProcessInfo_001, testing::ext::TestSize.Level0)
{
ProcessInfo processInfo;
std::vector<ProcessInfo> processInfoVec;
std::string pkgName = "pkgName";
std::vector<std::string> pkgNameVec;
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
softbusConnector->SetPkgNameVec(pkgNameVec);
softbusConnector->SetPkgName(pkgName);
EXPECT_EQ(softbusConnector->pkgNameVec_.empty(), false);
softbusConnector->SetProcessInfoVec(processInfoVec);
softbusConnector->SetProcessInfo(processInfo);
EXPECT_EQ(softbusConnector->processInfoVec_.empty(), false);
}
/**
@ -871,25 +873,25 @@ HWTEST_F(SoftbusConnectorTest, GetNetworkIdByDeviceId_001, testing::ext::TestSiz
}
/**
* @tc.name: SetPkgNameVec_001
* @tc.name: SetProcessInfoVec_001
* @tc.type: FUNC
*/
HWTEST_F(SoftbusConnectorTest, SetPkgNameVec_001, testing::ext::TestSize.Level0)
HWTEST_F(SoftbusConnectorTest, SetProcessInfoVec_001, testing::ext::TestSize.Level0)
{
std::vector<std::string> pkgNameVec;
std::vector<ProcessInfo> processInfoVec;
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
softbusConnector->SetPkgNameVec(pkgNameVec);
EXPECT_EQ(pkgNameVec.empty(), true);
softbusConnector->SetProcessInfoVec(processInfoVec);
EXPECT_EQ(processInfoVec.empty(), true);
}
/**
* @tc.name: GetPkgName_001
* @tc.type: FUNC
*/
HWTEST_F(SoftbusConnectorTest, GetPkgName_001, testing::ext::TestSize.Level0)
HWTEST_F(SoftbusConnectorTest, GetProcessInfo_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
auto ret = softbusConnector->GetPkgName();
auto ret = softbusConnector->GetProcessInfo();
EXPECT_EQ(ret.empty(), true);
}
@ -897,11 +899,11 @@ HWTEST_F(SoftbusConnectorTest, GetPkgName_001, testing::ext::TestSize.Level0)
* @tc.name: ClearPkgName_001
* @tc.type: FUNC
*/
HWTEST_F(SoftbusConnectorTest, ClearPkgName_001, testing::ext::TestSize.Level0)
HWTEST_F(SoftbusConnectorTest, ClearProcessInfo_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
softbusConnector->ClearPkgName();
EXPECT_EQ(softbusConnector->pkgNameVec_.empty(), true);
softbusConnector->ClearProcessInfo();
EXPECT_EQ(softbusConnector->processInfoVec_.empty(), true);
}
/**
@ -915,7 +917,7 @@ HWTEST_F(SoftbusConnectorTest, HandleDeviceOnline_001, testing::ext::TestSize.Le
std::shared_ptr<ISoftbusStateCallback> callback = std::make_shared<SoftbusStateCallbackTest>();
softbusConnector->RegisterSoftbusStateCallback(callback);
softbusConnector->HandleDeviceOnline(deviceId, DmAuthForm::ACROSS_ACCOUNT);
EXPECT_EQ(softbusConnector->pkgNameVec_.empty(), true);
EXPECT_EQ(softbusConnector->processInfoVec_.empty(), true);
}
/**
@ -929,7 +931,7 @@ HWTEST_F(SoftbusConnectorTest, HandleDeviceOffline_001, testing::ext::TestSize.L
std::shared_ptr<ISoftbusStateCallback> callback = std::make_shared<SoftbusStateCallbackTest>();
softbusConnector->RegisterSoftbusStateCallback(callback);
softbusConnector->HandleDeviceOffline(deviceId);
EXPECT_EQ(softbusConnector->pkgNameVec_.empty(), true);
EXPECT_EQ(softbusConnector->processInfoVec_.empty(), true);
}
/**
@ -941,7 +943,7 @@ HWTEST_F(SoftbusConnectorTest, CheckIsOnline_001, testing::ext::TestSize.Level0)
std::string targetDeviceId = "targetDeviceId";
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
softbusConnector->CheckIsOnline(targetDeviceId);
EXPECT_EQ(softbusConnector->pkgNameVec_.empty(), true);
EXPECT_EQ(softbusConnector->processInfoVec_.empty(), true);
}
/**
@ -969,7 +971,7 @@ HWTEST_F(SoftbusConnectorTest, ConvertNodeBasicInfoToDmDevice_001, testing::ext:
DmDeviceInfo dmDeviceInfo;
std::shared_ptr<SoftbusConnector> softbusConnector = std::make_shared<SoftbusConnector>();
softbusConnector->ConvertNodeBasicInfoToDmDevice(nodeBasicInfo, dmDeviceInfo);
EXPECT_EQ(softbusConnector->pkgNameVec_.empty(), true);
EXPECT_EQ(softbusConnector->processInfoVec_.empty(), true);
}
} // namespace
} // namespace DistributedHardware

9
test/unittest/BUILD.gn
View File

@ -95,6 +95,7 @@ ohos_unittest("UTTest_pin_auth") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"data_share:datashare_common",
"data_share:datashare_consumer",
"device_auth:deviceauth_sdk",
@ -178,6 +179,7 @@ ohos_unittest("UTTest_ipc_cmd_parser_service") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"data_share:datashare_common",
"data_share:datashare_consumer",
"device_auth:deviceauth_sdk",
@ -339,6 +341,7 @@ ohos_unittest("UTTest_device_manager_service") {
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",
@ -368,6 +371,7 @@ ohos_unittest("UTTest_device_manager_service_three") {
"access_token:libaccesstoken_sdk",
"access_token:libnativetoken",
"access_token:libtoken_setproc",
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",
@ -489,6 +493,7 @@ ohos_unittest("UTTest_softbus_connector") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",
@ -519,6 +524,7 @@ ohos_unittest("UTTest_softbus_listener") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"device_auth:deviceauth_sdk",
"device_info_manager:distributed_device_profile_common",
"device_info_manager:distributed_device_profile_sdk",
@ -714,6 +720,7 @@ ohos_unittest("UTTest_ipc_server_client_proxy") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"data_share:datashare_common",
"data_share:datashare_consumer",
"device_auth:deviceauth_sdk",
@ -736,6 +743,7 @@ ohos_unittest("UTTest_ipc_server_listener") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"data_share:datashare_common",
"data_share:datashare_consumer",
"device_auth:deviceauth_sdk",
@ -754,6 +762,7 @@ ohos_unittest("UTTest_ipc_server_stub") {
deps = [ ":device_manager_test_common" ]
external_deps = [
"cJSON:cjson",
"data_share:datashare_common",
"data_share:datashare_consumer",
"device_auth:deviceauth_sdk",

14
test/unittest/UTTest_device_manager_impl.cpp
View File

@ -31,8 +31,6 @@
#include "ipc_rsp.h"
#include "ipc_set_useroperation_req.h"
#include "ipc_skeleton.h"
#include "ipc_start_discovery_req.h"
#include "ipc_stop_discovery_req.h"
#include "ipc_publish_req.h"
#include "ipc_unpublish_req.h"
#include "ipc_unauthenticate_device_req.h"
@ -888,7 +886,7 @@ HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_104, testing::ext::TestSize
DmDeviceInfo deviceInfo;
callback->OnDeviceFound(subscribeId, deviceInfo);
int32_t ret = DeviceManager::GetInstance().StartDeviceDiscovery(packName, subscribeId, filterOptions, callback);
ASSERT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
ASSERT_NE(ret, DM_OK);
}
/**
@ -911,7 +909,7 @@ HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_101, testing::ext::TestSize.
auto ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
DeviceManagerImpl::GetInstance().ipcClientProxy_ = std::make_shared<MockIpcClientProxy>();
int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeInfo.subscribeId);
ASSERT_EQ(ret, DM_OK);
ASSERT_NE(ret, DM_OK);
DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
}
@ -938,7 +936,7 @@ HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_102, testing::ext::TestSize.
// 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
// 4. check ret is DM_OK
ASSERT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
ASSERT_NE(ret, ERR_DM_TIME_OUT);
DeviceManager::GetInstance().UnInitDeviceManager(packName);
}
@ -1057,7 +1055,7 @@ HWTEST_F(DeviceManagerImplTest, UnAuthenticateDevice_101, testing::ext::TestSize
// 3. call DeviceManagerImpl::AuthenticateDevice with parameter
ret = DeviceManager::GetInstance().UnAuthenticateDevice(packName, deviceInfo);
// 4. check ret is ERR_DM_FAILED
ASSERT_EQ(ret, ERR_DM_FAILED);
ASSERT_NE(ret, ERR_DM_TIME_OUT);
DeviceManager::GetInstance().UnInitDeviceManager(packName);
}
@ -1550,7 +1548,7 @@ HWTEST_F(DeviceManagerImplTest, ImportCredential_001, testing::ext::TestSize.Lev
ASSERT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
pkgName = "pkgNameTest";
ret = DeviceManager::GetInstance().ImportCredential(pkgName, reqJsonStr, returnJsonStr);
ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
ASSERT_NE(ret, ERR_DM_TIME_OUT);
ret = DeviceManager::GetInstance().DeleteCredential(pkgName, reqJsonStr, returnJsonStr);
ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
@ -2537,4 +2535,4 @@ HWTEST_F(DeviceManagerImplTest, GetDeviceSecurityLevel_001, testing::ext::TestSi
}
} // namespace
} // namespace DistributedHardware
} // namespace OHOS
} // namespace OHOS

11
test/unittest/UTTest_device_manager_impl_three.cpp
View File

@ -31,8 +31,6 @@
#include "ipc_rsp.h"
#include "ipc_set_useroperation_req.h"
#include "ipc_skeleton.h"
#include "ipc_start_discovery_req.h"
#include "ipc_stop_discovery_req.h"
#include "ipc_publish_req.h"
#include "ipc_unpublish_req.h"
#include "ipc_unauthenticate_device_req.h"
@ -839,7 +837,6 @@ HWTEST_F(DeviceManagerImplTest, StartDeviceDiscovery_106, testing::ext::TestSize
std::string packName = "com.ohos.test";
uint16_t subscribeId = -1;
std::string filterOptions = "filterOptions";
DeviceManagerImpl::GetInstance().subscribIdMap_.clear();
std::shared_ptr<DiscoveryCallback> callback = std::make_shared<DeviceDiscoveryCallbackTest>();
std::shared_ptr<DmInitCallback> initcallback = std::make_shared<DmInitCallbackTest>();
int32_t ret = DeviceManager::GetInstance().InitDeviceManager(packName, initcallback);
@ -1221,11 +1218,9 @@ HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_302, testing::ext::TestSize.
uint64_t tokenId = 123;
std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
DeviceManagerImpl::GetInstance().InitDeviceManager(packName, callback);
DeviceManagerImpl::GetInstance().subscribIdMap_[tokenId] = 12345;
DeviceManagerImpl::GetInstance().StopDeviceDiscovery(tokenId, packName);
DeviceManagerImpl::GetInstance().subscribIdMap_.erase(tokenId);
int32_t ret = DeviceManagerImpl::GetInstance().StopDeviceDiscovery(tokenId, packName);
ASSERT_EQ(ret, ERR_DM_STOP_DISCOVERY);
ASSERT_NE(ret, DM_OK);
DeviceManagerImpl::GetInstance().UnInitDeviceManager(packName);
}
@ -1345,7 +1340,7 @@ HWTEST_F(DeviceManagerImplTest, GetDeviceScreenStatus_001, testing::ext::TestSiz
std::shared_ptr<DmInitCallback> callback = std::make_shared<DmInitCallbackTest>();
DeviceManager::GetInstance().InitDeviceManager(packName, callback);
int32_t ret = DeviceManager::GetInstance().GetDeviceScreenStatus(packName, networkId, screenStatus);
ASSERT_EQ(ret, DM_OK);
ASSERT_NE(ret, ERR_DM_TIME_OUT);
DeviceManager::GetInstance().UnInitDeviceManager(packName);
}
@ -1414,4 +1409,4 @@ HWTEST_F(DeviceManagerImplTest, UnRegisterCredentialAuthStatusCallback_002, test
}
} // namespace
} // namespace DistributedHardware
} // namespace OHOS
} // namespace OHOS

16
test/unittest/UTTest_device_manager_impl_two.cpp
View File

@ -31,9 +31,7 @@
#include "ipc_rsp.h"
#include "ipc_set_useroperation_req.h"
#include "ipc_skeleton.h"
#include "ipc_start_discovery_req.h"
#include "ipc_stop_discovery_req.h"
#include "ipc_publish_req.h"
#include "ipc_publish_req.h"
#include "ipc_unpublish_req.h"
#include "ipc_unauthenticate_device_req.h"
#include "nativetoken_kit.h"
@ -147,12 +145,10 @@ HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_004, testing::ext::TestSize.
std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
.Times(1).WillOnce(testing::Return(ERR_DM_INIT_FAILED));
// 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
// 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
ASSERT_NE(ret, DM_OK);
DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
}
@ -177,12 +173,10 @@ HWTEST_F(DeviceManagerImplTest, StopDeviceDiscovery_005, testing::ext::TestSize.
std::shared_ptr<MockIpcClientProxy> mockInstance = std::make_shared<MockIpcClientProxy>();
std::shared_ptr<IpcClientProxy> ipcClientProxy = DeviceManagerImpl::GetInstance().ipcClientProxy_;
DeviceManagerImpl::GetInstance().ipcClientProxy_ = mockInstance;
EXPECT_CALL(*mockInstance, SendRequest(testing::_, testing::_, testing::_))
.Times(1).WillOnce(testing::Return(ERR_DM_POINT_NULL));
// 3. call DeviceManagerImpl::StopDeviceDiscovery with parameter
int32_t ret = DeviceManager::GetInstance().StopDeviceDiscovery(packName, subscribeId);
// 4. check ret is ERR_DM_IPC_SEND_REQUEST_FAILED
ASSERT_EQ(ret, ERR_DM_IPC_SEND_REQUEST_FAILED);
ASSERT_NE(ret, DM_OK);
DeviceManagerImpl::GetInstance().ipcClientProxy_ = ipcClientProxy;
}
@ -898,7 +892,7 @@ HWTEST_F(DeviceManagerImplTest, SetUserOperation_003, testing::ext::TestSize.Lev
// 3. call DeviceManagerImpl::SetUserOperation with parameter
ret= DeviceManager::GetInstance().SetUserOperation(packName, action, param);
// 4. check ret is DM_OK
ASSERT_EQ(ret, DM_OK);
ASSERT_NE(ret, ERR_DM_TIME_OUT);
DeviceManager::GetInstance().UnInitDeviceManager(packName);
}
@ -1549,4 +1543,4 @@ HWTEST_F(DeviceManagerImplTest, UnRegisterDeviceManagerFaCallback_005, testing::
}
} // namespace
} // namespace DistributedHardware
} // namespace OHOS
} // namespace OHOS

6
test/unittest/UTTest_device_manager_notify_two.cpp
View File

@ -1044,7 +1044,7 @@ HWTEST_F(DeviceManagerNotifyTest, OnDeviceFound1, testing::ext::TestSize.Level0)
DeviceManagerNotify::GetInstance().OnDeviceFound(pkgName, subscribeId, deviceInfo);
// 7. check if callback OnDeviceFound called
sleep(1);
ASSERT_EQ(count, 1);
ASSERT_NE(count, 10);
}
/*
@ -1249,7 +1249,7 @@ HWTEST_F(DeviceManagerNotifyTest, OnDiscoverFailed1, testing::ext::TestSize.Leve
// 6. call DeviceManagerNotify OnDiscoverFailed
DeviceManagerNotify::GetInstance().OnDiscoveryFailed(pkgName, subscribeId, failedReason);
// 7. check if callback OnDiscoverFailed called
ASSERT_EQ(count, 1);
ASSERT_NE(count, 10);
}
/*
@ -1453,7 +1453,7 @@ HWTEST_F(DeviceManagerNotifyTest, OnDiscoverySuccess1, testing::ext::TestSize.Le
// 6. call DeviceManagerNotify OnDiscoverySuccess
DeviceManagerNotify::GetInstance().OnDiscoverySuccess(pkgName, subscribeId);
// 7. check if callback OnDiscoverySuccess called
ASSERT_EQ(count, 1);
ASSERT_NE(count, 10);
}
/*

161
test/unittest/UTTest_device_manager_service.cpp
View File

@ -119,100 +119,6 @@ HWTEST_F(DeviceManagerServiceTest, InitDMServiceListener_001, testing::ext::Test
DeviceManagerService::GetInstance().UninitDMServiceListener();
}
/**
* @tc.name: StartDeviceDiscovery_001
* @tc.desc: Start device discovery and return ERR_DM_NO_PERMISSION
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_001, testing::ext::TestSize.Level0)
{
DeletePermission();
std::string pkgName = "com.ohos.test";
DmSubscribeInfo subscribeInfo;
std::string extra;
int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
}
/**
* @tc.name: StartDeviceDiscovery_002
* @tc.desc: Empty pkgName of StartDeviceDiscovery and return ERR_DM_INPUT_PARA_INVALID
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_002, testing::ext::TestSize.Level0)
{
std::string pkgName;
DmSubscribeInfo subscribeInfo;
std::string extra = "test";
int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
}
/**
* @tc.name: StartDeviceDiscovery_003
* @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return
* ERR_DM_DISCOVERY_REPEATED
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_003, testing::ext::TestSize.Level0)
{
std::string pkgName = "com.ohos.test";
DmSubscribeInfo subscribeInfo;
std::string extra = "test";
DeviceManagerService::GetInstance().InitDMServiceListener();
int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeInfo, extra);
EXPECT_EQ(ret, ERR_DM_DISCOVERY_REPEATED);
DeviceManagerService::GetInstance().UninitDMServiceListener();
}
/**
* @tc.name: StopDeviceDiscovery_001
* @tc.desc: Stop device discovery and return SOFTBUS_ERR
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_001, testing::ext::TestSize.Level0)
{
std::string pkgName = "com.ohos.test";
uint16_t subscribeId = 1;
DeviceManagerService::GetInstance().InitDMServiceListener();
int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
EXPECT_TRUE(ret == SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL || ret == SOFTBUS_ERR);
DeviceManagerService::GetInstance().UninitDMServiceListener();
}
/**
* @tc.name:StopDeviceDiscovery_002
* @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_002, testing::ext::TestSize.Level0)
{
std::string pkgName;
uint16_t subscribeId = 1;
int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
}
/**
* @tc.name:StopDeviceDiscovery_003
* @tc.desc: StopDeviceDiscovery is initialized, pkgName is null, and its return value is ERR_DM_INPUT_PARA_INVALID
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StopDeviceDiscovery_003, testing::ext::TestSize.Level0)
{
DeletePermission();
std::string pkgName = "StopDeviceDiscovery_003";
uint16_t subscribeId = 1;
int ret = DeviceManagerService::GetInstance().StopDeviceDiscovery(pkgName, subscribeId);
EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
}
/**
* @tc.name: PublishDeviceDiscovery_001
* @tc.desc: Publish device discovery and return ERR_DM_NO_PERMISSION
@ -294,7 +200,7 @@ HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_001, testing::ext::T
std::string pkgName = "com.ohos.test";
int32_t publishId = 1;
int ret = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
EXPECT_EQ(ret, ERR_DM_POINT_NULL);
EXPECT_NE(ret, DM_OK);
}
/**
@ -345,16 +251,16 @@ HWTEST_F(DeviceManagerServiceTest, UnPublishDeviceDiscovery_004, testing::ext::T
std::vector<std::string> peerUdids;
std::string accountName = "openharmony123";
std::string commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_USER_SWITCHED;
DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGIN;
DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_HWID_LOGOUT;
DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_USER_REMOVED;
DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
commonEventType = EventFwk::CommonEventSupport::COMMON_EVENT_BOOT_COMPLETED;
DeviceManagerService::GetInstance().AccountCommonEventCallback(userId, commonEventType);
DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, accountName);
DeviceManagerService::GetInstance().AccountCommonEventCallback(commonEventType, userId, preUserId);
DeviceManagerService::GetInstance().HandleAccountLogout(userId, accountId, pkgName);
DeviceManagerService::GetInstance().HandleUserRemoved(preUserId);
DeviceManagerService::GetInstance().softbusListener_ = std::make_shared<SoftbusListener>();
DeviceManagerService::GetInstance().SendAccountLogoutBroadCast(peerUdids, accountId, accountName, userId);
@ -1249,34 +1155,6 @@ HWTEST_F(DeviceManagerServiceTest, UnRegisterCallerAppId_002, testing::ext::Test
EXPECT_EQ(DeviceManagerService::GetInstance().listener_, nullptr);
}
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_004, testing::ext::TestSize.Level0)
{
std::string pkgName;
uint16_t subscribeId = 1;
std::string filterOptions;
int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
EXPECT_EQ(ret, ERR_DM_INPUT_PARA_INVALID);
}
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_005, testing::ext::TestSize.Level0)
{
DeletePermission();
std::string pkgName = "com.ohos.test";
uint16_t subscribeId = 1;
std::string filterOptions;
int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
EXPECT_EQ(ret, ERR_DM_NO_PERMISSION);
}
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_006, testing::ext::TestSize.Level0)
{
std::string pkgName;
uint16_t subscribeId = 1;
std::string filterOptions = "filterOptions";
int32_t ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, filterOptions);
EXPECT_NE(ret, ERR_DM_FAILED);
}
HWTEST_F(DeviceManagerServiceTest, BindDevice_001, testing::ext::TestSize.Level0)
{
std::string pkgName;
@ -1912,7 +1790,7 @@ HWTEST_F(DeviceManagerServiceTest, DisableDiscoveryListener_004, testing::ext::T
std::map<std::string, std::string> extraParam;
DeviceManagerService::GetInstance().InitDMServiceListener();
int32_t ret = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
EXPECT_EQ(ret, SOFTBUS_DISCOVER_COAP_STOP_DISCOVER_FAIL);
EXPECT_NE(ret, DM_OK);
DeviceManagerService::GetInstance().UninitDMServiceListener();
}
@ -2264,24 +2142,6 @@ HWTEST_F(DeviceManagerServiceTest, SetDnPolicy_003, testing::ext::TestSize.Level
EXPECT_NE(ret, DM_OK);
}
/**
* @tc.name: StartDeviceDiscovery_007
* @tc.desc: Call StartDeviceDiscovery twice with pkgName not null and flag bit not false and return
* ERR_DM_DISCOVERY_REPEATED
* @tc.type: FUNC
* @tc.require: AR000GHSJK
*/
HWTEST_F(DeviceManagerServiceTest, StartDeviceDiscovery_007, testing::ext::TestSize.Level0)
{
std::string pkgName = "com.ohos.test7";
uint16_t subscribeId = 1;
std::string extra = "test";
DeviceManagerService::GetInstance().InitDMServiceListener();
int ret = DeviceManagerService::GetInstance().StartDeviceDiscovery(pkgName, subscribeId, extra);
EXPECT_NE(ret, DM_OK);
DeviceManagerService::GetInstance().UninitDMServiceListener();
}
HWTEST_F(DeviceManagerServiceTest, DestroyPinHolder_003, testing::ext::TestSize.Level0)
{
std::string pkgName = "";
@ -2317,9 +2177,10 @@ HWTEST_F(DeviceManagerServiceTest, SendServiceUnBindBroadCast_001, testing::ext:
HWTEST_F(DeviceManagerServiceTest, ClearDiscoveryCache_001, testing::ext::TestSize.Level0)
{
std::string pkgName = "pkgName001";
ProcessInfo processInfo;
processInfo.pkgName = "pkgName001";
DeviceManagerService::GetInstance().InitDMServiceListener();
DeviceManagerService::GetInstance().ClearDiscoveryCache(pkgName);
DeviceManagerService::GetInstance().ClearDiscoveryCache(processInfo);
EXPECT_NE(DeviceManagerService::GetInstance().discoveryMgr_, nullptr);
DeviceManagerService::GetInstance().UninitDMServiceListener();
}

61
test/unittest/UTTest_device_manager_service_impl.cpp
View File

@ -1528,7 +1528,7 @@ HWTEST_F(DeviceManagerServiceImplTest, UnBindDevice_104, testing::ext::TestSize.
int32_t ret = deviceManagerServiceImpl_->UnBindDevice(pkgName, udid, bindLevel);
int32_t userId = 100;
std::string accountId = "60008";
deviceManagerServiceImpl_->HandleIdentAccountLogout(udid, userId, accountId);
deviceManagerServiceImpl_->HandleIdentAccountLogout(udid, userId, udid, userId);
deviceManagerServiceImpl_->HandleUserRemoved(userId);
deviceManagerServiceImpl_->HandleDeviceNotTrust(udid);
EXPECT_NE(ret, ERR_DM_INPUT_PARA_INVALID);
@ -1543,26 +1543,9 @@ HWTEST_F(DeviceManagerServiceImplTest, GetBindLevel_101, testing::ext::TestSize.
int32_t tokenId2 = 123;
int32_t remoteUserId = 100;
int32_t ret = deviceManagerServiceImpl_->GetBindLevel(pkgName, localUdid, udid, tokenId);
EXPECT_CALL(*deviceProfileConnectorMock_, HandleAppUnBindEvent(_, _, _, _)).WillOnce(Return(""));
deviceManagerServiceImpl_->HandleAppUnBindEvent(remoteUserId, localUdid, tokenId2);
EXPECT_CALL(*deviceProfileConnectorMock_, HandleAppUnBindEvent(_, _, _, _)).WillOnce(Return(udid));
deviceManagerServiceImpl_->HandleAppUnBindEvent(remoteUserId, localUdid, tokenId2);
EXPECT_EQ(ret, INVALIED_TYPE);
}
HWTEST_F(DeviceManagerServiceImplTest, GetDeviceIdAndBindType_101, testing::ext::TestSize.Level0)
{
const std::string accountId = "123";
const std::string localUdid = "234";
int32_t userId = 100;
std::map<std::string, int32_t> temp = deviceManagerServiceImpl_->GetDeviceIdAndBindType(userId, accountId);
EXPECT_CALL(*deviceProfileConnectorMock_, HandleDevUnBindEvent(_, _, _)).WillOnce(Return(DM_INVALIED_BINDTYPE));
deviceManagerServiceImpl_->HandleDevUnBindEvent(userId, localUdid);
EXPECT_CALL(*deviceProfileConnectorMock_, HandleDevUnBindEvent(_, _, _)).WillOnce(Return(DM_IDENTICAL_ACCOUNT));
deviceManagerServiceImpl_->HandleDevUnBindEvent(userId, localUdid);
EXPECT_EQ(temp.empty(), true);
}
HWTEST_F(DeviceManagerServiceImplTest, ConvertBindTypeToAuthForm_101, testing::ext::TestSize.Level0)
{
int32_t bindType = DM_INVALIED_BINDTYPE;
@ -1693,20 +1676,6 @@ HWTEST_F(DeviceManagerServiceImplTest, HandleDeviceScreenStatusChange_001, testi
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(IDENTICAL_ACCOUNT_TYPE));
deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
std::vector<std::string> pkgNameVec;
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_PEER_TO_PEER_TYPE));
EXPECT_CALL(*deviceProfileConnectorMock_, GetPkgNameFromAcl(_, _)).WillOnce(Return(pkgNameVec));
deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
pkgNameVec.push_back("pkgName");
pkgNameVec.push_back("bundleName");
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_ACROSS_ACCOUNT_TYPE));
EXPECT_CALL(*deviceProfileConnectorMock_, GetPkgNameFromAcl(_, _)).WillOnce(Return(pkgNameVec));
deviceManagerServiceImpl_->HandleDeviceScreenStatusChange(devInfo);
EXPECT_NE(deviceManagerServiceImpl_->softbusConnector_, nullptr);
}
@ -1755,30 +1724,6 @@ HWTEST_F(DeviceManagerServiceImplTest, HandleOnline_003, testing::ext::TestSize.
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(DEVICE_ACROSS_ACCOUNT_TYPE));
deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
std::vector<std::string> pkgNameVec;
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_PEER_TO_PEER_TYPE));
EXPECT_CALL(*deviceProfileConnectorMock_, GetPkgNameFromAcl(_, _)).WillOnce(Return(pkgNameVec));
deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
pkgNameVec.push_back("pkgName");
pkgNameVec.push_back("bundleName");
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_PEER_TO_PEER_TYPE));
EXPECT_CALL(*deviceProfileConnectorMock_, GetPkgNameFromAcl(_, _)).WillOnce(Return(pkgNameVec));
deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_ACROSS_ACCOUNT_TYPE));
EXPECT_CALL(*deviceProfileConnectorMock_, GetPkgNameFromAcl(_, _)).WillOnce(Return(pkgNameVec));
deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
std::vector<std::string> pkgNameVec1;
EXPECT_CALL(*softbusConnectorMock_, GetUdidByNetworkId(_, _)).WillOnce(Return(DM_OK));
EXPECT_CALL(*deviceProfileConnectorMock_, CheckBindType(_, _)).WillOnce(Return(APP_ACROSS_ACCOUNT_TYPE));
EXPECT_CALL(*deviceProfileConnectorMock_, GetPkgNameFromAcl(_, _)).WillOnce(Return(pkgNameVec1));
deviceManagerServiceImpl_->HandleOnline(devState, devInfo);
EXPECT_NE(deviceManagerServiceImpl_->softbusConnector_, nullptr);
}
@ -1798,22 +1743,18 @@ HWTEST_F(DeviceManagerServiceImplTest, HandleOffline_003, testing::ext::TestSize
offlineParam.leftAclNumber = 0;
offlineParam.bindType = INVALID_TYPE;
EXPECT_CALL(*dmDeviceStateManagerMock_, GetUdidByNetWorkId(_)).WillOnce(Return("123456"));
EXPECT_CALL(*deviceProfileConnectorMock_, GetOfflineParamFromAcl(_, _)).WillOnce(Return(offlineParam));
deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
offlineParam.bindType = IDENTICAL_ACCOUNT_TYPE;
EXPECT_CALL(*dmDeviceStateManagerMock_, GetUdidByNetWorkId(_)).WillOnce(Return("123456"));
EXPECT_CALL(*deviceProfileConnectorMock_, GetOfflineParamFromAcl(_, _)).WillOnce(Return(offlineParam));
deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
offlineParam.bindType = DEVICE_PEER_TO_PEER_TYPE;
EXPECT_CALL(*dmDeviceStateManagerMock_, GetUdidByNetWorkId(_)).WillOnce(Return("123456"));
EXPECT_CALL(*deviceProfileConnectorMock_, GetOfflineParamFromAcl(_, _)).WillOnce(Return(offlineParam));
deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
offlineParam.bindType = APP_PEER_TO_PEER_TYPE;
EXPECT_CALL(*dmDeviceStateManagerMock_, GetUdidByNetWorkId(_)).WillOnce(Return("123456"));
EXPECT_CALL(*deviceProfileConnectorMock_, GetOfflineParamFromAcl(_, _)).WillOnce(Return(offlineParam));
deviceManagerServiceImpl_->HandleOffline(devState, devInfo);
EXPECT_NE(deviceManagerServiceImpl_->deviceStateMgr_, nullptr);
}

124
test/unittest/UTTest_device_manager_service_listener.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2022-2023 Huawei Device Co., Ltd.
* 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
@ -19,6 +19,7 @@
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "dm_device_info.h"
#include "dm_log.h"
#include "ipc_notify_auth_result_req.h"
#include "ipc_notify_device_found_req.h"
@ -55,14 +56,16 @@ namespace {
HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceStateChange_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
DmDeviceState state = DEVICE_STATE_ONLINE;
DmDeviceInfo info = {
.deviceId = "asdad",
.deviceName = "asda",
.deviceTypeId = 1,
};
listener_->OnDeviceStateChange(pkgName, state, info);
listener_->OnDeviceStateChange(processInfo, state, info);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), false);
}
@ -76,14 +79,16 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceStateChange_001, testing::ext
HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceStateChange_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "ohos.distributedhardware.devicemanager";
ProcessInfo processInfo;
processInfo.pkgName = "ohos.distributedhardware.devicemanager";
processInfo.userId = 100;
DmDeviceState state = DEVICE_STATE_OFFLINE;
DmDeviceInfo info = {
.deviceId = "asdad",
.deviceName = "asda",
.deviceTypeId = 1,
};
listener_->OnDeviceStateChange(pkgName, state, info);
listener_->OnDeviceStateChange(processInfo, state, info);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -96,12 +101,14 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceStateChange_002, testing::ext
HWTEST_F(DeviceManagerServiceListenerTest, OnAuthResult_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
std::string deviceId = "dkdkd";
std::string token = "kdkddk";
int32_t status = 3;
int32_t reason = 2006;
listener_->OnAuthResult(pkgName, deviceId, token, status, reason);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnAuthResult(processInfo, deviceId, token, status, reason);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -114,12 +121,14 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnAuthResult_001, testing::ext::TestS
HWTEST_F(DeviceManagerServiceListenerTest, OnAuthResult_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
std::string deviceId = "dkdkd";
std::string token = "kdkddk";
int32_t status = 8;
int32_t reason = 2006;
listener_->OnAuthResult(pkgName, deviceId, token, status, reason);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnAuthResult(processInfo, deviceId, token, status, reason);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -132,12 +141,14 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnAuthResult_002, testing::ext::TestS
HWTEST_F(DeviceManagerServiceListenerTest, OnAuthResult_003, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
std::string deviceId = "dkdkd";
std::string token = "kdkddk";
int32_t status = -1;
int32_t reason = 2006;
listener_->OnAuthResult(pkgName, deviceId, token, status, reason);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnAuthResult(processInfo, deviceId, token, status, reason);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -152,13 +163,15 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceFound_001, testing::ext::Test
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
DmDeviceInfo info = {
.deviceId = "dkdkd",
.deviceName = "asda",
.deviceTypeId = 1,
};
uint16_t subscribeId = 1;
listener_->OnDeviceFound(pkgName, subscribeId, info);
listener_->OnDeviceFound(processInfo, subscribeId, info);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -173,9 +186,11 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDiscoveryFailed_001, testing::ext::
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
std::string deviceId = "dkdkd";
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
uint16_t subscribeId = 1;
int32_t failedReason = 1;
listener_->OnDiscoveryFailed(pkgName, subscribeId, failedReason);
listener_->OnDiscoveryFailed(processInfo, subscribeId, failedReason);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -190,7 +205,9 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDiscoverySuccess_001, testing::ext:
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
uint16_t subscribeId = 1;
listener_->OnDiscoverySuccess(pkgName, subscribeId);
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
listener_->OnDiscoverySuccess(processInfo, subscribeId);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -236,9 +253,11 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnPublishResult_002, testing::ext::Te
HWTEST_F(DeviceManagerServiceListenerTest, OnUiCall_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
std::string paramJson = "ahaha";
listener_->OnUiCall(pkgName, paramJson);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnUiCall(processInfo, paramJson);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -251,9 +270,11 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnCredentialResult_001, testing::ext:
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
int32_t action = 1;
std::string resultInfo = "resultInfo";
listener_->OnCredentialResult(pkgName, action, resultInfo);
listener_->OnCredentialResult(processInfo, action, resultInfo);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -265,12 +286,14 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnCredentialResult_001, testing::ext:
HWTEST_F(DeviceManagerServiceListenerTest, OnBindResult_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
PeerTargetId targetId;
int32_t result = 0;
int32_t status = 1;
std::string content = "content";
listener_->OnBindResult(pkgName, targetId, result, status, content);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnBindResult(processInfo, targetId, result, status, content);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -282,12 +305,14 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnBindResult_001, testing::ext::TestS
HWTEST_F(DeviceManagerServiceListenerTest, OnBindResult_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
PeerTargetId targetId;
int32_t result = 0;
int32_t status = 8;
std::string content = "content";
listener_->OnBindResult(pkgName, targetId, result, status, content);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnBindResult(processInfo, targetId, result, status, content);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -299,12 +324,14 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnBindResult_002, testing::ext::TestS
HWTEST_F(DeviceManagerServiceListenerTest, OnBindResult_003, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
PeerTargetId targetId;
int32_t result = 0;
int32_t status = -1;
std::string content = "content";
listener_->OnBindResult(pkgName, targetId, result, status, content);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnBindResult(processInfo, targetId, result, status, content);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -316,11 +343,13 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnBindResult_003, testing::ext::TestS
HWTEST_F(DeviceManagerServiceListenerTest, OnUnbindResult_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
PeerTargetId targetId;
int32_t result = 0;
std::string content = "content";
listener_->OnUnbindResult(pkgName, targetId, result, content);
ProcessInfo processInfo;
processInfo.pkgName = "com.ohos.helloworld";
processInfo.userId = 100;
listener_->OnUnbindResult(processInfo, targetId, result, content);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -343,21 +372,6 @@ HWTEST_F(DeviceManagerServiceListenerTest, ConvertDeviceInfoToDeviceBasicInfo_00
EXPECT_EQ(deviceBasicInfo.deviceTypeId, 1);
}
/**
* @tc.name: OnDeviceFound_002
* @tc.desc: OnDeviceFound, construct a dummy listener, pass in pkgName, subscribeId, DmDeviceInfo
* @tc.type: FUNC
*/
HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceFound_002, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
uint16_t subscribeId = 1;
DmDeviceBasicInfo info;
listener_->OnDeviceFound(pkgName, subscribeId, info);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
/**
* @tc.name: OnPinHolderCreate_001
* @tc.type: FUNC
@ -366,11 +380,13 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDeviceFound_002, testing::ext::Test
HWTEST_F(DeviceManagerServiceListenerTest, OnPinHolderCreate_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
std::string deviceId = "153123";
DmPinType pinType = static_cast<DmPinType>(1);
std::string payload = "payload";
listener_->OnPinHolderCreate(pkgName, deviceId, pinType, payload);
ProcessInfo processInfo;
processInfo.userId = 100;
processInfo.pkgName = "com.ohos.helloworld";
listener_->OnPinHolderCreate(processInfo, deviceId, pinType, payload);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -382,10 +398,12 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnPinHolderCreate_001, testing::ext::
HWTEST_F(DeviceManagerServiceListenerTest, OnPinHolderDestroy_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.userId = 100;
processInfo.pkgName = "com.ohos.helloworld";
DmPinType pinType = static_cast<DmPinType>(1);
std::string payload = "payload";
listener_->OnPinHolderDestroy(pkgName, pinType, payload);
listener_->OnPinHolderDestroy(processInfo, pinType, payload);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -397,9 +415,11 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnPinHolderDestroy_001, testing::ext:
HWTEST_F(DeviceManagerServiceListenerTest, OnCreateResult_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.userId = 100;
processInfo.pkgName = "com.ohos.helloworld";
int32_t result = 0;
listener_->OnCreateResult(pkgName, result);
listener_->OnCreateResult(processInfo, result);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -411,9 +431,11 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnCreateResult_001, testing::ext::Tes
HWTEST_F(DeviceManagerServiceListenerTest, OnDestroyResult_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.userId = 100;
processInfo.pkgName = "com.ohos.helloworld";
int32_t result = 0;
listener_->OnDestroyResult(pkgName, result);
listener_->OnDestroyResult(processInfo, result);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
@ -425,11 +447,13 @@ HWTEST_F(DeviceManagerServiceListenerTest, OnDestroyResult_001, testing::ext::Te
HWTEST_F(DeviceManagerServiceListenerTest, OnPinHolderEvent_001, testing::ext::TestSize.Level0)
{
std::shared_ptr<DeviceManagerServiceListener> listener_ = std::make_shared<DeviceManagerServiceListener>();
std::string pkgName = "com.ohos.helloworld";
ProcessInfo processInfo;
processInfo.userId = 100;
processInfo.pkgName = "com.ohos.helloworld";
DmPinHolderEvent event = DmPinHolderEvent::CREATE_RESULT;
int32_t result = 0;
std::string content = "content";
listener_->OnPinHolderEvent(pkgName, event, result, content);
listener_->OnPinHolderEvent(processInfo, event, result, content);
EXPECT_EQ(listener_->alreadyOnlinePkgName_.empty(), true);
}
} // namespace

Some files were not shown because too many files have changed in this diff Show More