blob: 47e20dbf758cb43c5b2b2c86a0786620d46c7735 [file] [log] [blame]
/*
* 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