| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * 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. |
| */ |
| |
| #define LOG_TAG "InputHub" |
| //#define LOG_NDEBUG 0 |
| |
| #include "InputHub.h" |
| |
| #include <dirent.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <sys/capability.h> |
| #include <sys/epoll.h> |
| #include <sys/eventfd.h> |
| #include <sys/inotify.h> |
| #include <sys/ioctl.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <sys/utsname.h> |
| #include <unistd.h> |
| |
| #include <vector> |
| |
| #include <android/input.h> |
| #include <hardware_legacy/power.h> |
| #include <linux/input.h> |
| |
| #include <utils/Log.h> |
| |
| #include "BitUtils.h" |
| |
| namespace android { |
| |
| static const char WAKE_LOCK_ID[] = "KeyEvents"; |
| static const int NO_TIMEOUT = -1; |
| static const int EPOLL_MAX_EVENTS = 16; |
| static const int INPUT_MAX_EVENTS = 128; |
| |
| static constexpr bool testBit(int bit, const uint8_t arr[]) { |
| return arr[bit / 8] & (1 << (bit % 8)); |
| } |
| |
| static constexpr size_t sizeofBitArray(size_t bits) { |
| return (bits + 7) / 8; |
| } |
| |
| static void getLinuxRelease(int* major, int* minor) { |
| struct utsname info; |
| if (uname(&info) || sscanf(info.release, "%d.%d", major, minor) <= 0) { |
| *major = 0, *minor = 0; |
| ALOGE("Could not get linux version: %s", strerror(errno)); |
| } |
| } |
| |
| class EvdevDeviceNode : public InputDeviceNode { |
| public: |
| static EvdevDeviceNode* openDeviceNode(const std::string& path); |
| |
| virtual ~EvdevDeviceNode() { |
| ALOGV("closing %s (fd=%d)", mPath.c_str(), mFd); |
| if (mFd >= 0) { |
| ::close(mFd); |
| } |
| } |
| |
| virtual int getFd() const { return mFd; } |
| virtual const std::string& getPath() const override { return mPath; } |
| virtual const std::string& getName() const override { return mName; } |
| virtual const std::string& getLocation() const override { return mLocation; } |
| virtual const std::string& getUniqueId() const override { return mUniqueId; } |
| |
| virtual uint16_t getBusType() const override { return mBusType; } |
| virtual uint16_t getVendorId() const override { return mVendorId; } |
| virtual uint16_t getProductId() const override { return mProductId; } |
| virtual uint16_t getVersion() const override { return mVersion; } |
| |
| virtual bool hasKey(int32_t key) const override; |
| virtual bool hasKeyInRange(int32_t start, int32_t end) const override; |
| virtual bool hasRelativeAxis(int32_t axis) const override; |
| virtual bool hasAbsoluteAxis(int32_t axis) const override; |
| virtual bool hasSwitch(int32_t sw) const override; |
| virtual bool hasForceFeedback(int32_t ff) const override; |
| virtual bool hasInputProperty(int property) const override; |
| |
| virtual int32_t getKeyState(int32_t key) const override; |
| virtual int32_t getSwitchState(int32_t sw) const override; |
| virtual const AbsoluteAxisInfo* getAbsoluteAxisInfo(int32_t axis) const override; |
| virtual status_t getAbsoluteAxisValue(int32_t axis, int32_t* outValue) const override; |
| |
| virtual void vibrate(nsecs_t duration) override; |
| virtual void cancelVibrate() override; |
| |
| virtual void disableDriverKeyRepeat() override; |
| |
| private: |
| EvdevDeviceNode(const std::string& path, int fd) : |
| mFd(fd), mPath(path) {} |
| |
| status_t queryProperties(); |
| void queryAxisInfo(); |
| |
| int mFd; |
| std::string mPath; |
| |
| std::string mName; |
| std::string mLocation; |
| std::string mUniqueId; |
| |
| uint16_t mBusType; |
| uint16_t mVendorId; |
| uint16_t mProductId; |
| uint16_t mVersion; |
| |
| uint8_t mKeyBitmask[KEY_CNT / 8]; |
| uint8_t mAbsBitmask[ABS_CNT / 8]; |
| uint8_t mRelBitmask[REL_CNT / 8]; |
| uint8_t mSwBitmask[SW_CNT / 8]; |
| uint8_t mLedBitmask[LED_CNT / 8]; |
| uint8_t mFfBitmask[FF_CNT / 8]; |
| uint8_t mPropBitmask[INPUT_PROP_CNT / 8]; |
| |
| std::unordered_map<uint32_t, std::unique_ptr<AbsoluteAxisInfo>> mAbsInfo; |
| |
| bool mFfEffectPlaying = false; |
| int16_t mFfEffectId = -1; |
| }; |
| |
| EvdevDeviceNode* EvdevDeviceNode::openDeviceNode(const std::string& path) { |
| auto fd = TEMP_FAILURE_RETRY(::open(path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)); |
| if (fd < 0) { |
| ALOGE("could not open evdev device %s. err=%d", path.c_str(), errno); |
| return nullptr; |
| } |
| |
| // Tell the kernel that we want to use the monotonic clock for reporting |
| // timestamps associated with input events. This is important because the |
| // input system uses the timestamps extensively and assumes they were |
| // recorded using the monotonic clock. |
| // |
| // The EVIOCSCLOCKID ioctl was introduced in Linux 3.4. |
| int clockId = CLOCK_MONOTONIC; |
| if (TEMP_FAILURE_RETRY(ioctl(fd, EVIOCSCLOCKID, &clockId)) < 0) { |
| ALOGW("Could not set input clock id to CLOCK_MONOTONIC. errno=%d", errno); |
| } |
| |
| auto node = new EvdevDeviceNode(path, fd); |
| status_t ret = node->queryProperties(); |
| if (ret != OK) { |
| ALOGE("could not open evdev device %s: failed to read properties. errno=%d", |
| path.c_str(), ret); |
| delete node; |
| return nullptr; |
| } |
| return node; |
| } |
| |
| status_t EvdevDeviceNode::queryProperties() { |
| char buffer[80]; |
| |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGNAME(sizeof(buffer) - 1), buffer)) < 1) { |
| ALOGV("could not get device name for %s.", mPath.c_str()); |
| } else { |
| buffer[sizeof(buffer) - 1] = '\0'; |
| mName = buffer; |
| } |
| |
| int driverVersion; |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGVERSION, &driverVersion))) { |
| ALOGE("could not get driver version for %s. err=%d", mPath.c_str(), errno); |
| return -errno; |
| } |
| |
| struct input_id inputId; |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGID, &inputId))) { |
| ALOGE("could not get device input id for %s. err=%d", mPath.c_str(), errno); |
| return -errno; |
| } |
| mBusType = inputId.bustype; |
| mVendorId = inputId.vendor; |
| mProductId = inputId.product; |
| mVersion = inputId.version; |
| |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGPHYS(sizeof(buffer) - 1), buffer)) < 1) { |
| ALOGV("could not get location for %s.", mPath.c_str()); |
| } else { |
| buffer[sizeof(buffer) - 1] = '\0'; |
| mLocation = buffer; |
| } |
| |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGUNIQ(sizeof(buffer) - 1), buffer)) < 1) { |
| ALOGV("could not get unique id for %s.", mPath.c_str()); |
| } else { |
| buffer[sizeof(buffer) - 1] = '\0'; |
| mUniqueId = buffer; |
| } |
| |
| ALOGV("add device %s", mPath.c_str()); |
| ALOGV(" bus: %04x\n" |
| " vendor: %04x\n" |
| " product: %04x\n" |
| " version: %04x\n", |
| mBusType, mVendorId, mProductId, mVersion); |
| ALOGV(" name: \"%s\"\n" |
| " location: \"%s\"\n" |
| " unique_id: \"%s\"\n" |
| " descriptor: (TODO)\n" |
| " driver: v%d.%d.%d", |
| mName.c_str(), mLocation.c_str(), mUniqueId.c_str(), |
| driverVersion >> 16, (driverVersion >> 8) & 0xff, (driverVersion >> 16) & 0xff); |
| |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGBIT(EV_KEY, sizeof(mKeyBitmask)), mKeyBitmask)); |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGBIT(EV_ABS, sizeof(mAbsBitmask)), mAbsBitmask)); |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGBIT(EV_REL, sizeof(mRelBitmask)), mRelBitmask)); |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGBIT(EV_SW, sizeof(mSwBitmask)), mSwBitmask)); |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGBIT(EV_LED, sizeof(mLedBitmask)), mLedBitmask)); |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGBIT(EV_FF, sizeof(mFfBitmask)), mFfBitmask)); |
| TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGPROP(sizeof(mPropBitmask)), mPropBitmask)); |
| |
| queryAxisInfo(); |
| |
| return OK; |
| } |
| |
| void EvdevDeviceNode::queryAxisInfo() { |
| for (int32_t axis = 0; axis < ABS_MAX; ++axis) { |
| if (testBit(axis, mAbsBitmask)) { |
| struct input_absinfo info; |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGABS(axis), &info))) { |
| ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", |
| axis, mPath.c_str(), mFd, errno); |
| continue; |
| } |
| |
| mAbsInfo[axis] = std::unique_ptr<AbsoluteAxisInfo>(new AbsoluteAxisInfo{ |
| .minValue = info.minimum, |
| .maxValue = info.maximum, |
| .flat = info.flat, |
| .fuzz = info.fuzz, |
| .resolution = info.resolution |
| }); |
| } |
| } |
| } |
| |
| bool EvdevDeviceNode::hasKey(int32_t key) const { |
| if (key >= 0 && key <= KEY_MAX) { |
| return testBit(key, mKeyBitmask); |
| } |
| return false; |
| } |
| |
| bool EvdevDeviceNode::hasKeyInRange(int32_t startKey, int32_t endKey) const { |
| return testBitInRange(mKeyBitmask, startKey, endKey); |
| } |
| |
| bool EvdevDeviceNode::hasRelativeAxis(int axis) const { |
| if (axis >= 0 && axis <= REL_MAX) { |
| return testBit(axis, mRelBitmask); |
| } |
| return false; |
| } |
| |
| bool EvdevDeviceNode::hasAbsoluteAxis(int axis) const { |
| if (axis >= 0 && axis <= ABS_MAX) { |
| return getAbsoluteAxisInfo(axis) != nullptr; |
| } |
| return false; |
| } |
| |
| const AbsoluteAxisInfo* EvdevDeviceNode::getAbsoluteAxisInfo(int32_t axis) const { |
| if (axis < 0 || axis > ABS_MAX) { |
| return nullptr; |
| } |
| |
| const auto absInfo = mAbsInfo.find(axis); |
| if (absInfo != mAbsInfo.end()) { |
| return absInfo->second.get(); |
| } |
| return nullptr; |
| } |
| |
| bool EvdevDeviceNode::hasSwitch(int32_t sw) const { |
| if (sw >= 0 && sw <= SW_MAX) { |
| return testBit(sw, mSwBitmask); |
| } |
| return false; |
| } |
| |
| bool EvdevDeviceNode::hasForceFeedback(int32_t ff) const { |
| if (ff >= 0 && ff <= FF_MAX) { |
| return testBit(ff, mFfBitmask); |
| } |
| return false; |
| } |
| |
| bool EvdevDeviceNode::hasInputProperty(int property) const { |
| if (property >= 0 && property <= INPUT_PROP_MAX) { |
| return testBit(property, mPropBitmask); |
| } |
| return false; |
| } |
| |
| int32_t EvdevDeviceNode::getKeyState(int32_t key) const { |
| if (key >= 0 && key <= KEY_MAX) { |
| if (testBit(key, mKeyBitmask)) { |
| uint8_t keyState[sizeofBitArray(KEY_CNT)]; |
| memset(keyState, 0, sizeof(keyState)); |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGKEY(sizeof(keyState)), keyState)) >= 0) { |
| return testBit(key, keyState) ? AKEY_STATE_DOWN : AKEY_STATE_UP; |
| } |
| } |
| } |
| return AKEY_STATE_UNKNOWN; |
| } |
| |
| int32_t EvdevDeviceNode::getSwitchState(int32_t sw) const { |
| if (sw >= 0 && sw <= SW_MAX) { |
| if (testBit(sw, mSwBitmask)) { |
| uint8_t swState[sizeofBitArray(SW_CNT)]; |
| memset(swState, 0, sizeof(swState)); |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGSW(sizeof(swState)), swState)) >= 0) { |
| return testBit(sw, swState) ? AKEY_STATE_DOWN : AKEY_STATE_UP; |
| } |
| } |
| } |
| return AKEY_STATE_UNKNOWN; |
| } |
| |
| status_t EvdevDeviceNode::getAbsoluteAxisValue(int32_t axis, int32_t* outValue) const { |
| *outValue = 0; |
| |
| if (axis >= 0 && axis <= ABS_MAX) { |
| if (testBit(axis, mAbsBitmask)) { |
| struct input_absinfo info; |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCGABS(axis), &info))) { |
| ALOGW("Error reading absolute controller %d for device %s fd %d, errno=%d", |
| axis, mPath.c_str(), mFd, errno); |
| return -errno; |
| } |
| |
| *outValue = info.value; |
| return OK; |
| } |
| } |
| return -1; |
| } |
| |
| void EvdevDeviceNode::vibrate(nsecs_t duration) { |
| ff_effect effect{}; |
| effect.type = FF_RUMBLE; |
| effect.id = mFfEffectId; |
| effect.u.rumble.strong_magnitude = 0xc000; |
| effect.u.rumble.weak_magnitude = 0xc000; |
| effect.replay.length = (duration + 999'999LL) / 1'000'000LL; |
| effect.replay.delay = 0; |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCSFF, &effect))) { |
| ALOGW("Could not upload force feedback effect to device %s due to error %d.", |
| mPath.c_str(), errno); |
| return; |
| } |
| mFfEffectId = effect.id; |
| |
| struct input_event ev{}; |
| ev.type = EV_FF; |
| ev.code = mFfEffectId; |
| ev.value = 1; |
| size_t written = TEMP_FAILURE_RETRY(write(mFd, &ev, sizeof(ev))); |
| if (written != sizeof(ev)) { |
| ALOGW("Could not start force feedback effect on device %s due to error %d.", |
| mPath.c_str(), errno); |
| return; |
| } |
| mFfEffectPlaying = true; |
| } |
| |
| void EvdevDeviceNode::cancelVibrate() { |
| if (mFfEffectPlaying) { |
| mFfEffectPlaying = false; |
| |
| struct input_event ev{}; |
| ev.type = EV_FF; |
| ev.code = mFfEffectId; |
| ev.value = 0; |
| size_t written = TEMP_FAILURE_RETRY(write(mFd, &ev, sizeof(ev))); |
| if (written != sizeof(ev)) { |
| ALOGW("Could not stop force feedback effect on device %s due to error %d.", |
| mPath.c_str(), errno); |
| return; |
| } |
| } |
| } |
| |
| void EvdevDeviceNode::disableDriverKeyRepeat() { |
| unsigned int repeatRate[] = {0, 0}; |
| if (TEMP_FAILURE_RETRY(ioctl(mFd, EVIOCSREP, repeatRate))) { |
| ALOGW("Unable to disable kernel key repeat for %s due to error %d.", |
| mPath.c_str(), errno); |
| } |
| } |
| |
| InputHub::InputHub(const std::shared_ptr<InputCallbackInterface>& cb) : |
| mInputCallback(cb) { |
| // Determine the type of suspend blocking we can do on this device. There |
| // are 3 options, in decreasing order of preference: |
| // 1) EPOLLWAKEUP: introduced in Linux kernel 3.5, this flag can be set on |
| // an epoll event to indicate that a wake lock should be held from the |
| // time an fd has data until the next epoll_wait (or the epoll fd is |
| // closed). |
| // 2) EVIOCSSUSPENDBLOCK: introduced into the Android kernel's evdev |
| // driver, this ioctl blocks suspend while the event queue for the fd is |
| // not empty. This was never accepted into the mainline kernel, and it was |
| // replaced by EPOLLWAKEUP. |
| // 3) explicit wake locks: use acquire_wake_lock to manage suspend |
| // blocking explicitly in the InputHub code. |
| // |
| // (1) can be checked by simply observing the Linux kernel version. (2) |
| // requires an fd from an evdev node, which cannot be done in the InputHub |
| // constructor. So we assume (3) unless (1) is true, and we can verify |
| // whether (2) is true once we have an evdev fd (and we're not in (1)). |
| int major, minor; |
| getLinuxRelease(&major, &minor); |
| if (major > 3 || (major == 3 && minor >= 5)) { |
| ALOGI("Using EPOLLWAKEUP to block suspend while processing input events."); |
| mWakeupMechanism = WakeMechanism::EPOLL_WAKEUP; |
| mNeedToCheckSuspendBlockIoctl = false; |
| } |
| if (manageWakeLocks()) { |
| acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID); |
| } |
| |
| // epoll_create argument is ignored, but it must be > 0. |
| mEpollFd = epoll_create(1); |
| LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance. errno=%d", errno); |
| |
| mINotifyFd = inotify_init(); |
| LOG_ALWAYS_FATAL_IF(mINotifyFd < 0, "Could not create inotify instance. errno=%d", errno); |
| |
| struct epoll_event eventItem; |
| memset(&eventItem, 0, sizeof(eventItem)); |
| eventItem.events = EPOLLIN; |
| if (mWakeupMechanism == WakeMechanism::EPOLL_WAKEUP) { |
| eventItem.events |= EPOLLWAKEUP; |
| } |
| eventItem.data.u32 = mINotifyFd; |
| int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mINotifyFd, &eventItem); |
| LOG_ALWAYS_FATAL_IF(result != 0, "Could not add INotify to epoll instance. errno=%d", errno); |
| |
| int wakeFds[2]; |
| result = pipe(wakeFds); |
| LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe. errno=%d", errno); |
| |
| mWakeEventFd = eventfd(0, EFD_NONBLOCK); |
| LOG_ALWAYS_FATAL_IF(mWakeEventFd == -1, "Could not create wake event fd. errno=%d", errno); |
| |
| eventItem.data.u32 = mWakeEventFd; |
| result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, &eventItem); |
| LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake event fd to epoll instance. errno=%d", errno); |
| } |
| |
| InputHub::~InputHub() { |
| ::close(mEpollFd); |
| ::close(mINotifyFd); |
| ::close(mWakeEventFd); |
| |
| if (manageWakeLocks()) { |
| release_wake_lock(WAKE_LOCK_ID); |
| } |
| } |
| |
| status_t InputHub::registerDevicePath(const std::string& path) { |
| ALOGV("registering device path %s", path.c_str()); |
| int wd = inotify_add_watch(mINotifyFd, path.c_str(), IN_DELETE | IN_CREATE); |
| if (wd < 0) { |
| ALOGE("Could not add %s to INotify watch. errno=%d", path.c_str(), errno); |
| return -errno; |
| } |
| mWatchedPaths[wd] = path; |
| scanDir(path); |
| return OK; |
| } |
| |
| status_t InputHub::unregisterDevicePath(const std::string& path) { |
| int wd = -1; |
| for (auto pair : mWatchedPaths) { |
| if (pair.second == path) { |
| wd = pair.first; |
| break; |
| } |
| } |
| |
| if (wd == -1) { |
| return BAD_VALUE; |
| } |
| mWatchedPaths.erase(wd); |
| if (inotify_rm_watch(mINotifyFd, wd) != 0) { |
| return -errno; |
| } |
| return OK; |
| } |
| |
| status_t InputHub::poll() { |
| bool deviceChange = false; |
| |
| if (manageWakeLocks()) { |
| // Mind the wake lock dance! |
| // If we're relying on wake locks, we hold a wake lock at all times |
| // except during epoll_wait(). This works due to some subtle |
| // choreography. When a device driver has pending (unread) events, it |
| // acquires a kernel wake lock. However, once the last pending event |
| // has been read, the device driver will release the kernel wake lock. |
| // To prevent the system from going to sleep when this happens, the |
| // InputHub holds onto its own user wake lock while the client is |
| // processing events. Thus the system can only sleep if there are no |
| // events pending or currently being processed. |
| release_wake_lock(WAKE_LOCK_ID); |
| } |
| |
| struct epoll_event pendingEventItems[EPOLL_MAX_EVENTS]; |
| int pollResult = epoll_wait(mEpollFd, pendingEventItems, EPOLL_MAX_EVENTS, NO_TIMEOUT); |
| |
| if (manageWakeLocks()) { |
| acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_ID); |
| } |
| |
| if (pollResult == 0) { |
| ALOGW("epoll_wait should not return 0 with no timeout"); |
| return UNKNOWN_ERROR; |
| } |
| if (pollResult < 0) { |
| // An error occurred. Return even if it's EINTR, and let the caller |
| // restart the poll. |
| ALOGE("epoll_wait returned with errno=%d", errno); |
| return -errno; |
| } |
| |
| // pollResult > 0: there are events to process |
| nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC); |
| std::vector<int> removedDeviceFds; |
| int inputFd = -1; |
| std::shared_ptr<InputDeviceNode> deviceNode; |
| for (int i = 0; i < pollResult; ++i) { |
| const struct epoll_event& eventItem = pendingEventItems[i]; |
| |
| int dataFd = static_cast<int>(eventItem.data.u32); |
| if (dataFd == mINotifyFd) { |
| if (eventItem.events & EPOLLIN) { |
| deviceChange = true; |
| } else { |
| ALOGW("Received unexpected epoll event 0x%08x for INotify.", eventItem.events); |
| } |
| continue; |
| } |
| |
| if (dataFd == mWakeEventFd) { |
| if (eventItem.events & EPOLLIN) { |
| ALOGV("awoken after wake()"); |
| uint64_t u; |
| ssize_t nRead = TEMP_FAILURE_RETRY(read(mWakeEventFd, &u, sizeof(uint64_t))); |
| if (nRead != sizeof(uint64_t)) { |
| ALOGW("Could not read event fd; waking anyway."); |
| } |
| } else { |
| ALOGW("Received unexpected epoll event 0x%08x for wake event.", |
| eventItem.events); |
| } |
| continue; |
| } |
| |
| // Update the fd and device node when the fd changes. When several |
| // events are read back-to-back with the same fd, this saves many reads |
| // from the hash table. |
| if (inputFd != dataFd) { |
| inputFd = dataFd; |
| deviceNode = mDeviceNodes[inputFd]; |
| } |
| if (deviceNode == nullptr) { |
| ALOGE("could not find device node for fd %d", inputFd); |
| continue; |
| } |
| if (eventItem.events & EPOLLIN) { |
| struct input_event ievs[INPUT_MAX_EVENTS]; |
| for (;;) { |
| ssize_t readSize = TEMP_FAILURE_RETRY(read(inputFd, ievs, sizeof(ievs))); |
| if (readSize == 0 || (readSize < 0 && errno == ENODEV)) { |
| ALOGW("could not get event, removed? (fd: %d, size: %zd errno: %d)", |
| inputFd, readSize, errno); |
| |
| removedDeviceFds.push_back(inputFd); |
| break; |
| } else if (readSize < 0) { |
| if (errno != EAGAIN && errno != EINTR) { |
| ALOGW("could not get event. errno=%d", errno); |
| } |
| break; |
| } else if (readSize % sizeof(input_event) != 0) { |
| ALOGE("could not get event. wrong size=%zd", readSize); |
| break; |
| } else { |
| size_t count = static_cast<size_t>(readSize) / sizeof(struct input_event); |
| for (size_t i = 0; i < count; ++i) { |
| auto& iev = ievs[i]; |
| auto when = s2ns(iev.time.tv_sec) + us2ns(iev.time.tv_usec); |
| InputEvent inputEvent = { when, iev.type, iev.code, iev.value }; |
| mInputCallback->onInputEvent(deviceNode, inputEvent, now); |
| } |
| } |
| } |
| } else if (eventItem.events & EPOLLHUP) { |
| ALOGI("Removing device fd %d due to epoll hangup event.", inputFd); |
| removedDeviceFds.push_back(inputFd); |
| } else { |
| ALOGW("Received unexpected epoll event 0x%08x for device fd %d", |
| eventItem.events, inputFd); |
| } |
| } |
| |
| if (removedDeviceFds.size()) { |
| for (auto deviceFd : removedDeviceFds) { |
| auto deviceNode = mDeviceNodes[deviceFd]; |
| if (deviceNode != nullptr) { |
| status_t ret = closeNodeByFd(deviceFd); |
| if (ret != OK) { |
| ALOGW("Could not close device with fd %d. errno=%d", deviceFd, ret); |
| } else { |
| mInputCallback->onDeviceRemoved(deviceNode); |
| } |
| } |
| } |
| } |
| |
| if (deviceChange) { |
| readNotify(); |
| } |
| |
| return OK; |
| } |
| |
| status_t InputHub::wake() { |
| ALOGV("wake() called"); |
| |
| uint64_t u = 1; |
| ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &u, sizeof(uint64_t))); |
| |
| if (nWrite != sizeof(uint64_t) && errno != EAGAIN) { |
| ALOGW("Could not write wake signal, errno=%d", errno); |
| return -errno; |
| } |
| return OK; |
| } |
| |
| void InputHub::dump(String8& dump) { |
| // TODO |
| } |
| |
| status_t InputHub::readNotify() { |
| char event_buf[512]; |
| struct inotify_event* event; |
| |
| ssize_t res = TEMP_FAILURE_RETRY(read(mINotifyFd, event_buf, sizeof(event_buf))); |
| if (res < static_cast<int>(sizeof(*event))) { |
| ALOGW("could not get inotify event, %s\n", strerror(errno)); |
| return -errno; |
| } |
| |
| size_t event_pos = 0; |
| while (res >= static_cast<int>(sizeof(*event))) { |
| event = reinterpret_cast<struct inotify_event*>(event_buf + event_pos); |
| if (event->len) { |
| std::string path = mWatchedPaths[event->wd]; |
| path.append("/").append(event->name); |
| ALOGV("inotify event for path %s", path.c_str()); |
| |
| if (event->mask & IN_CREATE) { |
| auto deviceNode = openNode(path); |
| if (deviceNode == nullptr) { |
| ALOGE("could not open device node %s. err=%zd", path.c_str(), res); |
| } else { |
| mInputCallback->onDeviceAdded(deviceNode); |
| } |
| } else { |
| auto deviceNode = findNodeByPath(path); |
| if (deviceNode != nullptr) { |
| status_t ret = closeNode(deviceNode.get()); |
| if (ret != OK) { |
| ALOGW("Could not close device %s. errno=%d", path.c_str(), ret); |
| } else { |
| mInputCallback->onDeviceRemoved(deviceNode); |
| } |
| } else { |
| ALOGW("could not find device node for %s", path.c_str()); |
| } |
| } |
| } |
| int event_size = sizeof(*event) + event->len; |
| res -= event_size; |
| event_pos += event_size; |
| } |
| |
| return OK; |
| } |
| |
| status_t InputHub::scanDir(const std::string& path) { |
| auto dir = ::opendir(path.c_str()); |
| if (dir == nullptr) { |
| ALOGE("could not open device path %s to scan for devices. err=%d", path.c_str(), errno); |
| return -errno; |
| } |
| |
| while (auto dirent = readdir(dir)) { |
| if (strcmp(dirent->d_name, ".") == 0 || |
| strcmp(dirent->d_name, "..") == 0) { |
| continue; |
| } |
| std::string filename = path + "/" + dirent->d_name; |
| auto node = openNode(filename); |
| if (node == nullptr) { |
| ALOGE("could not open device node %s", filename.c_str()); |
| } else { |
| mInputCallback->onDeviceAdded(node); |
| } |
| } |
| ::closedir(dir); |
| return OK; |
| } |
| |
| std::shared_ptr<InputDeviceNode> InputHub::openNode(const std::string& path) { |
| ALOGV("opening %s...", path.c_str()); |
| auto evdevNode = std::shared_ptr<EvdevDeviceNode>(EvdevDeviceNode::openDeviceNode(path)); |
| if (evdevNode == nullptr) { |
| return nullptr; |
| } |
| |
| auto fd = evdevNode->getFd(); |
| ALOGV("opened %s with fd %d", path.c_str(), fd); |
| mDeviceNodes[fd] = evdevNode; |
| struct epoll_event eventItem{}; |
| eventItem.events = EPOLLIN; |
| if (mWakeupMechanism == WakeMechanism::EPOLL_WAKEUP) { |
| eventItem.events |= EPOLLWAKEUP; |
| } |
| eventItem.data.u32 = fd; |
| if (epoll_ctl(mEpollFd, EPOLL_CTL_ADD, fd, &eventItem)) { |
| ALOGE("Could not add device fd to epoll instance. errno=%d", errno); |
| return nullptr; |
| } |
| |
| if (mNeedToCheckSuspendBlockIoctl) { |
| #ifndef EVIOCSSUSPENDBLOCK |
| // uapi headers don't include EVIOCSSUSPENDBLOCK, and future kernels |
| // will use an epoll flag instead, so as long as we want to support this |
| // feature, we need to be prepared to define the ioctl ourselves. |
| #define EVIOCSSUSPENDBLOCK _IOW('E', 0x91, int) |
| #endif |
| if (TEMP_FAILURE_RETRY(ioctl(fd, EVIOCSSUSPENDBLOCK, 1))) { |
| // no wake mechanism, continue using explicit wake locks |
| ALOGI("Using explicit wakelocks to block suspend while processing input events."); |
| } else { |
| mWakeupMechanism = WakeMechanism::LEGACY_EVDEV_SUSPENDBLOCK_IOCTL; |
| // release any held wakelocks since we won't need them anymore |
| release_wake_lock(WAKE_LOCK_ID); |
| ALOGI("Using EVIOCSSUSPENDBLOCK to block suspend while processing input events."); |
| } |
| mNeedToCheckSuspendBlockIoctl = false; |
| } |
| |
| return evdevNode; |
| } |
| |
| status_t InputHub::closeNode(const InputDeviceNode* node) { |
| for (auto pair : mDeviceNodes) { |
| if (pair.second.get() == node) { |
| return closeNodeByFd(pair.first); |
| } |
| } |
| return BAD_VALUE; |
| } |
| |
| status_t InputHub::closeNodeByFd(int fd) { |
| status_t ret = OK; |
| if (epoll_ctl(mEpollFd, EPOLL_CTL_DEL, fd, NULL)) { |
| ALOGW("Could not remove device fd from epoll instance. errno=%d", errno); |
| ret = -errno; |
| } |
| mDeviceNodes.erase(fd); |
| ::close(fd); |
| return ret; |
| } |
| |
| std::shared_ptr<InputDeviceNode> InputHub::findNodeByPath(const std::string& path) { |
| for (auto pair : mDeviceNodes) { |
| if (pair.second->getPath() == path) return pair.second; |
| } |
| return nullptr; |
| } |
| |
| bool InputHub::manageWakeLocks() const { |
| return mWakeupMechanism != WakeMechanism::EPOLL_WAKEUP; |
| } |
| |
| } // namespace android |
