* Copyright (c) 2022-2025 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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 "xcollie/xcollie.h"
#include "xcollie/xcollie_define.h"
#include <securec.h>
#include "device_manager_ipc_interface_code.h"
#include "device_manager_service.h"
#include "device_manager_service_notify.h"
#include "dm_anonymous.h"
#include "dm_constants.h"
#include "ipc_acl_profile_req.h"
#include "ipc_cmd_register.h"
#include "ipc_def.h"
#include "ipc_create_pin_holder_req.h"
#include "ipc_credential_auth_status_req.h"
#include "ipc_destroy_pin_holder_req.h"
#include "ipc_model_codec.h"
#include "ipc_notify_devicetrustchange_req.h"
#include "ipc_notify_auth_result_req.h"
#include "ipc_notify_bind_result_req.h"
#include "ipc_notify_credential_req.h"
#include "ipc_notify_device_found_req.h"
#include "ipc_notify_device_discovery_req.h"
#include "ipc_notify_device_state_req.h"
#include "ipc_notify_discover_result_req.h"
#include "ipc_notify_get_device_icon_info_req.h"
#include "ipc_notify_get_device_profile_info_list_req.h"
#include "ipc_notify_publish_result_req.h"
#include "ipc_notify_pin_holder_event_req.h"
#include "ipc_notify_service_discover_result_req.h"
#include "ipc_notify_service_found_req.h"
#include "ipc_notify_set_local_device_name_req.h"
#include "ipc_notify_set_remote_device_name_req.h"
#include "ipc_notify_service_state_req.h"
#include "ipc_server_client_proxy.h"
#include "ipc_server_stub.h"
#include "ipc_service_publish_result_req.h"
#include "ipc_notify_service_state_req.h"
#include "ipc_sync_service_info_req.h"
#include "ipc_sync_service_info_result_req.h"
#include "multiple_user_connector.h"
#include "app_manager.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;
constexpr const char* SCENEBOARD_PROCESS = "com.ohos.sceneboard";
constexpr int32_t SERVICE_LIST_MAX_SIZE = 1024;
void DecodeDmAccessCaller(MessageParcel &parcel, DmAccessCaller &caller)
{
caller.accountId = parcel.ReadString();
caller.pkgName = parcel.ReadString();
caller.networkId = parcel.ReadString();
caller.userId = parcel.ReadInt32();
caller.tokenId = parcel.ReadUint64();
caller.extra = parcel.ReadString();
}
void DecodeDmAccessCallee(MessageParcel &parcel, DmAccessCallee &callee)
{
callee.accountId = parcel.ReadString();
callee.networkId = parcel.ReadString();
callee.peerId = parcel.ReadString();
callee.pkgName = parcel.ReadString();
callee.userId = parcel.ReadInt32();
callee.extra = parcel.ReadString();
callee.tokenId = parcel.ReadUint64();
}
int32_t OnIpcCmd(const DMIpcCmdInterfaceCode &ipcCode, MessageParcel &data, MessageParcel &reply)
{
LOGI("start ipcCode %{public}d.", static_cast<int32_t>(ipcCode));
DmAccessCaller caller;
DmAccessCallee callee;
DecodeDmAccessCaller(data, caller);
DecodeDmAccessCallee(data, callee);
bool result = false;
switch (ipcCode) {
case CHECK_ACCESS_CONTROL:
result = DeviceManagerService::GetInstance().CheckAccessControl(caller, callee);
break;
case CHECK_SAME_ACCOUNT:
result = DeviceManagerService::GetInstance().CheckIsSameAccount(caller, callee);
break;
case CHECK_SRC_ACCESS_CONTROL:
result = DeviceManagerService::GetInstance().CheckSrcAccessControl(caller, callee);
break;
case CHECK_SINK_ACCESS_CONTROL:
result = DeviceManagerService::GetInstance().CheckSinkAccessControl(caller, callee);
break;
case CHECK_SRC_SAME_ACCOUNT:
result = DeviceManagerService::GetInstance().CheckSrcIsSameAccount(caller, callee);
break;
case CHECK_SINK_SAME_ACCOUNT:
result = DeviceManagerService::GetInstance().CheckSinkIsSameAccount(caller, callee);
break;
default:
LOGE("invalid ipccode");
break;
}
if (!reply.WriteBool(result)) {
LOGE("write result failed.");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
int32_t SetXcollieTimer()
{
std::string processName = "";
AppManager::GetInstance().GetCallerProcessName(processName);
if (processName != SCENEBOARD_PROCESS) {
return OHOS::HiviewDFX::INVALID_ID;
}
return OHOS::HiviewDFX::XCollie::GetInstance().SetTimer("RegisterDeviceManagerListener", XCOLLIE_TIMEOUT_S,
nullptr, nullptr, OHOS::HiviewDFX::XCOLLIE_FLAG_LOG | OHOS::HiviewDFX::XCOLLIE_FLAG_RECOVERY);
}
void CancelXcollieTimer(int32_t id)
{
if (id == OHOS::HiviewDFX::INVALID_ID) {
return;
}
OHOS::HiviewDFX::XCollie::GetInstance().CancelTimer(id);
}
bool EncodeDmDeviceInfo(const DmDeviceInfo &devInfo, MessageParcel &parcel)
{
bool bRet = true;
std::string deviceIdStr(devInfo.deviceId);
bRet = (bRet && parcel.WriteString(deviceIdStr));
std::string deviceNameStr(devInfo.deviceName);
bRet = (bRet && parcel.WriteString(deviceNameStr));
bRet = (bRet && parcel.WriteUint16(devInfo.deviceTypeId));
std::string networkIdStr(devInfo.networkId);
bRet = (bRet && parcel.WriteString(networkIdStr));
bRet = (bRet && parcel.WriteInt32(devInfo.range));
bRet = (bRet && parcel.WriteInt32(devInfo.networkType));
bRet = (bRet && parcel.WriteInt32(devInfo.authForm));
bRet = (bRet && parcel.WriteString(devInfo.extraData));
return bRet;
}
bool EncodeDmDeviceBasicInfo(const DmDeviceBasicInfo &devInfo, MessageParcel &parcel)
{
bool bRet = true;
std::string deviceIdStr(devInfo.deviceId);
bRet = (bRet && parcel.WriteString(deviceIdStr));
std::string deviceNameStr(devInfo.deviceName);
bRet = (bRet && parcel.WriteString(deviceNameStr));
bRet = (bRet && parcel.WriteUint16(devInfo.deviceTypeId));
std::string networkIdStr(devInfo.networkId);
bRet = (bRet && parcel.WriteString(networkIdStr));
bRet = (bRet && parcel.WriteString(devInfo.extraData));
return bRet;
}
bool EncodePeerTargetId(const PeerTargetId &targetId, MessageParcel &parcel)
{
bool bRet = true;
bRet = (bRet && parcel.WriteString(targetId.deviceId));
bRet = (bRet && parcel.WriteString(targetId.brMac));
bRet = (bRet && parcel.WriteString(targetId.bleMac));
bRet = (bRet && parcel.WriteString(targetId.wifiIp));
bRet = (bRet && parcel.WriteUint16(targetId.wifiPort));
bRet = (bRet && parcel.WriteInt64(targetId.serviceId));
return bRet;
}
void DecodePeerTargetId(MessageParcel &parcel, PeerTargetId &targetId)
{
targetId.deviceId = parcel.ReadString();
targetId.brMac = parcel.ReadString();
targetId.bleMac = parcel.ReadString();
targetId.wifiIp = parcel.ReadString();
targetId.wifiPort = parcel.ReadUint16();
targetId.serviceId = parcel.ReadInt64();
}
ON_IPC_SET_REQUEST(SERVER_DEVICE_STATE_NOTIFY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::static_pointer_cast<IpcNotifyDeviceStateReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t deviceState = pReq->GetDeviceState();
DmDeviceInfo deviceInfo = pReq->GetDeviceInfo();
DmDeviceBasicInfo deviceBasicInfo = pReq->GetDeviceBasicInfo();
std::vector<int64_t> serviceIds = pReq->GetServiceIds();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(deviceState)) {
LOGE("write state failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodeDmDeviceInfo(deviceInfo, data)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodeDmDeviceBasicInfo(deviceBasicInfo, data)) {
LOGE("write dm device basic info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!IpcModelCodec::EncodeServiceIds(serviceIds, data)) {
LOGE("write dm service info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DEVICE_STATE_NOTIFY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DEVICE_FOUND, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDeviceFoundReq> pReq = std::static_pointer_cast<IpcNotifyDeviceFoundReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
uint16_t subscribeId = pReq->GetSubscribeId();
DmDeviceInfo deviceInfo = pReq->GetDeviceInfo();
DmDeviceBasicInfo devBasicInfo = pReq->GetDeviceBasicInfo();
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;
}
if (!EncodeDmDeviceInfo(deviceInfo, data)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodeDmDeviceBasicInfo(devBasicInfo, data)) {
LOGE("write dm device basic info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DEVICE_FOUND, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DEVICE_DISCOVERY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDeviceDiscoveryReq> pReq = std::static_pointer_cast<IpcNotifyDeviceDiscoveryReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
uint16_t subscribeId = pReq->GetSubscribeId();
DmDeviceBasicInfo deviceBasicInfo = pReq->GetDeviceBasicInfo();
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;
}
if (!EncodeDmDeviceBasicInfo(deviceBasicInfo, data)) {
LOGE("write dm device basic info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DEVICE_DISCOVERY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DISCOVER_FINISH, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDiscoverResultReq> pReq = std::static_pointer_cast<IpcNotifyDiscoverResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
uint16_t subscribeId = pReq->GetSubscribeId();
int32_t result = pReq->GetResult();
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;
}
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DISCOVER_FINISH, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_PUBLISH_FINISH, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyPublishResultReq> pReq = std::static_pointer_cast<IpcNotifyPublishResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t publishId = pReq->GetPublishId();
int32_t result = pReq->GetResult();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(publishId)) {
LOGE("write publishId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_PUBLISH_FINISH, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_AUTH_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyAuthResultReq> pReq = std::static_pointer_cast<IpcNotifyAuthResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string deviceId = pReq->GetDeviceId();
std::string token = pReq->GetPinToken();
int32_t status = pReq->GetStatus();
int32_t reason = pReq->GetReason();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(deviceId)) {
LOGE("write deviceId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(token)) {
LOGE("write token failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(status)) {
LOGE("write status failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(reason)) {
LOGE("write reason failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_AUTH_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DEVICE_FA_NOTIFY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDMFAResultReq> pReq = std::static_pointer_cast<IpcNotifyDMFAResultReq>(pBaseReq);
std::string packagname = pReq->GetPkgName();
std::string paramJson = pReq->GetJsonParam();
if (!data.WriteString(packagname)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(paramJson)) {
LOGE("write paramJson failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DEVICE_FA_NOTIFY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(GET_TRUST_DEVICE_LIST, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string extra = data.ReadString();
bool isRefresh = data.ReadBool();
if (isRefresh) {
DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, pkgName, isRefresh, false);
}
std::vector<DmDeviceInfo> deviceList;
int32_t result = DeviceManagerService::GetInstance().GetTrustedDeviceList(pkgName, extra, deviceList);
if (!reply.WriteInt32((int32_t)deviceList.size())) {
LOGE("write device list size failed");
return ERR_DM_IPC_WRITE_FAILED;
}
for (const auto &devInfo : deviceList) {
if (!EncodeDmDeviceInfo(devInfo, reply)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_ALL_TRUST_DEVICE_LIST, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string extra = data.ReadString();
std::vector<DmDeviceInfo> deviceList;
int32_t result = DeviceManagerService::GetInstance().GetAllTrustedDeviceList(pkgName, extra, deviceList);
if (!reply.WriteInt32((int32_t)deviceList.size())) {
LOGE("write device list size failed");
return ERR_DM_IPC_WRITE_FAILED;
}
for (const auto &devInfo : deviceList) {
if (!EncodeDmDeviceInfo(devInfo, reply)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(REGISTER_DEVICE_MANAGER_LISTENER, MessageParcel &data, MessageParcel &reply)
{
int32_t timerId = SetXcollieTimer();
std::string pkgName = data.ReadString();
sptr<IRemoteObject> listener = data.ReadRemoteObject();
if (listener == nullptr) {
LOGE("read remote object failed.");
CancelXcollieTimer(timerId);
return ERR_DM_POINT_NULL;
}
sptr<IpcServerClientProxy> callback(new IpcServerClientProxy(listener));
if (callback == nullptr) {
LOGE("create ipc server client proxy failed.");
CancelXcollieTimer(timerId);
return ERR_DM_POINT_NULL;
}
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
MultipleUserConnector::GetCallerUserId(processInfo.userId);
MultipleUserConnector::GetCallingTokenId(processInfo.tokenId);
DeviceManagerService::GetInstance().RegisterCallerAppId(pkgName, processInfo.userId);
int32_t result = IpcServerStub::GetInstance().RegisterDeviceManagerListener(processInfo, callback);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
CancelXcollieTimer(timerId);
return ERR_DM_IPC_WRITE_FAILED;
}
CancelXcollieTimer(timerId);
return DM_OK;
}
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);
MultipleUserConnector::GetCallingTokenId(processInfo.tokenId);
DeviceManagerService::GetInstance().UnRegisterCallerAppId(pkgName, processInfo.userId);
int32_t result = IpcServerStub::GetInstance().UnRegisterDeviceManagerListener(processInfo);
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)
{
std::string pkgName = data.ReadString();
DmPublishInfo *publishInfo =
static_cast<DmPublishInfo *>(const_cast<void *>(data.ReadRawData(sizeof(DmPublishInfo))));
int32_t result = ERR_DM_POINT_NULL;
if (publishInfo != nullptr) {
result = DeviceManagerService::GetInstance().PublishDeviceDiscovery(pkgName, *publishInfo);
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNPUBLISH_DEVICE_DISCOVER, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t publishId = data.ReadInt32();
int32_t result = DeviceManagerService::GetInstance().UnPublishDeviceDiscovery(pkgName, publishId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(AUTHENTICATE_DEVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string extra = data.ReadString();
std::string deviceId = data.ReadString();
int32_t authType = data.ReadInt32();
int32_t result = DM_OK;
result = DeviceManagerService::GetInstance().AuthenticateDevice(pkgName, authType, deviceId, extra);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNAUTHENTICATE_DEVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string deviceId = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().UnAuthenticateDevice(pkgName, deviceId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_DEVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string networkId = data.ReadString();
DmDeviceInfo deviceInfo;
int32_t result = DeviceManagerService::GetInstance().GetDeviceInfo(networkId, deviceInfo);
if (!EncodeDmDeviceInfo(deviceInfo, reply)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_LOCAL_DEVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
(void)data;
DmDeviceInfo localDeviceInfo;
int32_t result = DeviceManagerService::GetInstance().GetLocalDeviceInfo(localDeviceInfo);
if (!EncodeDmDeviceInfo(localDeviceInfo, reply)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_UDID_BY_NETWORK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string netWorkId = data.ReadString();
std::string udid;
int32_t result = DeviceManagerService::GetInstance().GetUdidByNetworkId(pkgName, netWorkId, udid);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(udid)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_UUID_BY_NETWORK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string netWorkId = data.ReadString();
std::string uuid;
int32_t result = DeviceManagerService::GetInstance().GetUuidByNetworkId(pkgName, netWorkId, uuid);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(uuid)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(SERVER_USER_AUTH_OPERATION, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
int32_t action = data.ReadInt32();
std::string params = data.ReadString();
int result = DeviceManagerService::GetInstance().SetUserOperation(packageName, action, params);
if (!reply.WriteInt32(result)) {
return ERR_DM_IPC_WRITE_FAILED;
}
return result;
}
ON_IPC_CMD(REQUEST_CREDENTIAL, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
std::string reqParaStr = data.ReadString();
std::map<std::string, std::string> requestParam;
ParseMapFromJsonString(reqParaStr, requestParam);
std::string returnJsonStr;
int32_t ret = ERR_DM_FAILED;
if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_OH) {
ret = DeviceManagerService::GetInstance().RequestCredential(requestParam[DM_CREDENTIAL_REQJSONSTR],
returnJsonStr);
}
if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_MINE) {
ret = DeviceManagerService::GetInstance().MineRequestCredential(packageName, returnJsonStr);
}
if (!reply.WriteInt32(ret)) {
LOGE("write ret failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (ret == DM_OK && !returnJsonStr.empty()) {
if (!reply.WriteString(returnJsonStr)) {
LOGE("write returnJsonStr failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
return DM_OK;
}
ON_IPC_CMD(IMPORT_CREDENTIAL, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
std::string reqParaStr = data.ReadString();
std::map<std::string, std::string> requestParam;
ParseMapFromJsonString(reqParaStr, requestParam);
std::string returnJsonStr;
std::map<std::string, std::string> outputResult;
int32_t ret = ERR_DM_FAILED;
if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_OH) {
ret = DeviceManagerService::GetInstance().ImportCredential(packageName, requestParam[DM_CREDENTIAL_REQJSONSTR]);
outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH);
}
if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_MINE) {
ret = DeviceManagerService::GetInstance().ImportCredential(packageName, requestParam[DM_CREDENTIAL_REQJSONSTR],
returnJsonStr);
outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE);
outputResult.emplace(DM_CREDENTIAL_RETURNJSONSTR, returnJsonStr);
}
if (!reply.WriteInt32(ret)) {
LOGE("write ret failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (ret == DM_OK && !returnJsonStr.empty()) {
std::string outParaStr = ConvertMapToJsonString(outputResult);
if (!reply.WriteString(outParaStr)) {
LOGE("write returnJsonStr failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
return DM_OK;
}
ON_IPC_CMD(DELETE_CREDENTIAL, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
std::string reqParaStr = data.ReadString();
std::map<std::string, std::string> requestParam;
ParseMapFromJsonString(reqParaStr, requestParam);
std::map<std::string, std::string> outputResult;
std::string returnJsonStr;
int32_t ret = ERR_DM_FAILED;
if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_OH) {
ret = DeviceManagerService::GetInstance().DeleteCredential(packageName, requestParam[DM_CREDENTIAL_REQJSONSTR]);
outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_OH);
}
if (requestParam[DM_CREDENTIAL_TYPE] == DM_TYPE_MINE) {
ret = DeviceManagerService::GetInstance().DeleteCredential(packageName, requestParam[DM_CREDENTIAL_REQJSONSTR],
returnJsonStr);
outputResult.emplace(DM_CREDENTIAL_TYPE, DM_TYPE_MINE);
outputResult.emplace(DM_CREDENTIAL_RETURNJSONSTR, returnJsonStr);
}
if (!reply.WriteInt32(ret)) {
LOGE("write ret failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (ret == DM_OK && !returnJsonStr.empty()) {
std::string outParaStr = ConvertMapToJsonString(outputResult);
if (!reply.WriteString(outParaStr)) {
LOGE("write returnJsonStr failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
return DM_OK;
}
ON_IPC_CMD(SERVER_GET_DMFA_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
std::string reqJsonStr = data.ReadString();
std::string returnJsonStr;
int32_t ret = DeviceManagerService::GetInstance().CheckCredential(packageName, reqJsonStr, returnJsonStr);
if (!reply.WriteInt32(ret)) {
LOGE("write ret failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (ret == DM_OK && !returnJsonStr.empty()) {
if (!reply.WriteString(returnJsonStr)) {
LOGE("write returnJsonStr failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
return DM_OK;
}
ON_IPC_CMD(REGISTER_CREDENTIAL_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
int result = DeviceManagerService::GetInstance().RegisterCredentialCallback(packageName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return result;
}
ON_IPC_CMD(UNREGISTER_CREDENTIAL_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string packageName = data.ReadString();
int result = DeviceManagerService::GetInstance().UnRegisterCredentialCallback(packageName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return result;
}
ON_IPC_CMD(NOTIFY_EVENT, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t eventId = data.ReadInt32();
std::string event = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().NotifyEvent(pkgName, eventId, event);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_CREDENTIAL_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyCredentialReq> pReq = std::static_pointer_cast<IpcNotifyCredentialReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t action = pReq->GetCredentialAction();
std::string credentialResult = pReq->GetCredentialResult();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(action)) {
LOGE("write action failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(credentialResult)) {
LOGE("write credentialResult failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!credentialResult.empty()) {
(void)memset_s(const_cast<char*>(credentialResult.data()), credentialResult.size(), 0, credentialResult.size());
credentialResult.clear();
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_CREDENTIAL_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(GET_ENCRYPTED_UUID_BY_NETWOEKID, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string networkId = data.ReadString();
std::string uuid;
int32_t result = DeviceManagerService::GetInstance().GetEncryptedUuidByNetworkId(pkgName, networkId, uuid);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(uuid)) {
LOGE("write uuid failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GENERATE_ENCRYPTED_UUID, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string uuid = data.ReadString();
std::string appId = data.ReadString();
std::string encryptedUuid;
int32_t result = DeviceManagerService::GetInstance().GenerateEncryptedUuid(pkgName, uuid, appId, encryptedUuid);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(encryptedUuid)) {
LOGE("write encryptedUuid failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(BIND_DEVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string bindParam = data.ReadString();
std::string deviceId = data.ReadString();
int32_t bindType = data.ReadInt32();
int32_t result = DM_OK;
result = DeviceManagerService::GetInstance().BindDevice(pkgName, bindType, deviceId, bindParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNBIND_DEVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string deviceId = data.ReadString();
std::string extra = data.ReadString();
int32_t result = 0;
result = DeviceManagerService::GetInstance().UnBindDeviceParseExtra(pkgName, deviceId, extra);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_NETWORKTYPE_BY_NETWORK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string netWorkId = data.ReadString();
int32_t networkType = -1;
int32_t result = DeviceManagerService::GetInstance().GetNetworkTypeByNetworkId(pkgName, netWorkId, networkType);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(networkType)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_OS_TYPE_BY_NETWORK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string networkId = data.ReadString();
int32_t osType = -1;
int32_t result = DeviceManagerService::GetInstance().GetOsTypeByNetworkId(pkgName, networkId, osType);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(osType)) {
LOGE("write osType failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(REGISTER_UI_STATE_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().RegisterUiStateCallback(pkgName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNREGISTER_UI_STATE_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().UnRegisterUiStateCallback(pkgName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(IMPORT_AUTH_CODE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string authCode = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().ImportAuthCode(pkgName, authCode);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(EXPORT_AUTH_CODE, MessageParcel &data, MessageParcel &reply)
{
std::string authCode = "";
int32_t result = DeviceManagerService::GetInstance().ExportAuthCode(authCode);
if (!reply.WriteString(authCode)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!authCode.empty()) {
(void)memset_s(const_cast<char*>(authCode.data()), authCode.size(), 0, authCode.size());
authCode.clear();
}
return DM_OK;
}
ON_IPC_CMD(IMPORT_AUTH_INFO, MessageParcel &data, MessageParcel &reply)
{
DmAuthInfo authInfo;
if (!IpcModelCodec::DecodeDmAuthInfo(data, authInfo)) {
reply.WriteInt32(ERR_DM_IPC_WRITE_FAILED);
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = DeviceManagerService::GetInstance().ImportAuthInfo(authInfo);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(EXPORT_AUTH_INFO, MessageParcel &data, MessageParcel &reply)
{
DmAuthInfo authInfo;
IpcModelCodec::DecodeDmAuthInfo(data, authInfo);
uint32_t pinLength = data.ReadUint32();
int32_t result = DeviceManagerService::GetInstance().ExportAuthInfo(authInfo, pinLength);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (result == DM_OK && !IpcModelCodec::EncodeDmAuthInfo(authInfo, reply)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(REGISTER_DISCOVERY_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string discParaStr = data.ReadString();
std::string filterOpStr = data.ReadString();
std::map<std::string, std::string> discoverParam;
ParseMapFromJsonString(discParaStr, discoverParam);
std::map<std::string, std::string> filterOptions;
ParseMapFromJsonString(filterOpStr, filterOptions);
int32_t result = DeviceManagerService::GetInstance().EnableDiscoveryListener(pkgName, discoverParam, filterOptions);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNREGISTER_DISCOVERY_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string extraParaStr = data.ReadString();
std::map<std::string, std::string> extraParam;
ParseMapFromJsonString(extraParaStr, extraParam);
int32_t result = DeviceManagerService::GetInstance().DisableDiscoveryListener(pkgName, extraParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(START_DISCOVERING, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string discParaStr = data.ReadString();
std::string filterOpStr = data.ReadString();
std::map<std::string, std::string> discoverParam;
ParseMapFromJsonString(discParaStr, discoverParam);
std::map<std::string, std::string> filterOptions;
ParseMapFromJsonString(filterOpStr, filterOptions);
int32_t result = DeviceManagerService::GetInstance().StartDiscovering(pkgName, discoverParam, filterOptions);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(STOP_DISCOVERING, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string discParaStr = data.ReadString();
std::map<std::string, std::string> discoverParam;
ParseMapFromJsonString(discParaStr, discoverParam);
int32_t result = DeviceManagerService::GetInstance().StopDiscovering(pkgName, discoverParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(START_ADVERTISING, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string adverParaStr = data.ReadString();
std::map<std::string, std::string> advertiseParam;
ParseMapFromJsonString(adverParaStr, advertiseParam);
int32_t result = DeviceManagerService::GetInstance().StartAdvertising(pkgName, advertiseParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(STOP_ADVERTISING, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string adverParaStr = data.ReadString();
std::map<std::string, std::string> advertiseParam;
ParseMapFromJsonString(adverParaStr, advertiseParam);
int32_t result = DeviceManagerService::GetInstance().StopAdvertising(pkgName, advertiseParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(BIND_TARGET, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
PeerTargetId targetId;
DecodePeerTargetId(data, targetId);
std::string bindParamStr = data.ReadString();
std::map<std::string, std::string> bindParam;
ParseMapFromJsonString(bindParamStr, bindParam);
int32_t result = DeviceManagerService::GetInstance().BindTarget(pkgName, targetId, bindParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNBIND_TARGET, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
PeerTargetId targetId;
DecodePeerTargetId(data, targetId);
std::string unbindParamStr = data.ReadString();
std::map<std::string, std::string> unbindParam;
ParseMapFromJsonString(unbindParamStr, unbindParam);
int32_t result = DeviceManagerService::GetInstance().UnbindTarget(pkgName, targetId, unbindParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(BIND_TARGET_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyBindResultReq> pReq = std::static_pointer_cast<IpcNotifyBindResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
PeerTargetId targetId = pReq->GetPeerTargetId();
int32_t result = pReq->GetResult();
int32_t status = pReq->GetStatus();
std::string content = pReq->GetContent();
if (!data.WriteString(pkgName)) {
LOGE("write bind pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodePeerTargetId(targetId, data)) {
LOGE("write bind peer target id failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write bind result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(status)) {
LOGE("write bind result status failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(content)) {
LOGE("write bind result content failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(BIND_TARGET_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SINK_BIND_TARGET_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyBindResultReq> pReq = std::static_pointer_cast<IpcNotifyBindResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
PeerTargetId targetId = pReq->GetPeerTargetId();
int32_t result = pReq->GetResult();
int32_t status = pReq->GetStatus();
std::string content = pReq->GetContent();
if (!data.WriteString(pkgName)) {
LOGE("write bind pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodePeerTargetId(targetId, data)) {
LOGE("write bind peer target id failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write bind result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(status)) {
LOGE("write bind result status failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(content)) {
LOGE("write bind result content failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SINK_BIND_TARGET_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(UNBIND_TARGET_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyBindResultReq> pReq = std::static_pointer_cast<IpcNotifyBindResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
PeerTargetId targetId = pReq->GetPeerTargetId();
int32_t result = pReq->GetResult();
std::string content = pReq->GetContent();
if (!data.WriteString(pkgName)) {
LOGE("write unbind pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodePeerTargetId(targetId, data)) {
LOGE("write unbind peer target id failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write unbind result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(content)) {
LOGE("write unbind result content failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(UNBIND_TARGET_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(REGISTER_PIN_HOLDER_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().RegisterPinHolderCallback(pkgName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(CREATE_PIN_HOLDER, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
PeerTargetId targetId;
DecodePeerTargetId(data, targetId);
std::string payload = data.ReadString();
DmPinType pinType = static_cast<DmPinType>(data.ReadInt32());
int32_t result = DeviceManagerService::GetInstance().CreatePinHolder(pkgName, targetId, pinType, payload);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(DESTROY_PIN_HOLDER, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
PeerTargetId targetId;
DecodePeerTargetId(data, targetId);
DmPinType pinType = static_cast<DmPinType>(data.ReadInt32());
std::string payload = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().DestroyPinHolder(pkgName, targetId, pinType, payload);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!payload.empty()) {
(void)memset_s(const_cast<char*>(payload.data()), payload.size(), 0, payload.size());
payload.clear();
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_CREATE_PIN_HOLDER, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcCreatePinHolderReq> pReq = std::static_pointer_cast<IpcCreatePinHolderReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string deviceId = pReq->GetDeviceId();
int32_t pinType = pReq->GetPinType();
std::string payload = pReq->GetPayload();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(deviceId)) {
LOGE("write deviceId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(pinType)) {
LOGE("write pinType failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(payload)) {
LOGE("write payload failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_CREATE_PIN_HOLDER, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DESTROY_PIN_HOLDER, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcDestroyPinHolderReq> pReq = std::static_pointer_cast<IpcDestroyPinHolderReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t pinType = pReq->GetPinType();
std::string payload = pReq->GetPayload();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(pinType)) {
LOGE("write pinType failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(payload)) {
LOGE("write payload failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!payload.empty()) {
(void)memset_s(const_cast<char*>(payload.data()), payload.size(), 0, payload.size());
payload.clear();
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DESTROY_PIN_HOLDER, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_CREATE_PIN_HOLDER_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyPublishResultReq> pReq = std::static_pointer_cast<IpcNotifyPublishResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t result = pReq->GetResult();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_CREATE_PIN_HOLDER_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DESTROY_PIN_HOLDER_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyPublishResultReq> pReq = std::static_pointer_cast<IpcNotifyPublishResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t result = pReq->GetResult();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DESTROY_PIN_HOLDER_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(DP_ACL_ADD, MessageParcel &data, MessageParcel &reply)
{
std::string udid = data.ReadString();
int64_t accessControlId = data.ReadInt64();
int32_t result = DeviceManagerService::GetInstance().DpAclAdd(udid, accessControlId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_SECURITY_LEVEL, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string networkId = data.ReadString();
int32_t securityLevel = -1;
int32_t result = DeviceManagerService::GetInstance().GetDeviceSecurityLevel(pkgName, networkId, securityLevel);
if (!reply.WriteInt32(result)) {
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(securityLevel)) {
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_ON_PIN_HOLDER_EVENT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyPinHolderEventReq> pReq = std::static_pointer_cast<IpcNotifyPinHolderEventReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
int32_t pinHolderEvent = pReq->GetPinHolderEvent();
int32_t result = pReq->GetResult();
std::string content = pReq->GetContent();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(pinHolderEvent)) {
LOGE("write pinHolderEvent failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(content)) {
LOGE("write content failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_ON_PIN_HOLDER_EVENT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(IS_SAME_ACCOUNT, MessageParcel &data, MessageParcel &reply)
{
std::string netWorkId = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().IsSameAccount(netWorkId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed.");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(CHECK_API_PERMISSION, MessageParcel &data, MessageParcel &reply)
{
int32_t permissionLevel = data.ReadInt32();
int32_t result = DeviceManagerService::GetInstance().CheckApiPermission(permissionLevel);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(CHECK_ACCESS_CONTROL, MessageParcel &data, MessageParcel &reply)
{
return OnIpcCmd(CHECK_ACCESS_CONTROL, data, reply);
}
ON_IPC_CMD(CHECK_SAME_ACCOUNT, MessageParcel &data, MessageParcel &reply)
{
return OnIpcCmd(CHECK_SAME_ACCOUNT, data, reply);
}
ON_IPC_CMD(SHIFT_LNN_GEAR, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().ShiftLNNGear(pkgName, pkgName, true, true);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(SET_DN_POLICY, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string policyStr = data.ReadString();
std::map<std::string, std::string> policy;
ParseMapFromJsonString(policyStr, policy);
int32_t result = DeviceManagerService::GetInstance().SetDnPolicy(pkgName, policy);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(STOP_AUTHENTICATE_DEVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().StopAuthenticateDevice(pkgName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(REMOTE_DEVICE_TRUST_CHANGE, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDevTrustChangeReq> pReq = std::static_pointer_cast<IpcNotifyDevTrustChangeReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string udid = pReq->GetUdid();
int32_t authForm = pReq->GetAuthForm();
std::string uuid = pReq->GetUuid();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(udid)) {
LOGE("write udid failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(authForm)) {
LOGE("write authForm code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(uuid)) {
LOGE("write uuid code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(REMOTE_DEVICE_TRUST_CHANGE, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_DEVICE_SCREEN_STATE_NOTIFY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyDeviceStateReq> pReq = std::static_pointer_cast<IpcNotifyDeviceStateReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
DmDeviceInfo deviceInfo = pReq->GetDeviceInfo();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!EncodeDmDeviceInfo(deviceInfo, data)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_DEVICE_SCREEN_STATE_NOTIFY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(GET_DEVICE_SCREEN_STATUS, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string networkId = data.ReadString();
int32_t screenStatus = -1;
int32_t result = DeviceManagerService::GetInstance().GetDeviceScreenStatus(pkgName, networkId, screenStatus);
if (!reply.WriteInt32(result)) {
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(screenStatus)) {
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_NETWORKID_BY_UDID, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string udid = data.ReadString();
std::string netWorkId;
int32_t result = DeviceManagerService::GetInstance().GetNetworkIdByUdid(pkgName, udid, netWorkId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(netWorkId)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_ANONY_LOCAL_UDID, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string anonyUdid;
int32_t result = DeviceManagerService::GetInstance().GetAnonyLocalUdid(pkgName, anonyUdid);
if (!reply.WriteInt32(result)) {
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(anonyUdid)) {
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVICE_CREDENTIAL_AUTH_STATUS_NOTIFY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyCredentialAuthStatusReq> pReq =
std::static_pointer_cast<IpcNotifyCredentialAuthStatusReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
std::string deviceList = pReq->GetDeviceList();
uint16_t deviceTypeId = pReq->GetDeviceTypeId();
int32_t errCode = pReq->GetErrCode();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(deviceList)) {
LOGE("write deviceList failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteUint16(deviceTypeId)) {
LOGE("write deviceTypeId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(errCode)) {
LOGE("write errCode failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVICE_CREDENTIAL_AUTH_STATUS_NOTIFY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(SYNC_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t dmCommonNotifyEvent = data.ReadInt32();
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
MultipleUserConnector::GetCallerUserId(processInfo.userId);
MultipleUserConnector::GetCallingTokenId(processInfo.tokenId);
int32_t result = DeviceManagerServiceNotify::GetInstance().RegisterCallBack(dmCommonNotifyEvent, processInfo);
if (dmCommonNotifyEvent == static_cast<int32_t>(DmCommonNotifyEvent::REG_DEVICE_STATE)) {
#ifdef CAR_DEVICE_ENABLE
DeviceManagerService::GetInstance().RegDevStateCallbackToService(pkgName, processInfo);
#else
DeviceManagerService::GetInstance().RegDevStateCallbackToService(pkgName);
#endif
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(REG_AUTHENTICATION_TYPE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string authTypeStr = data.ReadString();
std::map<std::string, std::string> authParam;
ParseMapFromJsonString(authTypeStr, authParam);
int32_t result = DeviceManagerService::GetInstance().RegisterAuthenticationType(pkgName, authParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_DEVICE_PROFILE_INFO_LIST, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
DmDeviceProfileInfoFilterOptions filterOptions;
int32_t ret = IpcModelCodec::DecodeDmDeviceProfileInfoFilterOptions(data, filterOptions);
if (ret != DM_OK) {
LOGE("DecodeDmDeviceProfileInfoFilterOptions fail ret:%{public}d,", ret);
return ret;
}
int32_t result = DeviceManagerService::GetInstance().GetDeviceProfileInfoList(pkgName, filterOptions);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(GET_DEVICE_PROFILE_INFO_LIST_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyGetDeviceProfileInfoListReq> pReq =
std::static_pointer_cast<IpcNotifyGetDeviceProfileInfoListReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = pReq->GetResult();
if (!data.WriteInt32(result)) {
LOGE("write result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
std::vector<DmDeviceProfileInfo> deviceProfileInfos = pReq->GetDeviceProfileInfoList();
if (!data.WriteInt32((int32_t)deviceProfileInfos.size())) {
LOGE("write device list size failed");
return ERR_DM_IPC_WRITE_FAILED;
}
for (const auto &devInfo : deviceProfileInfos) {
if (!IpcModelCodec::EncodeDmDeviceProfileInfo(devInfo, data)) {
LOGE("write dm device profile info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(GET_DEVICE_PROFILE_INFO_LIST_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(PUT_DEVICE_PROFILE_INFO_LIST, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t deviceNum = data.ReadInt32();
std::vector<DmDeviceProfileInfo> deviceProfileInfoList;
if (deviceNum > 0 && deviceNum <= MAX_DEVICE_PROFILE_SIZE) {
for (int32_t i = 0; i < deviceNum; ++i) {
DmDeviceProfileInfo deviceInfo;
IpcModelCodec::DecodeDmDeviceProfileInfo(data, deviceInfo);
deviceProfileInfoList.emplace_back(deviceInfo);
}
}
int32_t result = DeviceManagerService::GetInstance().PutDeviceProfileInfoList(pkgName, deviceProfileInfoList);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_DEVICE_ICON_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
DmDeviceIconInfoFilterOptions filterOptions;
IpcModelCodec::DecodeDmDeviceIconInfoFilterOptions(data, filterOptions);
int32_t result = DeviceManagerService::GetInstance().GetDeviceIconInfo(pkgName, filterOptions);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(GET_DEVICE_ICON_INFO_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyGetDeviceIconInfoReq> pReq =
std::static_pointer_cast<IpcNotifyGetDeviceIconInfoReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = pReq->GetResult();
if (!data.WriteInt32(result)) {
LOGE("write result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!IpcModelCodec::EncodeDmDeviceIconInfo(pReq->GetDmDeviceIconInfo(), data)) {
LOGE("write dm device icon info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(GET_DEVICE_ICON_INFO_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(GET_LOCAL_DISPLAY_DEVICE_NAME, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t maxNameLength = data.ReadInt32();
std::string displayName = "";
int32_t result = DeviceManagerService::GetInstance().GetLocalDisplayDeviceName(pkgName, maxNameLength, displayName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(displayName)) {
LOGE("write displayName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(REG_LOCALSERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
DMLocalServiceInfo serviceInfo;
IpcModelCodec::DecodeLocalServiceInfo(data, serviceInfo);
int32_t result = DeviceManagerService::GetInstance().RegisterLocalServiceInfo(serviceInfo);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNREG_LOCALSERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string bundleName = data.ReadString();
int32_t pinExchangeType = data.ReadInt32();
int32_t result = DeviceManagerService::GetInstance().UnRegisterLocalServiceInfo(bundleName, pinExchangeType);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UPDATE_SERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
int64_t serviceId = data.ReadInt64();
DmRegisterServiceInfo regServiceInfo;
IpcModelCodec::DecodeDmRegServiceInfo(data, regServiceInfo);
int32_t result = DeviceManagerService::GetInstance().UpdateServiceInfo(serviceId, regServiceInfo);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UPDATE_LOCALSERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
DMLocalServiceInfo serviceInfo;
IpcModelCodec::DecodeLocalServiceInfo(data, serviceInfo);
int32_t result = DeviceManagerService::GetInstance().UpdateLocalServiceInfo(serviceInfo);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_SERVICEINFO_BYBUNDLENAME_PINEXCHANGETYPE, MessageParcel &data, MessageParcel &reply)
{
std::string bundleName = data.ReadString();
int32_t pinExchangeType = data.ReadInt32();
DMLocalServiceInfo serviceInfo;
int32_t result = DeviceManagerService::GetInstance().GetLocalServiceInfoByBundleNameAndPinExchangeType(
bundleName, pinExchangeType, serviceInfo);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (result == DM_OK && !IpcModelCodec::EncodeLocalServiceInfo(serviceInfo, reply)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(SET_LOCAL_DEVICE_NAME, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string deviceName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().SetLocalDeviceName(pkgName, deviceName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SET_LOCAL_DEVICE_NAME_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
if (pBaseReq == nullptr) {
return ERR_DM_FAILED;
}
std::shared_ptr<IpcNotifySetLocalDeviceNameReq> pReq =
std::static_pointer_cast<IpcNotifySetLocalDeviceNameReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = pReq->GetResult();
if (!data.WriteInt32(result)) {
LOGE("write result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SET_LOCAL_DEVICE_NAME_RESULT, 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_CMD(SET_REMOTE_DEVICE_NAME, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string deviceId = data.ReadString();
std::string deviceName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().SetRemoteDeviceName(pkgName, deviceId, deviceName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SET_REMOTE_DEVICE_NAME_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
if (pBaseReq == nullptr) {
return ERR_DM_FAILED;
}
std::shared_ptr<IpcNotifySetRemoteDeviceNameReq> pReq =
std::static_pointer_cast<IpcNotifySetRemoteDeviceNameReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
std::string deviceId = pReq->GetDeviceId();
if (!data.WriteString(deviceId)) {
LOGE("write deviceId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = pReq->GetResult();
if (!data.WriteInt32(result)) {
LOGE("write result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SET_REMOTE_DEVICE_NAME_RESULT, 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_CMD(RESTORE_LOCAL_DEVICE_NAME, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().RestoreLocalDeviceName(pkgName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_DEVICE_NETWORK_ID_LIST, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
NetworkIdQueryFilter queryFilter;
IpcModelCodec::DecodeNetworkIdQueryFilter(data, queryFilter);
std::vector<std::string> networkIds;
int32_t result = DeviceManagerService::GetInstance().GetDeviceNetworkIdList(pkgName, queryFilter, networkIds);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (result == DM_OK && !IpcModelCodec::EncodeStringVector(networkIds, reply)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNREGISTER_PIN_HOLDER_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().UnRegisterPinHolderCallback(pkgName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_LOCAL_DEVICE_NAME, MessageParcel &data, MessageParcel &reply)
{
std::string deviceName = "";
int32_t result = DeviceManagerService::GetInstance().GetLocalDeviceName(deviceName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(deviceName)) {
LOGE("write displayName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_LOCAL_DEVICE_NAME_OLD, MessageParcel &data, MessageParcel &reply)
{
std::string deviceName = "";
int32_t result = DeviceManagerService::GetInstance().GetLocalDeviceNameOld(deviceName);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteString(deviceName)) {
LOGE("write deviceName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(CHECK_SRC_ACCESS_CONTROL, MessageParcel &data, MessageParcel &reply)
{
return OnIpcCmd(CHECK_SRC_ACCESS_CONTROL, data, reply);
}
ON_IPC_CMD(CHECK_SINK_ACCESS_CONTROL, MessageParcel &data, MessageParcel &reply)
{
return OnIpcCmd(CHECK_SINK_ACCESS_CONTROL, data, reply);
}
ON_IPC_CMD(CHECK_SRC_SAME_ACCOUNT, MessageParcel &data, MessageParcel &reply)
{
return OnIpcCmd(CHECK_SRC_SAME_ACCOUNT, data, reply);
}
ON_IPC_CMD(CHECK_SINK_SAME_ACCOUNT, MessageParcel &data, MessageParcel &reply)
{
return OnIpcCmd(CHECK_SINK_SAME_ACCOUNT, data, reply);
}
ON_IPC_CMD(BIND_SERVICE_TARGET, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
PeerTargetId targetId;
DecodePeerTargetId(data, targetId);
std::string bindParamStr = data.ReadString();
std::map<std::string, std::string> bindParam;
ParseMapFromJsonString(bindParamStr, bindParam);
int32_t result = DeviceManagerService::GetInstance().BindServiceTarget(pkgName, targetId, bindParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(NOTIFY_SERVICE_FOUND, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyServiceFoundReq> pReq =
std::static_pointer_cast<IpcNotifyServiceFoundReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
DmServiceInfo dmServiceInfo = pReq->GetDmServiceInfo();
if (!IpcModelCodec::EncodeDmServiceInfo(dmServiceInfo, data)) {
LOGE("EncodeDmServiceInfo failed");
return ERR_DM_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(NOTIFY_SERVICE_FOUND, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_SET_REQUEST(NOTIFY_SERVICE_DISCOVERY_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyServiceDiscoverResultReq> pReq =
std::static_pointer_cast<IpcNotifyServiceDiscoverResultReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
std::string serviceType = pReq->GetServiceType();
if (!data.WriteString(serviceType)) {
LOGE("write serviceType failed");
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = pReq->GetResult();
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(NOTIFY_SERVICE_DISCOVERY_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(UNBIND_SERVICE_TARGET, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string unbindParamStr = data.ReadString();
std::map<std::string, std::string> unbindParam;
ParseMapFromJsonString(unbindParamStr, unbindParam);
std::string networkId = data.ReadString();
int64_t serviceId = data.ReadInt64();
int32_t result = DeviceManagerService::GetInstance().UnbindServiceTarget(pkgName,
unbindParam, networkId, serviceId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(REGISTER_SERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
DmRegisterServiceInfo regServiceInfo;
IpcModelCodec::DecodeDmRegServiceInfo(data, regServiceInfo);
int64_t serviceId = 0;
int32_t result = DeviceManagerService::GetInstance().RegisterServiceInfo(regServiceInfo, serviceId);
if (!reply.WriteInt32(result)) {
LOGE("Failed to write result to reply.");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt64(serviceId)) {
LOGE("Failed to write regServiceId to reply.");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(UNREGISTER_SERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
int64_t serviceId = data.ReadInt64();
int32_t result = DeviceManagerService::GetInstance().UnRegisterServiceInfo(serviceId);
if (!reply.WriteInt32(result)) {
LOGE("Failed to write result to reply.");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(START_PUBLISH_SERVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int64_t serviceId = data.ReadInt64();
DmPublishServiceParam publishServiceParam;
IpcModelCodec::DecodeDmPublishServiceParam(data, publishServiceParam);
int32_t result = DeviceManagerService::GetInstance().StartPublishService(pkgName, serviceId, publishServiceParam);
if (!reply.WriteInt32(result)) {
LOGE("Write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(STOP_PUBLISH_SERVICE, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int64_t serviceId = data.ReadInt64();
int32_t result = DeviceManagerService::GetInstance().StopPublishService(pkgName, serviceId);
if (!reply.WriteInt32(result)) {
LOGE("Write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVICE_PUBLISH_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcServicePublishResultReq> pReq = std::static_pointer_cast<IpcServicePublishResultReq>(pBaseReq);
int64_t serviceId = pReq->GetServiceId();
int32_t result = pReq->GetResult();
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt64(serviceId)) {
LOGE("write serviceId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVICE_PUBLISH_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(LEAVE_LNN, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string networkId = data.ReadString();
int32_t result = DeviceManagerService::GetInstance().LeaveLNN(pkgName, networkId);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(LEAVE_LNN_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
if (pBaseReq == nullptr) {
return ERR_DM_FAILED;
}
std::shared_ptr<IpcNotifyBindResultReq> pReq =
std::static_pointer_cast<IpcNotifyBindResultReq>(pBaseReq);
std::string networkId = pReq->GetContent();
if (!data.WriteString(networkId)) {
LOGE("write networkId failed");
return ERR_DM_IPC_WRITE_FAILED;
}
int32_t result = pReq->GetResult();
if (!data.WriteInt32(result)) {
LOGE("write result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(LEAVE_LNN_RESULT, 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_CMD(GET_AUTHTYPE_BY_UDIDHASH, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string udidHash = data.ReadString();
DMLocalServiceInfoAuthType authType = DMLocalServiceInfoAuthType::CANCEL;
int32_t result = DeviceManagerService::GetInstance().GetAuthTypeByUdidHash(udidHash, pkgName, authType);
if (!reply.WriteInt32(result)) {
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(static_cast<int32_t>(authType))) {
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(ON_AUTH_CODE_INVALID, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcReq> pReq = std::static_pointer_cast<IpcReq>(pBaseReq);
std::string pkgName = pReq->GetPkgName();
if (!data.WriteString(pkgName)) {
LOGE("write pkgName failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(ON_AUTH_CODE_INVALID, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(GET_IDENTIFICATION_BY_DEVICEIDS, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::vector<std::string> deviceIdList;
IpcModelCodec::DecodeStringVector(data, deviceIdList);
std::map<std::string, std::string> deviceIdentificationMap;
int32_t result = DeviceManagerService::GetInstance().GetIdentificationByDeviceIds(
pkgName, deviceIdList, deviceIdentificationMap);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (result == DM_OK && !deviceIdentificationMap.empty()) {
std::string outParaStr = ConvertMapToJsonString(deviceIdentificationMap);
if (!reply.WriteString(outParaStr)) {
LOGE("write returnJsonStr failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
return DM_OK;
}
ON_IPC_CMD(START_SERVICE_DISCOVERING, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
DmDiscoveryServiceParam discParam;
if (!IpcModelCodec::DecodeDmSrvDiscParam(data, discParam)) {
LOGE("DecodeSrvDiscParam failed");
return ERR_DM_FAILED;
}
int32_t result = DeviceManagerService::GetInstance().StartDiscoveryService(pkgName, discParam);
if (!reply.WriteInt32(result)) {
LOGE("Write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(STOP_SERVICE_DISCOVERING, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
DmDiscoveryServiceParam discParam;
if (!IpcModelCodec::DecodeDmSrvDiscParam(data, discParam)) {
LOGE("DecodeSrvDiscParam failed");
return ERR_DM_FAILED;
}
int32_t result = DeviceManagerService::GetInstance().StopDiscoveryService(pkgName, discParam);
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(SYNC_SERVICE_CALLBACK, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int64_t serviceId = data.ReadInt64();
int32_t dmCommonNotifyEvent = data.ReadInt32();
ProcessInfo processInfo;
processInfo.pkgName = pkgName;
MultipleUserConnector::GetCallerUserId(processInfo.userId);
MultipleUserConnector::GetCallingTokenId(processInfo.tokenId);
int32_t result = DeviceManagerServiceNotify::GetInstance().RegisterCallBack(dmCommonNotifyEvent, processInfo);
if (dmCommonNotifyEvent == static_cast<int32_t>(DmCommonNotifyEvent::REG_SERVICE_STATE)) {
DeviceManagerService::GetInstance().RegServiceStateCallback(pkgName, serviceId);
} else if (dmCommonNotifyEvent == static_cast<int32_t>(DmCommonNotifyEvent::UN_REG_SERVICE_STATE)) {
DeviceManagerService::GetInstance().UnRegServiceStateCallback(pkgName, serviceId);
} else {
LOGE("Request out of scope");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SERVER_SERVICE_STATE_NOTIFY, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcNotifyServiceStateReq> pReq = std::static_pointer_cast<IpcNotifyServiceStateReq>(pBaseReq);
DmRegisterServiceState registerServiceState = pReq->GetDmRegisterServiceState();
DmServiceInfo dmServiceInfo = pReq->GetDmServiceInfo();
int32_t serviceState = pReq->GetServiceState();
if (!IpcModelCodec::EncodeDmRegisterServiceState(registerServiceState, data)) {
LOGE("write register service info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!IpcModelCodec::EncodeDmServiceInfo(dmServiceInfo, data)) {
LOGE("write dm service info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(serviceState)) {
LOGE("write state failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SERVER_SERVICE_STATE_NOTIFY, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(SYNC_SERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
int32_t localUserId = data.ReadInt32();
std::string networkId = data.ReadString();
int64_t serviceId = data.ReadInt64();
int32_t result = -1;
if (serviceId > 0) {
result = DeviceManagerService::GetInstance().SyncServiceInfoByServiceId(pkgName, localUserId,
networkId, serviceId);
} else if (serviceId == 0) {
result = DeviceManagerService::GetInstance().SyncAllServiceInfo(pkgName, localUserId, networkId);
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_SET_REQUEST(SYNC_SERVICE_INFO_RESULT, std::shared_ptr<IpcReq> pBaseReq, MessageParcel &data)
{
CHECK_NULL_RETURN(pBaseReq, ERR_DM_FAILED);
std::shared_ptr<IpcSyncServiceInfoResultReq> pReq =
std::static_pointer_cast<IpcSyncServiceInfoResultReq>(pBaseReq);
ServiceSyncInfo serviceSyncInfo = pReq->GetServiceSyncInfo();
int32_t result = pReq->GetResult();
std::string content = pReq->GetContent();
if (!IpcModelCodec::EncodeServiceSyncInfo(serviceSyncInfo, data)) {
LOGE("write serviceSyncInfo failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteInt32(result)) {
LOGE("write result code failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!data.WriteString(content)) {
LOGE("write content failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_READ_RESPONSE(SYNC_SERVICE_INFO_RESULT, MessageParcel &reply, std::shared_ptr<IpcRsp> pBaseRsp)
{
CHECK_NULL_RETURN(pBaseRsp, ERR_DM_FAILED);
pBaseRsp->SetErrCode(reply.ReadInt32());
return DM_OK;
}
ON_IPC_CMD(GET_LOCAL_SERVICEINFO_BY_SERVICEID, MessageParcel &data, MessageParcel &reply)
{
int64_t serviceId = data.ReadInt64();
LOGI("GET_LOCAL_SERVICEINFO_BY_SERVICEID, serviceId: %{public}" PRId64, serviceId);
DmRegisterServiceInfo serviceInfo;
int32_t result = DeviceManagerService::GetInstance().GetLocalServiceInfoByServiceId(serviceId, serviceInfo);
if (!IpcModelCodec::EncodeDmRegServiceInfo(serviceInfo, reply)) {
LOGE("EncodeDmRegServiceInfo failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_TRUST_SERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string pkgName = data.ReadString();
std::string jsonParam = data.ReadString();
std::vector<DmServiceInfo> serviceList;
std::map<std::string, std::string> paramMap;
ParseMapFromJsonString(jsonParam, paramMap);
int32_t result = DeviceManagerService::GetInstance().GetTrustServiceInfo(pkgName, paramMap, serviceList);
if ((int32_t)serviceList.size() > SERVICE_LIST_MAX_SIZE) {
LOGE("service list over max size");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32((int32_t)serviceList.size())) {
LOGE("write device list size failed");
return ERR_DM_IPC_WRITE_FAILED;
}
for (const auto &serviceInfo : serviceList) {
if (!IpcModelCodec::EncodeDmServiceInfo(serviceInfo, reply)) {
LOGE("write dm device info failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_REGISTER_SERVICE_INFO, MessageParcel &data, MessageParcel &reply)
{
std::string jsonParam = data.ReadString();
std::map<std::string, std::string> paramMap;
ParseMapFromJsonString(jsonParam, paramMap);
std::vector<DmRegisterServiceInfo> regServiceInfos;
int32_t result = DeviceManagerService::GetInstance().GetRegisterServiceInfo(paramMap, regServiceInfos);
if ((int32_t)regServiceInfos.size() > SERVICE_LIST_MAX_SIZE) {
LOGE("service info list over max size");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32((int32_t)regServiceInfos.size())) {
LOGE("write regServiceInfos size failed");
return ERR_DM_IPC_WRITE_FAILED;
}
for (const auto ®ServiceInfo : regServiceInfos) {
if (!IpcModelCodec::EncodeDmRegServiceInfo(regServiceInfo, reply)) {
LOGE("write regServiceInfo failed");
return ERR_DM_IPC_WRITE_FAILED;
}
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
ON_IPC_CMD(GET_PEER_SERVICEINFO_BY_SERVICEID, MessageParcel &data, MessageParcel &reply)
{
std::string networkId = data.ReadString();
int64_t serviceId = data.ReadInt64();
DmRegisterServiceInfo serviceInfo;
int32_t result = DeviceManagerService::GetInstance().GetPeerServiceInfoByServiceId(networkId,
serviceId, serviceInfo);
if (!IpcModelCodec::EncodeDmRegServiceInfo(serviceInfo, reply)) {
LOGE("EncodeDmRegServiceInfo failed");
return ERR_DM_IPC_WRITE_FAILED;
}
if (!reply.WriteInt32(result)) {
LOGE("write result failed");
return ERR_DM_IPC_WRITE_FAILED;
}
return DM_OK;
}
}
}