openharmony/distributedhardware_distributed_input
1
0
Fork 0
mirror of https://github.com/openharmony/distributedhardware_distributed_input.git synced 2026-07-19 09:36:05 -04:00
Code Issues Packages Projects Releases Wiki Activity

update interfaces/ipc/src/distributed_input_source_stub.cpp.

Browse Source 
Signed-off-by: ry521 <renyi50@huawei.com>
This commit is contained in:
ry521
2023-09-27 09:49:55 +00:00
committed by Gitee
parent 10e2d1652e
commit 6d41fdccde
1 changed files with 380 additions and 415 deletions
Download Patch File Download Diff File Expand all files Collapse all files
interfaces/ipc/src/distributed_input_source_stub.cpp
+380 -415
View File
@@ -84,469 +84,440 @@ void DistributedInputSourceStub::RegRespFunMap()
memberFuncMap_[static_cast<uint32_t>(IDInputSourceInterfaceCode::UNREGISTER_SESSION_STATE_CB)] =
&DistributedInputSourceStub::HandleUnregisterSessionStateCb;
}
int32_t DistributedInputSourceStub::HandleInitDistributedHardware(MessageParcel &reply)
bool DScreenSourceStub::HasEnableDHPermission()
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
const std::string permissionName = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::unique_lock<std::mutex> lock(operatorMutex_);
if (sourceManagerInitFlag_.load()) {
DHLOGE("DistributedInputSourceStub already init.");
return DH_SUCCESS;
}
int32_t ret = Init();
if (!reply.WriteInt32(ret)) {
DHLOGE("DistributedInputSourceStub Init write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
sourceManagerInitFlag_.store(true);
DHLOGE("Enable Permission vailable");
permissionName);
return (result == Security::AccessToken::PERMISSION_GRANTED);
}
bool DScreenSourceStub::HasAccessDHPermission()
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
const std::string permissionName = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
permissionName);
return (result == Security::AccessToken::PERMISSION_GRANTED);
}
int32_t DistributedInputSourceStub::HandleInitDistributedHardware(MessageParcel &reply)
{
if (!HasEnableDHPermission()) {
DHLOGE("Enable Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
std::unique_lock<std::mutex> lock(operatorMutex_);
if (sourceManagerInitFlag_.load()) {
DHLOGE("DistributedInputSourceStub already init.");
return DH_SUCCESS;
}
DHLOGE("Enable Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
int32_t ret = Init();
if (!reply.WriteInt32(ret)) {
DHLOGE("DistributedInputSourceStub Init write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
sourceManagerInitFlag_.store(true);
DHLOGE("Enable Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleReleaseDistributedHardware(MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::unique_lock<std::mutex> lock(operatorMutex_);
if (!sourceManagerInitFlag_.load()) {
DHLOGE("DistributedInputSourceStub already Release.");
return DH_SUCCESS;
}
int32_t ret = Release();
if (!reply.WriteInt32(ret)) {
DHLOGE("DistributedInputSourceStub release write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
sourceManagerInitFlag_.store(false);
DHLOGE("Enable Permission vailable");
if (!HasEnableDHPermission()) {
DHLOGE("Enable Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
std::unique_lock<std::mutex> lock(operatorMutex_);
if (!sourceManagerInitFlag_.load()) {
DHLOGE("DistributedInputSourceStub already Release.");
return DH_SUCCESS;
}
DHLOGE("Enable Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
int32_t ret = Release();
if (!reply.WriteInt32(ret)) {
DHLOGE("DistributedInputSourceStub release write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
sourceManagerInitFlag_.store(false);
DHLOGE("Enable Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleRegisterDistributedHardware(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string devId = data.ReadString();
std::string dhId = data.ReadString();
std::string params = data.ReadString();
sptr<IRegisterDInputCallback> callback = iface_cast<IRegisterDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleRegisterDistributedHardware failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = RegisterDistributedHardware(devId, dhId, params, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleRegisterDistributedHardware write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
DHLOGE("Enable Permission vailable");
return DH_SUCCESS;
if (!HasEnableDHPermission()) {
DHLOGE("Enable Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Enable Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string devId = data.ReadString();
std::string dhId = data.ReadString();
std::string params = data.ReadString();
sptr<IRegisterDInputCallback> callback = iface_cast<IRegisterDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleRegisterDistributedHardware failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = RegisterDistributedHardware(devId, dhId, params, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleRegisterDistributedHardware write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
DHLOGE("Enable Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleUnregisterDistributedHardware(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ENABLE_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string devId = data.ReadString();
std::string dhId = data.ReadString();
sptr<IUnregisterDInputCallback> callback = iface_cast<IUnregisterDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleUnregisterDistributedHardware failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = UnregisterDistributedHardware(devId, dhId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnregisterDistributedHardware write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
DHLOGE("Enable Permission vailable");
return DH_SUCCESS;
if (!HasEnableDHPermission()) {
DHLOGE("Enable Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Enable Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string devId = data.ReadString();
std::string dhId = data.ReadString();
sptr<IUnregisterDInputCallback> callback = iface_cast<IUnregisterDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleUnregisterDistributedHardware failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = UnregisterDistributedHardware(devId, dhId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnregisterDistributedHardware write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
DHLOGE("Enable Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandlePrepareRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string deviceId = data.ReadString();
sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandlePrepareRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = PrepareRemoteInput(deviceId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandlePrepareRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string deviceId = data.ReadString();
sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandlePrepareRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = PrepareRemoteInput(deviceId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandlePrepareRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_TOKEN_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleUnprepareRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string deviceId = data.ReadString();
sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleUnprepareRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = UnprepareRemoteInput(deviceId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnprepareRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string deviceId = data.ReadString();
sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleUnprepareRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = UnprepareRemoteInput(deviceId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnprepareRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStartRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string deviceId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(deviceId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string deviceId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(deviceId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStopRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string deviceId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(deviceId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string deviceId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(deviceId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStartRelayTypeRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartRelayTypeRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(srcId, sinkId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartRelayTypeRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStartDInputCallback> callback = iface_cast<IStartDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartRelayTypeRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(srcId, sinkId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartRelayTypeRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStopRelayTypeRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopRelayTypeRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(srcId, sinkId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopRelayTypeRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
uint32_t inputTypes = data.ReadUint32();
sptr<IStopDInputCallback> callback = iface_cast<IStopDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopRelayTypeRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(srcId, sinkId, inputTypes, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopRelayTypeRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandlePrepareRelayRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandlePrepareRelayRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = PrepareRemoteInput(srcId, sinkId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandlePrepareRelayRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
sptr<IPrepareDInputCallback> callback = iface_cast<IPrepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandlePrepareRelayRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = PrepareRemoteInput(srcId, sinkId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandlePrepareRelayRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleUnprepareRelayRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleUnprepareRelayRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = UnprepareRemoteInput(srcId, sinkId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnprepareRelayRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
sptr<IUnprepareDInputCallback> callback = iface_cast<IUnprepareDInputCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleUnprepareRelayRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = UnprepareRemoteInput(srcId, sinkId, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnprepareRelayRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStartDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStartDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStartDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStartDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStartDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStopDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStopDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStopDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStopDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStopDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStartRelayDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStartRelayDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStartRelayDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartRelayDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(srcId, sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartRelayDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStartRelayDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStartRelayDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStartRelayDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StartRemoteInput(srcId, sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStartRelayDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleStopRelayDhidRemoteInput(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStopRelayDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStopRelayDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopRelayDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(srcId, sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopRelayDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
std::string srcId = data.ReadString();
std::string sinkId = data.ReadString();
std::vector<std::string> tempVector;
uint32_t vecSize = data.ReadUint32();
if (vecSize > IPC_VECTOR_MAX_SIZE) {
DHLOGE("HandleStopRelayDhidRemoteInput vecSize too large");
return ERR_DH_INPUT_IPC_READ_VALID_FAIL;
}
for (uint32_t i = 0; i < vecSize; i++) {
std::string dhid = data.ReadString();
if (dhid.empty()) {
DHLOGE("HandleStopRelayDhidRemoteInput dhid is empty");
continue;
}
tempVector.push_back(dhid);
}
sptr<IStartStopDInputsCallback> callback = iface_cast<IStartStopDInputsCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleStopRelayDhidRemoteInput failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = StopRemoteInput(srcId, sinkId, tempVector, callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleStopRelayDhidRemoteInput write ret failed");
return ERR_DH_INPUT_IPC_WRITE_VALID_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleSyncNodeInfoRemoteInput(MessageParcel &data, MessageParcel &reply)
@@ -659,45 +630,39 @@ int32_t DistributedInputSourceStub::HandleUnregisterSimulationEventListener(Mess
int32_t DistributedInputSourceStub::HandleRegisterSessionStateCb(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
sptr<ISessionStateCallback> callback = iface_cast<ISessionStateCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleRegisterSessionStateCb failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = RegisterSessionStateCb(callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleRegisterSessionStateCb write ret failed, ret = %d", ret);
return ERR_DH_INPUT_SRC_STUB_REGISTER_SESSION_STATE_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
sptr<ISessionStateCallback> callback = iface_cast<ISessionStateCallback>(data.ReadRemoteObject());
if (callback == nullptr) {
DHLOGE("HandleRegisterSessionStateCb failed, callback is nullptr.");
return ERR_DH_INPUT_POINTER_NULL;
}
int32_t ret = RegisterSessionStateCb(callback);
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleRegisterSessionStateCb write ret failed, ret = %d", ret);
return ERR_DH_INPUT_SRC_STUB_REGISTER_SESSION_STATE_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::HandleUnregisterSessionStateCb(MessageParcel &data, MessageParcel &reply)
{
Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
"ohos.permission.ACCESS_DISTRIBUTED_HARDWARE");
if (result == Security::AccessToken::PERMISSION_GRANTED) {
int32_t ret = UnregisterSessionStateCb();
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnregisterSessionStateCb write ret failed, ret = %d", ret);
return ERR_DH_INPUT_SRC_STUB_UNREGISTER_SESSION_STATE_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
if (!HasAccessDHPermission()) {
DHLOGE("Access Permission inlvaliable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
}
DHLOGE("Access Permission invailable");
return ERR_DH_INPUT_CLIENT_STOP_FAIL;
int32_t ret = UnregisterSessionStateCb();
if (!reply.WriteInt32(ret)) {
DHLOGE("HandleUnregisterSessionStateCb write ret failed, ret = %d", ret);
return ERR_DH_INPUT_SRC_STUB_UNREGISTER_SESSION_STATE_FAIL;
}
DHLOGE("Access Permission vailable");
return DH_SUCCESS;
}
int32_t DistributedInputSourceStub::OnRemoteRequest(