| /* |
| * Copyright (C) 2019 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. |
| */ |
| |
| #ifndef _UI_INPUT_CLASSIFIER_H |
| #define _UI_INPUT_CLASSIFIER_H |
| |
| #include <android-base/thread_annotations.h> |
| #include <utils/RefBase.h> |
| #include <unordered_map> |
| #include <thread> |
| |
| #include "BlockingQueue.h" |
| #include "InputListener.h" |
| #include <android/hardware/input/classifier/1.0/IInputClassifier.h> |
| |
| namespace android { |
| |
| enum class ClassifierEventType : uint8_t { |
| MOTION = 0, |
| DEVICE_RESET = 1, |
| HAL_RESET = 2, |
| EXIT = 3, |
| }; |
| |
| struct ClassifierEvent { |
| ClassifierEventType type; |
| std::unique_ptr<NotifyArgs> args; |
| |
| ClassifierEvent(ClassifierEventType type, std::unique_ptr<NotifyArgs> args); |
| ClassifierEvent(std::unique_ptr<NotifyMotionArgs> args); |
| ClassifierEvent(std::unique_ptr<NotifyDeviceResetArgs> args); |
| ClassifierEvent(ClassifierEvent&& other); |
| ClassifierEvent& operator=(ClassifierEvent&& other); |
| |
| // Convenience function to create a HAL_RESET event |
| static ClassifierEvent createHalResetEvent(); |
| // Convenience function to create an EXIT event |
| static ClassifierEvent createExitEvent(); |
| |
| std::optional<int32_t> getDeviceId() const; |
| }; |
| |
| // --- Interfaces --- |
| |
| /** |
| * Interface for adding a MotionClassification to NotifyMotionArgs. |
| * |
| * To implement, override the classify function. |
| */ |
| class MotionClassifierInterface { |
| public: |
| MotionClassifierInterface() { } |
| virtual ~MotionClassifierInterface() { } |
| /** |
| * Based on the motion event described by NotifyMotionArgs, |
| * provide a MotionClassification for the current gesture. |
| */ |
| virtual MotionClassification classify(const NotifyMotionArgs& args) = 0; |
| /** |
| * Reset all internal HAL state. |
| */ |
| virtual void reset() = 0; |
| /** |
| * Reset HAL state for a specific device. |
| */ |
| virtual void reset(const NotifyDeviceResetArgs& args) = 0; |
| |
| /** |
| * Dump the state of the motion classifier |
| */ |
| virtual void dump(std::string& dump) = 0; |
| }; |
| |
| /** |
| * Base interface for an InputListener stage. |
| * Provides classification to events. |
| */ |
| class InputClassifierInterface : public virtual RefBase, public InputListenerInterface { |
| public: |
| /** |
| * Dump the state of the input classifier. |
| * This method may be called on any thread (usually by the input manager). |
| */ |
| virtual void dump(std::string& dump) = 0; |
| protected: |
| InputClassifierInterface() { } |
| virtual ~InputClassifierInterface() { } |
| }; |
| |
| // --- Implementations --- |
| |
| /** |
| * Implementation of MotionClassifierInterface that calls the InputClassifier HAL |
| * in order to determine the classification for the current gesture. |
| * |
| * The InputClassifier HAL may keep track of the entire gesture in order to determine |
| * the classification, and may be hardware-specific. It may use the data in |
| * NotifyMotionArgs::videoFrames field to drive the classification decisions. |
| * The HAL is called from a separate thread. |
| */ |
| class MotionClassifier final : public MotionClassifierInterface { |
| public: |
| /** |
| * The deathRecipient will be subscribed to the HAL death. If the death recipient |
| * owns MotionClassifier and receives HAL death, it should delete its copy of it. |
| * The callback serviceDied will also be sent if the MotionClassifier itself fails |
| * to initialize. If the MotionClassifier fails to initialize, it is not useful, and |
| * should be deleted. |
| * If no death recipient is supplied, then the registration step will be skipped, so there will |
| * be no listeners registered for the HAL death. This is useful for testing |
| * MotionClassifier in isolation. |
| */ |
| explicit MotionClassifier(sp<android::hardware::hidl_death_recipient> deathRecipient = nullptr); |
| ~MotionClassifier(); |
| |
| /** |
| * Classifies events asynchronously; that is, it doesn't block events on a classification, |
| * but instead sends them over to the classifier HAL and after a classification is |
| * determined, it then marks the next event it sees in the stream with it. |
| * |
| * Therefore, it is acceptable to have the classifications be delayed by 1-2 events |
| * in a particular gesture. |
| */ |
| virtual MotionClassification classify(const NotifyMotionArgs& args) override; |
| virtual void reset() override; |
| virtual void reset(const NotifyDeviceResetArgs& args) override; |
| |
| virtual void dump(std::string& dump) override; |
| |
| private: |
| /** |
| * Initialize MotionClassifier. |
| * Return true if initializaion is successful. |
| */ |
| bool init(); |
| /** |
| * Entity that will be notified of the HAL death (most likely InputClassifier). |
| */ |
| wp<android::hardware::hidl_death_recipient> mDeathRecipient; |
| |
| // The events that need to be sent to the HAL. |
| BlockingQueue<ClassifierEvent> mEvents; |
| /** |
| * Add an event to the queue mEvents. |
| */ |
| void enqueueEvent(ClassifierEvent&& event); |
| /** |
| * Thread that will communicate with InputClassifier HAL. |
| * This should be the only thread that communicates with InputClassifier HAL, |
| * because this thread is allowed to block on the HAL calls. |
| */ |
| std::thread mHalThread; |
| /** |
| * Print an error message if the caller is not on the InputClassifier thread. |
| * Caller must supply the name of the calling function as __func__ |
| */ |
| void ensureHalThread(const char* function); |
| /** |
| * Call the InputClassifier HAL |
| */ |
| void callInputClassifierHal(); |
| /** |
| * Access to the InputClassifier HAL. May be null if init() hasn't completed yet. |
| * When init() successfully completes, mService is guaranteed to remain non-null and to not |
| * change its value until MotionClassifier is destroyed. |
| * This variable is *not* guarded by mLock in the InputClassifier thread, because |
| * that thread knows exactly when this variable is initialized. |
| * When accessed in any other thread, mService is checked for nullness with a lock. |
| */ |
| sp<android::hardware::input::classifier::V1_0::IInputClassifier> mService; |
| std::mutex mLock; |
| /** |
| * Per-device input classifications. Should only be accessed using the |
| * getClassification / setClassification methods. |
| */ |
| std::unordered_map<int32_t /*deviceId*/, MotionClassification> |
| mClassifications GUARDED_BY(mLock); |
| /** |
| * Set the current classification for a given device. |
| */ |
| void setClassification(int32_t deviceId, MotionClassification classification); |
| /** |
| * Get the current classification for a given device. |
| */ |
| MotionClassification getClassification(int32_t deviceId); |
| void updateClassification(int32_t deviceId, nsecs_t eventTime, |
| MotionClassification classification); |
| /** |
| * Clear all current classifications |
| */ |
| void clearClassifications(); |
| /** |
| * Per-device times when the last ACTION_DOWN was received. |
| * Used to reject late classifications that do not belong to the current gesture. |
| * |
| * Accessed indirectly by both InputClassifier thread and the thread that receives notifyMotion. |
| */ |
| std::unordered_map<int32_t /*deviceId*/, nsecs_t /*downTime*/> mLastDownTimes GUARDED_BY(mLock); |
| |
| void updateLastDownTime(int32_t deviceId, nsecs_t downTime); |
| |
| /** |
| * Exit the InputClassifier HAL thread. |
| * Useful for tests to ensure proper cleanup. |
| */ |
| void requestExit(); |
| /** |
| * Return string status of mService |
| */ |
| const char* getServiceStatus() REQUIRES(mLock); |
| }; |
| |
| |
| /** |
| * Implementation of the InputClassifierInterface. |
| * Represents a separate stage of input processing. All of the input events go through this stage. |
| * Acts as a passthrough for all input events except for motion events. |
| * The events of motion type are sent to MotionClassifier. |
| */ |
| class InputClassifier : public InputClassifierInterface, |
| public android::hardware::hidl_death_recipient { |
| public: |
| explicit InputClassifier(const sp<InputListenerInterface>& listener); |
| // Some of the constructor logic is finished in onFirstRef |
| virtual void onFirstRef() override; |
| |
| virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override; |
| virtual void notifyKey(const NotifyKeyArgs* args) override; |
| virtual void notifyMotion(const NotifyMotionArgs* args) override; |
| virtual void notifySwitch(const NotifySwitchArgs* args) override; |
| virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) override; |
| |
| virtual void serviceDied(uint64_t cookie, |
| const wp<android::hidl::base::V1_0::IBase>& who) override; |
| |
| virtual void dump(std::string& dump) override; |
| |
| private: |
| // Protect access to mMotionClassifier, since it may become null via a hidl callback |
| std::mutex mLock; |
| std::unique_ptr<MotionClassifierInterface> mMotionClassifier GUARDED_BY(mLock); |
| // The next stage to pass input events to |
| sp<InputListenerInterface> mListener; |
| }; |
| |
| } // namespace android |
| #endif |