mirror of
https://github.com/openharmony/drivers_peripheral.git
synced 2026-08-24 07:45:51 -04:00
yanghang
548 lines
20 KiB
C++
548 lines
20 KiB
C++
/*
|
|
* Copyright (c) 2022 Huawei Device Co., Ltd.
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "input_interfaces_impl.h"
|
|
#include <hdf_base.h>
|
|
#include <iproxy_broker.h>
|
|
#include <mutex>
|
|
#include <securec.h>
|
|
#include "input_uhdf_log.h"
|
|
#include "input_manager.h"
|
|
#include "input_type.h"
|
|
#include "osal_mem.h"
|
|
|
|
#define HDF_LOG_TAG InputInterfacesImpl
|
|
|
|
namespace OHOS {
|
|
namespace HDI {
|
|
namespace Input {
|
|
namespace V1_0 {
|
|
namespace {
|
|
constexpr uint32_t MAX_DEVICES = 32;
|
|
InputEventCb eventCb;
|
|
InputHostCb hostCb;
|
|
sptr<IInputCallback> g_inputEventCallback = nullptr;
|
|
sptr<IInputCallback> g_hotplugEventCallback = nullptr;
|
|
std::mutex g_mutex;
|
|
}
|
|
|
|
extern "C" IInputInterfaces *InputInterfacesImplGetInstance(void)
|
|
{
|
|
using OHOS::HDI::Input::V1_0::InputInterfacesImpl;
|
|
InputInterfacesImpl *service = new (std::nothrow) InputInterfacesImpl();
|
|
if (service == nullptr) {
|
|
return nullptr;
|
|
}
|
|
|
|
service->Init();
|
|
return service;
|
|
}
|
|
|
|
static struct DeviceInfo TransferDevInfo(InputDeviceInfo &halDevInfo)
|
|
{
|
|
DeviceInfo hdiDevInfo;
|
|
hdiDevInfo.devIndex = halDevInfo.devIndex;
|
|
hdiDevInfo.devType = halDevInfo.devType;
|
|
hdiDevInfo.chipInfo = halDevInfo.chipInfo;
|
|
hdiDevInfo.vendorName = halDevInfo.vendorName;
|
|
hdiDevInfo.chipName = halDevInfo.chipName;
|
|
hdiDevInfo.attrSet.devName = halDevInfo.attrSet.devName;
|
|
hdiDevInfo.attrSet.id.busType = halDevInfo.attrSet.id.busType;
|
|
hdiDevInfo.attrSet.id.vendor = halDevInfo.attrSet.id.vendor;
|
|
hdiDevInfo.attrSet.id.product = halDevInfo.attrSet.id.product;
|
|
hdiDevInfo.attrSet.id.version = halDevInfo.attrSet.id.version;
|
|
hdiDevInfo.attrSet.axisInfo.resize(ABS_CNT);
|
|
for (int32_t i = 0; i < ABS_CNT; i++) {
|
|
hdiDevInfo.attrSet.axisInfo[i].axis = halDevInfo.attrSet.axisInfo[i].axis;
|
|
hdiDevInfo.attrSet.axisInfo[i].min = halDevInfo.attrSet.axisInfo[i].min;
|
|
hdiDevInfo.attrSet.axisInfo[i].max = halDevInfo.attrSet.axisInfo[i].max;
|
|
hdiDevInfo.attrSet.axisInfo[i].fuzz = halDevInfo.attrSet.axisInfo[i].fuzz;
|
|
hdiDevInfo.attrSet.axisInfo[i].flat = halDevInfo.attrSet.axisInfo[i].flat;
|
|
hdiDevInfo.attrSet.axisInfo[i].range = halDevInfo.attrSet.axisInfo[i].range;
|
|
}
|
|
hdiDevInfo.abilitySet.devProp.assign(halDevInfo.abilitySet.devProp,
|
|
halDevInfo.abilitySet.devProp + BITS_TO_UINT64(INPUT_PROP_CNT));
|
|
hdiDevInfo.abilitySet.eventType.assign(halDevInfo.abilitySet.eventType,
|
|
halDevInfo.abilitySet.eventType + BITS_TO_UINT64(EV_CNT));
|
|
hdiDevInfo.abilitySet.absCode.assign(halDevInfo.abilitySet.absCode,
|
|
halDevInfo.abilitySet.absCode + BITS_TO_UINT64(ABS_CNT));
|
|
hdiDevInfo.abilitySet.relCode.assign(halDevInfo.abilitySet.relCode,
|
|
halDevInfo.abilitySet.relCode + BITS_TO_UINT64(REL_CNT));
|
|
hdiDevInfo.abilitySet.keyCode.assign(halDevInfo.abilitySet.keyCode,
|
|
halDevInfo.abilitySet.keyCode + BITS_TO_UINT64(KEY_CNT));
|
|
hdiDevInfo.abilitySet.ledCode.assign(halDevInfo.abilitySet.ledCode,
|
|
halDevInfo.abilitySet.ledCode + BITS_TO_UINT64(LED_CNT));
|
|
hdiDevInfo.abilitySet.miscCode.assign(halDevInfo.abilitySet.miscCode,
|
|
halDevInfo.abilitySet.miscCode + BITS_TO_UINT64(MSC_CNT));
|
|
hdiDevInfo.abilitySet.soundCode.assign(halDevInfo.abilitySet.soundCode,
|
|
halDevInfo.abilitySet.soundCode + BITS_TO_UINT64(SND_CNT));
|
|
hdiDevInfo.abilitySet.forceCode.assign(halDevInfo.abilitySet.forceCode,
|
|
halDevInfo.abilitySet.forceCode + BITS_TO_UINT64(HDF_FF_CNT));
|
|
hdiDevInfo.abilitySet.switchCode.assign(halDevInfo.abilitySet.switchCode,
|
|
halDevInfo.abilitySet.switchCode + BITS_TO_UINT64(SW_CNT));
|
|
hdiDevInfo.abilitySet.keyType.assign(halDevInfo.abilitySet.keyType,
|
|
halDevInfo.abilitySet.keyType + BITS_TO_UINT64(KEY_CNT));
|
|
hdiDevInfo.abilitySet.ledType.assign(halDevInfo.abilitySet.ledType,
|
|
halDevInfo.abilitySet.ledType + BITS_TO_UINT64(LED_CNT));
|
|
hdiDevInfo.abilitySet.soundType.assign(halDevInfo.abilitySet.soundType,
|
|
halDevInfo.abilitySet.soundType + BITS_TO_UINT64(SND_CNT));
|
|
hdiDevInfo.abilitySet.switchType.assign(halDevInfo.abilitySet.switchType,
|
|
halDevInfo.abilitySet.switchType + BITS_TO_UINT64(SW_CNT));
|
|
return hdiDevInfo;
|
|
}
|
|
|
|
void InputEventDataCallback(const InputEventPackage **pkgs, uint32_t count, uint32_t devIndex)
|
|
{
|
|
if (pkgs == nullptr || *pkgs == nullptr) {
|
|
HDF_LOGE("%{public}s failed, pkgs is nullptr", __func__);
|
|
return;
|
|
}
|
|
|
|
std::vector<EventPackage> tmp;
|
|
for (uint32_t i = 0; i < count; i++) {
|
|
if (pkgs[i] == nullptr) {
|
|
HDF_LOGE("%{public}s failed, pkgs[%{public}u] is nullptr", __func__, i);
|
|
return;
|
|
}
|
|
EventPackage InputEvents;
|
|
InputEvents.type = pkgs[i]->type;
|
|
InputEvents.code = pkgs[i]->code;
|
|
InputEvents.value = pkgs[i]->value;
|
|
InputEvents.timestamp = pkgs[i]->timestamp;
|
|
tmp.push_back(InputEvents);
|
|
}
|
|
|
|
if (g_inputEventCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: g_inputEventCallback is nullptr", __func__);
|
|
return;
|
|
}
|
|
g_inputEventCallback->EventPkgCallback(tmp, devIndex);
|
|
}
|
|
|
|
void HotplugEventDataCallback(const InputHotPlugEvent *event)
|
|
{
|
|
if (event == nullptr) {
|
|
HDF_LOGE("%{public}s failed, pkgs is nullptr", __func__);
|
|
return;
|
|
}
|
|
|
|
HotPlugEvent HotPlugEvent;
|
|
HotPlugEvent.devIndex = event->devIndex;
|
|
HotPlugEvent.devType = event->devType;
|
|
HotPlugEvent.status = event->status;
|
|
|
|
if (g_hotplugEventCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: g_hotplugEventCallback is nullptr", __func__);
|
|
return;
|
|
}
|
|
g_hotplugEventCallback->HotPlugCallback(HotPlugEvent);
|
|
}
|
|
|
|
void InputInterfacesImpl::Init()
|
|
{
|
|
int32_t ret = GetInputInterface(&inputInterface_);
|
|
if (inputInterface_ == nullptr || ret != HDF_SUCCESS) {
|
|
HDF_LOGE("%{public}s: get input Module instance failed", __func__);
|
|
}
|
|
|
|
eventCb.EventPkgCallback = InputEventDataCallback;
|
|
hostCb.HotPlugCallback = HotplugEventDataCallback;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::ScanInputDevice(std::vector<DevDesc> &staArr)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputManager == nullptr ||
|
|
inputInterface_->iInputManager->ScanInputDevice == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
InputDevDesc staArrHdf[MAX_DEVICES];
|
|
int32_t ret = memset_s(staArrHdf, MAX_DEVICES * sizeof(InputDevDesc), 0, MAX_DEVICES * sizeof(InputDevDesc));
|
|
if (ret != HDF_SUCCESS) {
|
|
HDF_LOGE("%{public}s: memset failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
ret = inputInterface_->iInputManager->ScanInputDevice(staArrHdf, MAX_DEVICES);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < MAX_DEVICES; i++) {
|
|
DevDesc StaArr;
|
|
StaArr.devIndex = staArrHdf[i].devIndex;
|
|
StaArr.devType = staArrHdf[i].devType;
|
|
staArr.push_back(StaArr);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::OpenInputDevice(uint32_t devIndex)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputManager == nullptr ||
|
|
inputInterface_->iInputManager->OpenInputDevice == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputManager->OpenInputDevice(devIndex);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::CloseInputDevice(uint32_t devIndex)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputManager == nullptr ||
|
|
inputInterface_->iInputManager->CloseInputDevice == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputManager->CloseInputDevice(devIndex);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetInputDevice(uint32_t devIndex, DeviceInfo &devInfo)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputManager == nullptr ||
|
|
inputInterface_->iInputManager->GetInputDevice == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
InputDeviceInfo *deviceInfo = nullptr;
|
|
|
|
int32_t ret = inputInterface_->iInputManager->GetInputDevice(devIndex, &deviceInfo);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return ret;
|
|
}
|
|
|
|
if (deviceInfo == nullptr) {
|
|
HDF_LOGE("%{public}s get deviceInfo failed, info is null", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
devInfo = TransferDevInfo(*deviceInfo);
|
|
#ifdef DRIVERS_PERIPHERAL_INPUT_FEATURE_UDRIVER
|
|
OsalMemFree(deviceInfo);
|
|
#endif /* DRIVERS_PERIPHERAL_INPUT_FEATURE_UDRIVER */
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetInputDeviceList(uint32_t &devNum, std::vector<DeviceInfo> &devList, uint32_t size)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputManager == nullptr ||
|
|
inputInterface_->iInputManager->GetInputDeviceList == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
InputDeviceInfo *deviceList = nullptr;
|
|
InputDeviceInfo *tmp = nullptr;
|
|
DeviceInfo hdfDevInfo;
|
|
|
|
int32_t ret = inputInterface_->iInputManager->GetInputDeviceList(&devNum, &deviceList, size);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
tmp = deviceList;
|
|
if (tmp == nullptr) {
|
|
HDF_LOGE("%{public}s deviceList is null", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
devList.reserve(devNum);
|
|
for (uint32_t i = 0; i < devNum; i++) {
|
|
hdfDevInfo = TransferDevInfo(*tmp);
|
|
devList.push_back(hdfDevInfo);
|
|
tmp++;
|
|
}
|
|
#ifdef DRIVERS_PERIPHERAL_INPUT_FEATURE_UDRIVER
|
|
OsalMemFree(deviceList);
|
|
#endif /* DRIVERS_PERIPHERAL_INPUT_FEATURE_UDRIVER */
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::SetPowerStatus(uint32_t devIndex, uint32_t status)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->SetPowerStatus == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputController->SetPowerStatus(devIndex, status);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetPowerStatus(uint32_t devIndex, uint32_t &status)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->GetPowerStatus == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputController->GetPowerStatus(devIndex, &status);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetDeviceType(uint32_t devIndex, uint32_t &deviceType)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->GetDeviceType == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputController->GetDeviceType(devIndex, &deviceType);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetChipInfo(uint32_t devIndex, std::string &chipInfo)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->GetChipInfo == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
char infoStr[CHIP_INFO_LEN] = {0};
|
|
int32_t ret = inputInterface_->iInputController->GetChipInfo(devIndex, infoStr, CHIP_INFO_LEN);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
chipInfo.assign(infoStr);
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetVendorName(uint32_t devIndex, std::string &vendorName)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->GetVendorName == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
char infoStr[VENDOR_NAME_LEN] = {0};
|
|
int32_t ret = inputInterface_->iInputController->GetVendorName(devIndex, infoStr, VENDOR_NAME_LEN);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
vendorName.assign(infoStr);
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::GetChipName(uint32_t devIndex, std::string &chipName)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->GetChipName == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
char infoStr[CHIP_NAME_LEN] = {0};
|
|
int32_t ret = inputInterface_->iInputController->GetChipName(devIndex, infoStr, CHIP_NAME_LEN);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
chipName.assign(infoStr);
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::SetGestureMode(uint32_t devIndex, uint32_t gestureMode)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->SetGestureMode == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputController->SetGestureMode(devIndex, gestureMode);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::RunCapacitanceTest(uint32_t devIndex, uint32_t testType, std::string &result,
|
|
uint32_t length)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->RunCapacitanceTest == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputController->RunCapacitanceTest(devIndex, testType, result.data(), length);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::RunExtraCommand(uint32_t devIndex, const ExtraCmd &cmd)
|
|
{
|
|
InputExtraCmd cmdInfo;
|
|
cmdInfo.cmdCode = cmd.cmdCode.c_str();
|
|
cmdInfo.cmdValue = cmd.cmdValue.c_str();
|
|
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputController == nullptr ||
|
|
inputInterface_->iInputController->RunExtraCommand == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputController->RunExtraCommand(devIndex, &cmdInfo);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::RegisterReportCallback(uint32_t devIndex, const sptr<IInputCallback> &eventPkgCallback)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputReporter == nullptr ||
|
|
inputInterface_->iInputReporter->RegisterReportCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
if (devIndex >= MAX_INPUT_DEV_NUM) {
|
|
HDF_LOGE("%{public}s: devIndex [%{public}d] out of range", __func__, devIndex);
|
|
return INPUT_INVALID_PARAM;
|
|
}
|
|
|
|
if (eventPkgCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: eventPkgCallback is null", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = HDF_FAILURE;
|
|
ret = inputInterface_->iInputReporter->RegisterReportCallback(devIndex, &eventCb);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, ret[%{public}d]", __func__, ret);
|
|
return ret;
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(g_mutex);
|
|
g_inputEventCallback = eventPkgCallback;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::UnregisterReportCallback(uint32_t devIndex)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputReporter == nullptr ||
|
|
inputInterface_->iInputReporter->UnregisterReportCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputReporter->UnregisterReportCallback(devIndex);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return ret;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::RegisterHotPlugCallback(const sptr<IInputCallback> &hotPlugCallback)
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputReporter == nullptr ||
|
|
inputInterface_->iInputReporter->UnregisterReportCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
if (hotPlugCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: hotPlugCallback is null", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
if (g_hotplugEventCallback != nullptr) {
|
|
return g_hotplugEventCallback == hotPlugCallback;
|
|
}
|
|
|
|
int32_t ret = HDF_FAILURE;
|
|
ret = inputInterface_->iInputReporter->RegisterHotPlugCallback(&hostCb);
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, ret[%{public}d]", __func__, ret);
|
|
return ret;
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(g_mutex);
|
|
g_hotplugEventCallback = hotPlugCallback;
|
|
|
|
return ret;
|
|
}
|
|
|
|
int32_t InputInterfacesImpl::UnregisterHotPlugCallback()
|
|
{
|
|
if (inputInterface_ == nullptr || inputInterface_->iInputReporter == nullptr ||
|
|
inputInterface_->iInputReporter->UnregisterHotPlugCallback == nullptr) {
|
|
HDF_LOGE("%{public}s: get input device Module instance failed", __func__);
|
|
return HDF_FAILURE;
|
|
}
|
|
|
|
int32_t ret = inputInterface_->iInputReporter->UnregisterHotPlugCallback();
|
|
if (ret != INPUT_SUCCESS) {
|
|
HDF_LOGE("%{public}s failed, error code is %{public}d", __func__, ret);
|
|
return ret;
|
|
}
|
|
|
|
std::lock_guard<std::mutex> lock(g_mutex);
|
|
g_hotplugEventCallback = nullptr;
|
|
|
|
return ret;
|
|
}
|
|
} // V1_0
|
|
} // Input
|
|
} // HDI
|
|
} // OHOS
|