Use InputProcessor instead of InputClassifier
Convert InputClassifier to aidl and use it inside framework's
InputClassifier.
Bug: 167946763
Test: verified on the actual device
Change-Id: I62520d424a42bead59904d5a9accea5325b9e8cb
diff --git a/services/inputflinger/Android.bp b/services/inputflinger/Android.bp
index 22a69e5..5d4225d 100644
--- a/services/inputflinger/Android.bp
+++ b/services/inputflinger/Android.bp
@@ -48,7 +48,7 @@
name: "libinputflinger_sources",
srcs: [
"InputClassifier.cpp",
- "InputClassifierConverter.cpp",
+ "InputCommonConverter.cpp",
"UnwantedInteractionBlocker.cpp",
"InputManager.cpp",
],
@@ -58,9 +58,10 @@
name: "libinputflinger_defaults",
srcs: [":libinputflinger_sources"],
shared_libs: [
- "android.hardware.input.classifier@1.0",
+ "android.hardware.input.processor-V1-ndk",
"libbase",
"libbinder",
+ "libbinder_ndk",
"libchrome",
"libcrypto",
"libcutils",
diff --git a/services/inputflinger/InputClassifier.cpp b/services/inputflinger/InputClassifier.cpp
index 6c4b11e..3ea0986 100644
--- a/services/inputflinger/InputClassifier.cpp
+++ b/services/inputflinger/InputClassifier.cpp
@@ -17,13 +17,15 @@
#define LOG_TAG "InputClassifier"
#include "InputClassifier.h"
-#include "InputClassifierConverter.h"
+#include "InputCommonConverter.h"
-#include <algorithm>
#include <android-base/stringprintf.h>
-#include <cmath>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
#include <inttypes.h>
#include <log/log.h>
+#include <algorithm>
+#include <cmath>
#if defined(__linux__)
#include <pthread.h>
#endif
@@ -36,10 +38,9 @@
#define INDENT5 " "
using android::base::StringPrintf;
-using android::hardware::hidl_bitfield;
-using android::hardware::hidl_vec;
-using android::hardware::Return;
-using namespace android::hardware::input;
+using namespace std::chrono_literals;
+using namespace ::aidl::android::hardware::input;
+using aidl::android::hardware::input::processor::IInputProcessor;
namespace android {
@@ -55,13 +56,13 @@
return it->second;
}
-static MotionClassification getMotionClassification(common::V1_0::Classification classification) {
+static MotionClassification getMotionClassification(common::Classification classification) {
static_assert(MotionClassification::NONE ==
- static_cast<MotionClassification>(common::V1_0::Classification::NONE));
+ static_cast<MotionClassification>(common::Classification::NONE));
static_assert(MotionClassification::AMBIGUOUS_GESTURE ==
- static_cast<MotionClassification>(common::V1_0::Classification::AMBIGUOUS_GESTURE));
+ static_cast<MotionClassification>(common::Classification::AMBIGUOUS_GESTURE));
static_assert(MotionClassification::DEEP_PRESS ==
- static_cast<MotionClassification>(common::V1_0::Classification::DEEP_PRESS));
+ static_cast<MotionClassification>(common::Classification::DEEP_PRESS));
return static_cast<MotionClassification>(classification);
}
@@ -70,6 +71,56 @@
isFromSource(args.source, AINPUT_SOURCE_TOUCHSCREEN);
}
+static void setCurrentThreadName(const char* name) {
+#if defined(__linux__)
+ // Set the thread name for debugging
+ pthread_setname_np(pthread_self(), name);
+#else
+ (void*)(name); // prevent unused variable warning
+#endif
+}
+
+static std::shared_ptr<IInputProcessor> getService() {
+ const std::string aidl_instance_name = std::string(IInputProcessor::descriptor) + "/default";
+
+ if (!AServiceManager_isDeclared(aidl_instance_name.c_str())) {
+ ALOGI("HAL %s is not declared", aidl_instance_name.c_str());
+ return nullptr;
+ }
+
+ ndk::SpAIBinder binder(AServiceManager_waitForService(aidl_instance_name.c_str()));
+ return IInputProcessor::fromBinder(binder);
+}
+
+// Temporarily releases a held mutex for the lifetime of the instance.
+// Named to match std::scoped_lock
+class scoped_unlock {
+public:
+ explicit scoped_unlock(std::mutex& mutex) : mMutex(mutex) { mMutex.unlock(); }
+ ~scoped_unlock() { mMutex.lock(); }
+
+private:
+ std::mutex& mMutex;
+};
+
+// --- ScopedDeathRecipient ---
+ScopedDeathRecipient::ScopedDeathRecipient(AIBinder_DeathRecipient_onBinderDied onBinderDied,
+ void* cookie)
+ : mCookie(cookie) {
+ mRecipient = AIBinder_DeathRecipient_new(onBinderDied);
+}
+
+void ScopedDeathRecipient::linkToDeath(AIBinder* binder) {
+ binder_status_t linked = AIBinder_linkToDeath(binder, mRecipient, mCookie);
+ if (linked != STATUS_OK) {
+ ALOGE("Could not link death recipient to the HAL death");
+ }
+}
+
+ScopedDeathRecipient::~ScopedDeathRecipient() {
+ AIBinder_DeathRecipient_delete(mRecipient);
+}
+
// --- ClassifierEvent ---
ClassifierEvent::ClassifierEvent(std::unique_ptr<NotifyMotionArgs> args) :
@@ -118,9 +169,8 @@
// --- MotionClassifier ---
-MotionClassifier::MotionClassifier(
- sp<android::hardware::input::classifier::V1_0::IInputClassifier> service)
- : mEvents(MAX_EVENTS), mService(service) {
+MotionClassifier::MotionClassifier(std::shared_ptr<IInputProcessor> service)
+ : mEvents(MAX_EVENTS), mService(std::move(service)) {
// Under normal operation, we do not need to reset the HAL here. But in the case where system
// crashed, but HAL didn't, we may be connecting to an existing HAL process that might already
// have received events in the past. That means, that HAL could be in an inconsistent state
@@ -135,23 +185,10 @@
}
std::unique_ptr<MotionClassifierInterface> MotionClassifier::create(
- sp<android::hardware::hidl_death_recipient> deathRecipient) {
- sp<android::hardware::input::classifier::V1_0::IInputClassifier> service =
- classifier::V1_0::IInputClassifier::getService();
- if (!service) {
- // Not really an error, maybe the device does not have this HAL,
- // but somehow the feature flag is flipped
- ALOGI("Could not obtain InputClassifier HAL");
- return nullptr;
- }
-
- const bool linked = service->linkToDeath(deathRecipient, 0 /* cookie */).withDefault(false);
- if (!linked) {
- ALOGE("Could not link death recipient to the HAL death");
- return nullptr;
- }
+ std::shared_ptr<IInputProcessor> service) {
+ LOG_ALWAYS_FATAL_IF(service == nullptr);
// Using 'new' to access a non-public constructor
- return std::unique_ptr<MotionClassifier>(new MotionClassifier(service));
+ return std::unique_ptr<MotionClassifier>(new MotionClassifier(std::move(service)));
}
MotionClassifier::~MotionClassifier() {
@@ -176,14 +213,12 @@
switch (event.type) {
case ClassifierEventType::MOTION: {
NotifyMotionArgs* motionArgs = static_cast<NotifyMotionArgs*>(event.args.get());
- common::V1_0::MotionEvent motionEvent =
- notifyMotionArgsToHalMotionEvent(*motionArgs);
- Return<common::V1_0::Classification> response = mService->classify(motionEvent);
- halResponseOk = response.isOk();
- if (halResponseOk) {
- common::V1_0::Classification halClassification = response;
+ common::MotionEvent motionEvent = notifyMotionArgsToHalMotionEvent(*motionArgs);
+ common::Classification classification;
+ ndk::ScopedAStatus response = mService->classify(motionEvent, &classification);
+ if (response.isOk()) {
updateClassification(motionArgs->deviceId, motionArgs->eventTime,
- getMotionClassification(halClassification));
+ getMotionClassification(classification));
}
break;
}
@@ -300,7 +335,8 @@
if (!mService) {
return "null";
}
- if (mService->ping().isOk()) {
+
+ if (AIBinder_ping(mService->asBinder().get()) == STATUS_OK) {
return "running";
}
return "not responding";
@@ -329,40 +365,53 @@
}
}
-// --- HalDeathRecipient
-
-InputClassifier::HalDeathRecipient::HalDeathRecipient(InputClassifier& parent) : mParent(parent) {}
-
-void InputClassifier::HalDeathRecipient::serviceDied(
- uint64_t cookie, const wp<android::hidl::base::V1_0::IBase>& who) {
- sp<android::hidl::base::V1_0::IBase> service = who.promote();
- if (service) {
- service->unlinkToDeath(this);
- }
- mParent.setMotionClassifier(nullptr);
-}
-
// --- InputClassifier ---
-InputClassifier::InputClassifier(InputListenerInterface& listener)
- : mListener(listener), mHalDeathRecipient(new HalDeathRecipient(*this)) {}
+InputClassifier::InputClassifier(InputListenerInterface& listener) : mListener(listener) {}
+
+void InputClassifier::onBinderDied(void* cookie) {
+ InputClassifier* classifier = static_cast<InputClassifier*>(cookie);
+ if (classifier == nullptr) {
+ LOG_ALWAYS_FATAL("Cookie is not valid");
+ return;
+ }
+ classifier->setMotionClassifierEnabled(false);
+}
void InputClassifier::setMotionClassifierEnabled(bool enabled) {
+ std::scoped_lock lock(mLock);
if (enabled) {
ALOGI("Enabling motion classifier");
- if (mInitializeMotionClassifierThread.joinable()) {
- mInitializeMotionClassifierThread.join();
+ if (mInitializeMotionClassifier.valid()) {
+ scoped_unlock unlock(mLock);
+ std::future_status status = mInitializeMotionClassifier.wait_for(5s);
+ if (status != std::future_status::ready) {
+ /**
+ * We don't have a better option here than to crash. We can't stop the thread,
+ * and we can't continue because 'mInitializeMotionClassifier' will block in its
+ * destructor.
+ */
+ LOG_ALWAYS_FATAL("The thread to load IInputClassifier is stuck!");
+ }
}
- mInitializeMotionClassifierThread = std::thread(
- [this] { setMotionClassifier(MotionClassifier::create(mHalDeathRecipient)); });
-#if defined(__linux__)
- // Set the thread name for debugging
- pthread_setname_np(mInitializeMotionClassifierThread.native_handle(),
- "Create MotionClassifier");
-#endif
+ mInitializeMotionClassifier = std::async(std::launch::async, [this] {
+ setCurrentThreadName("Create MotionClassifier");
+ std::shared_ptr<IInputProcessor> service = getService();
+ if (service == nullptr) {
+ // Keep the MotionClassifier null, no service was found
+ return;
+ }
+ { // acquire lock
+ std::scoped_lock threadLock(mLock);
+ mHalDeathRecipient =
+ std::make_unique<ScopedDeathRecipient>(onBinderDied, this /*cookie*/);
+ mHalDeathRecipient->linkToDeath(service->asBinder().get());
+ setMotionClassifierLocked(MotionClassifier::create(std::move(service)));
+ } // release lock
+ });
} else {
ALOGI("Disabling motion classifier");
- setMotionClassifier(nullptr);
+ setMotionClassifierLocked(nullptr);
}
}
@@ -419,9 +468,13 @@
mListener.notifyPointerCaptureChanged(args);
}
-void InputClassifier::setMotionClassifier(
- std::unique_ptr<MotionClassifierInterface> motionClassifier) {
- std::scoped_lock lock(mLock);
+void InputClassifier::setMotionClassifierLocked(
+ std::unique_ptr<MotionClassifierInterface> motionClassifier) REQUIRES(mLock) {
+ if (motionClassifier == nullptr) {
+ // Destroy the ScopedDeathRecipient object, which will cause it to unlinkToDeath.
+ // We can't call 'unlink' here because we don't have the binder handle.
+ mHalDeathRecipient = nullptr;
+ }
mMotionClassifier = std::move(motionClassifier);
}
@@ -438,9 +491,6 @@
}
InputClassifier::~InputClassifier() {
- if (mInitializeMotionClassifierThread.joinable()) {
- mInitializeMotionClassifierThread.join();
- }
}
} // namespace android
diff --git a/services/inputflinger/InputClassifier.h b/services/inputflinger/InputClassifier.h
index deeae7c..e2a0bc2 100644
--- a/services/inputflinger/InputClassifier.h
+++ b/services/inputflinger/InputClassifier.h
@@ -18,13 +18,13 @@
#define _UI_INPUT_CLASSIFIER_H
#include <android-base/thread_annotations.h>
+#include <future>
#include <thread>
#include <unordered_map>
+#include <aidl/android/hardware/input/processor/IInputProcessor.h>
#include "BlockingQueue.h"
#include "InputListener.h"
-#include <android/hardware/input/classifier/1.0/IInputClassifier.h>
-
namespace android {
enum class ClassifierEventType : uint8_t {
@@ -102,6 +102,19 @@
// --- Implementations ---
+class ScopedDeathRecipient {
+public:
+ explicit ScopedDeathRecipient(AIBinder_DeathRecipient_onBinderDied onBinderDied, void* cookie);
+ ScopedDeathRecipient(const ScopedDeathRecipient&) = delete;
+ ScopedDeathRecipient& operator=(ScopedDeathRecipient const&) = delete;
+ void linkToDeath(AIBinder* binder);
+ ~ScopedDeathRecipient();
+
+private:
+ AIBinder_DeathRecipient* mRecipient;
+ void* mCookie;
+};
+
/**
* Implementation of MotionClassifierInterface that calls the InputClassifier HAL
* in order to determine the classification for the current gesture.
@@ -121,7 +134,7 @@
* This function should be called asynchronously, because getService takes a long time.
*/
static std::unique_ptr<MotionClassifierInterface> create(
- sp<android::hardware::hidl_death_recipient> deathRecipient);
+ std::shared_ptr<aidl::android::hardware::input::processor::IInputProcessor> service);
~MotionClassifier();
@@ -143,7 +156,7 @@
private:
friend class MotionClassifierTest; // to create MotionClassifier with a test HAL implementation
explicit MotionClassifier(
- sp<android::hardware::input::classifier::V1_0::IInputClassifier> service);
+ std::shared_ptr<aidl::android::hardware::input::processor::IInputProcessor> service);
// The events that need to be sent to the HAL.
BlockingQueue<ClassifierEvent> mEvents;
@@ -162,14 +175,14 @@
*/
void processEvents();
/**
- * Access to the InputClassifier HAL. May be null if init() hasn't completed yet.
+ * Access to the InputProcessor 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::shared_ptr<aidl::android::hardware::input::processor::IInputProcessor> mService;
std::mutex mLock;
/**
* Per-device input classifications. Should only be accessed using the
@@ -224,21 +237,21 @@
public:
explicit InputClassifier(InputListenerInterface& listener);
- 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 notifySensor(const NotifySensorArgs* args) override;
- virtual void notifyVibratorState(const NotifyVibratorStateArgs* args) override;
- virtual void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
+ void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args) override;
+ void notifyKey(const NotifyKeyArgs* args) override;
+ void notifyMotion(const NotifyMotionArgs* args) override;
+ void notifySwitch(const NotifySwitchArgs* args) override;
+ void notifySensor(const NotifySensorArgs* args) override;
+ void notifyVibratorState(const NotifyVibratorStateArgs* args) override;
+ void notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
- virtual void dump(std::string& dump) override;
+ void dump(std::string& dump) override;
~InputClassifier();
// Called from InputManager
- virtual void setMotionClassifierEnabled(bool enabled) override;
+ void setMotionClassifierEnabled(bool enabled) override;
private:
// Protect access to mMotionClassifier, since it may become null via a hidl callback
@@ -247,7 +260,8 @@
InputListenerInterface& mListener;
std::unique_ptr<MotionClassifierInterface> mMotionClassifier GUARDED_BY(mLock);
- std::thread mInitializeMotionClassifierThread;
+ std::future<void> mInitializeMotionClassifier GUARDED_BY(mLock);
+
/**
* Set the value of mMotionClassifier.
* This is called from 2 different threads:
@@ -255,25 +269,12 @@
* 2) A binder thread of the HalDeathRecipient, which is created when HAL dies. This would cause
* mMotionClassifier to become nullptr.
*/
- void setMotionClassifier(std::unique_ptr<MotionClassifierInterface> motionClassifier);
+ void setMotionClassifierLocked(std::unique_ptr<MotionClassifierInterface> motionClassifier)
+ REQUIRES(mLock);
- /**
- * The deathRecipient will call setMotionClassifier(null) when the HAL dies.
- */
- class HalDeathRecipient : public android::hardware::hidl_death_recipient {
- public:
- explicit HalDeathRecipient(InputClassifier& parent);
- virtual void serviceDied(uint64_t cookie,
- const wp<android::hidl::base::V1_0::IBase>& who) override;
+ static void onBinderDied(void* cookie);
- private:
- InputClassifier& mParent;
- };
- // We retain a reference to death recipient, because the death recipient will be calling
- // ~MotionClassifier if the HAL dies.
- // If we don't retain a reference, and MotionClassifier is the only owner of the death
- // recipient, the serviceDied call will cause death recipient to call its own destructor.
- sp<HalDeathRecipient> mHalDeathRecipient;
+ std::unique_ptr<ScopedDeathRecipient> mHalDeathRecipient GUARDED_BY(mLock);
};
} // namespace android
diff --git a/services/inputflinger/InputClassifierConverter.cpp b/services/inputflinger/InputClassifierConverter.cpp
deleted file mode 100644
index b58a188..0000000
--- a/services/inputflinger/InputClassifierConverter.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-/*
- * 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.
- */
-
-#include "InputClassifierConverter.h"
-
-using android::hardware::hidl_bitfield;
-using namespace android::hardware::input;
-
-namespace android {
-
-static common::V1_0::Source getSource(uint32_t source) {
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_UNKNOWN) ==
- common::V1_0::Source::UNKNOWN, "SOURCE_UNKNOWN mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_KEYBOARD) ==
- common::V1_0::Source::KEYBOARD, "SOURCE_KEYBOARD mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_DPAD) ==
- common::V1_0::Source::DPAD, "SOURCE_DPAD mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_GAMEPAD) ==
- common::V1_0::Source::GAMEPAD, "SOURCE_GAMEPAD mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_TOUCHSCREEN) ==
- common::V1_0::Source::TOUCHSCREEN, "SOURCE_TOUCHSCREEN mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_MOUSE) ==
- common::V1_0::Source::MOUSE, "SOURCE_MOUSE mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_STYLUS) ==
- common::V1_0::Source::STYLUS, "SOURCE_STYLUS mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_BLUETOOTH_STYLUS) ==
- common::V1_0::Source::BLUETOOTH_STYLUS, "SOURCE_BLUETOOTH_STYLUS mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_TRACKBALL) ==
- common::V1_0::Source::TRACKBALL, "SOURCE_TRACKBALL mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_MOUSE_RELATIVE) ==
- common::V1_0::Source::MOUSE_RELATIVE, "SOURCE_MOUSE_RELATIVE mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_TOUCHPAD) ==
- common::V1_0::Source::TOUCHPAD, "SOURCE_TOUCHPAD mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_TOUCH_NAVIGATION) ==
- common::V1_0::Source::TOUCH_NAVIGATION, "SOURCE_TOUCH_NAVIGATION mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_JOYSTICK) ==
- common::V1_0::Source::JOYSTICK, "SOURCE_JOYSTICK mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_ROTARY_ENCODER) ==
- common::V1_0::Source::ROTARY_ENCODER, "SOURCE_ROTARY_ENCODER mismatch");
- static_assert(static_cast<common::V1_0::Source>(AINPUT_SOURCE_ANY) ==
- common::V1_0::Source::ANY, "SOURCE_ANY mismatch");
- return static_cast<common::V1_0::Source>(source);
-}
-
-static common::V1_0::Action getAction(int32_t actionMasked) {
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_DOWN) ==
- common::V1_0::Action::DOWN, "ACTION_DOWN mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_UP) ==
- common::V1_0::Action::UP, "ACTION_UP mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_MOVE) ==
- common::V1_0::Action::MOVE, "ACTION_MOVE mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_CANCEL) ==
- common::V1_0::Action::CANCEL, "ACTION_CANCEL mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_OUTSIDE) ==
- common::V1_0::Action::OUTSIDE, "ACTION_OUTSIDE mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_POINTER_DOWN) ==
- common::V1_0::Action::POINTER_DOWN, "ACTION_POINTER_DOWN mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_POINTER_UP) ==
- common::V1_0::Action::POINTER_UP, "ACTION_POINTER_UP mismatch");
- static_assert(static_cast<common::V1_0::Action>( AMOTION_EVENT_ACTION_HOVER_MOVE) ==
- common::V1_0::Action::HOVER_MOVE, "ACTION_HOVER_MOVE mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_SCROLL) ==
- common::V1_0::Action::SCROLL, "ACTION_SCROLL mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_HOVER_ENTER) ==
- common::V1_0::Action::HOVER_ENTER, "ACTION_HOVER_ENTER mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_HOVER_EXIT) ==
- common::V1_0::Action::HOVER_EXIT, "ACTION_HOVER_EXIT mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_BUTTON_PRESS) ==
- common::V1_0::Action::BUTTON_PRESS, "ACTION_BUTTON_PRESS mismatch");
- static_assert(static_cast<common::V1_0::Action>(AMOTION_EVENT_ACTION_BUTTON_RELEASE) ==
- common::V1_0::Action::BUTTON_RELEASE, "ACTION_BUTTON_RELEASE mismatch");
- return static_cast<common::V1_0::Action>(actionMasked);
-}
-
-static common::V1_0::Button getActionButton(int32_t actionButton) {
- static_assert(static_cast<common::V1_0::Button>(0) ==
- common::V1_0::Button::NONE, "BUTTON_NONE mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_PRIMARY) ==
- common::V1_0::Button::PRIMARY, "BUTTON_PRIMARY mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_SECONDARY) ==
- common::V1_0::Button::SECONDARY, "BUTTON_SECONDARY mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_TERTIARY) ==
- common::V1_0::Button::TERTIARY, "BUTTON_TERTIARY mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_BACK) ==
- common::V1_0::Button::BACK, "BUTTON_BACK mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_FORWARD) ==
- common::V1_0::Button::FORWARD, "BUTTON_FORWARD mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) ==
- common::V1_0::Button::STYLUS_PRIMARY, "BUTTON_STYLUS_PRIMARY mismatch");
- static_assert(static_cast<common::V1_0::Button>(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY) ==
- common::V1_0::Button::STYLUS_SECONDARY, "BUTTON_STYLUS_SECONDARY mismatch");
- return static_cast<common::V1_0::Button>(actionButton);
-}
-
-static hidl_bitfield<common::V1_0::Flag> getFlags(int32_t flags) {
- static_assert(static_cast<common::V1_0::Flag>(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED) ==
- common::V1_0::Flag::WINDOW_IS_OBSCURED);
- static_assert(static_cast<common::V1_0::Flag>(AMOTION_EVENT_FLAG_IS_GENERATED_GESTURE) ==
- common::V1_0::Flag::IS_GENERATED_GESTURE);
- static_assert(static_cast<common::V1_0::Flag>(AMOTION_EVENT_FLAG_TAINTED) ==
- common::V1_0::Flag::TAINTED);
- return static_cast<hidl_bitfield<common::V1_0::Flag>>(flags);
-}
-
-static hidl_bitfield<common::V1_0::PolicyFlag> getPolicyFlags(int32_t flags) {
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_WAKE) ==
- common::V1_0::PolicyFlag::WAKE);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_VIRTUAL) ==
- common::V1_0::PolicyFlag::VIRTUAL);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_FUNCTION) ==
- common::V1_0::PolicyFlag::FUNCTION);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_GESTURE) ==
- common::V1_0::PolicyFlag::GESTURE);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_INJECTED) ==
- common::V1_0::PolicyFlag::INJECTED);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_TRUSTED) ==
- common::V1_0::PolicyFlag::TRUSTED);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_FILTERED) ==
- common::V1_0::PolicyFlag::FILTERED);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_DISABLE_KEY_REPEAT) ==
- common::V1_0::PolicyFlag::DISABLE_KEY_REPEAT);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_INTERACTIVE) ==
- common::V1_0::PolicyFlag::INTERACTIVE);
- static_assert(static_cast<common::V1_0::PolicyFlag>(POLICY_FLAG_PASS_TO_USER) ==
- common::V1_0::PolicyFlag::PASS_TO_USER);
- return static_cast<hidl_bitfield<common::V1_0::PolicyFlag>>(flags);
-}
-
-static hidl_bitfield<common::V1_0::EdgeFlag> getEdgeFlags(int32_t flags) {
- static_assert(static_cast<common::V1_0::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_NONE) ==
- common::V1_0::EdgeFlag::NONE);
- static_assert(static_cast<common::V1_0::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_TOP) ==
- common::V1_0::EdgeFlag::TOP);
- static_assert(static_cast<common::V1_0::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_BOTTOM) ==
- common::V1_0::EdgeFlag::BOTTOM);
- static_assert(static_cast<common::V1_0::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_LEFT) ==
- common::V1_0::EdgeFlag::LEFT);
- static_assert(static_cast<common::V1_0::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_RIGHT) ==
- common::V1_0::EdgeFlag::RIGHT);
- return static_cast<hidl_bitfield<common::V1_0::EdgeFlag>>(flags);
-}
-
-static hidl_bitfield<common::V1_0::Meta> getMetastate(int32_t state) {
- static_assert(static_cast<common::V1_0::Meta>(AMETA_NONE) ==
- common::V1_0::Meta::NONE);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_ALT_ON) ==
- common::V1_0::Meta::ALT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_ALT_LEFT_ON) ==
- common::V1_0::Meta::ALT_LEFT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_ALT_RIGHT_ON) ==
- common::V1_0::Meta::ALT_RIGHT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_SHIFT_ON) ==
- common::V1_0::Meta::SHIFT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_SHIFT_LEFT_ON) ==
- common::V1_0::Meta::SHIFT_LEFT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_SHIFT_RIGHT_ON) ==
- common::V1_0::Meta::SHIFT_RIGHT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_SYM_ON) ==
- common::V1_0::Meta::SYM_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_FUNCTION_ON) ==
- common::V1_0::Meta::FUNCTION_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_CTRL_ON) ==
- common::V1_0::Meta::CTRL_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_CTRL_LEFT_ON) ==
- common::V1_0::Meta::CTRL_LEFT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_CTRL_RIGHT_ON) ==
- common::V1_0::Meta::CTRL_RIGHT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_META_ON) ==
- common::V1_0::Meta::META_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_META_LEFT_ON) ==
- common::V1_0::Meta::META_LEFT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_META_RIGHT_ON) ==
- common::V1_0::Meta::META_RIGHT_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_CAPS_LOCK_ON) ==
- common::V1_0::Meta::CAPS_LOCK_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_NUM_LOCK_ON) ==
- common::V1_0::Meta::NUM_LOCK_ON);
- static_assert(static_cast<common::V1_0::Meta>(AMETA_SCROLL_LOCK_ON) ==
- common::V1_0::Meta::SCROLL_LOCK_ON);
- return static_cast<hidl_bitfield<common::V1_0::Meta>>(state);
-}
-
-static hidl_bitfield<common::V1_0::Button> getButtonState(int32_t buttonState) {
- // No need for static_assert here.
- // The button values have already been asserted in getActionButton(..) above
- return static_cast<hidl_bitfield<common::V1_0::Button>>(buttonState);
-}
-
-static common::V1_0::ToolType getToolType(int32_t toolType) {
- static_assert(static_cast<common::V1_0::ToolType>(AMOTION_EVENT_TOOL_TYPE_UNKNOWN) ==
- common::V1_0::ToolType::UNKNOWN);
- static_assert(static_cast<common::V1_0::ToolType>(AMOTION_EVENT_TOOL_TYPE_FINGER) ==
- common::V1_0::ToolType::FINGER);
- static_assert(static_cast<common::V1_0::ToolType>(AMOTION_EVENT_TOOL_TYPE_STYLUS) ==
- common::V1_0::ToolType::STYLUS);
- static_assert(static_cast<common::V1_0::ToolType>(AMOTION_EVENT_TOOL_TYPE_MOUSE) ==
- common::V1_0::ToolType::MOUSE);
- static_assert(static_cast<common::V1_0::ToolType>(AMOTION_EVENT_TOOL_TYPE_ERASER) ==
- common::V1_0::ToolType::ERASER);
- return static_cast<common::V1_0::ToolType>(toolType);
-}
-
-// MotionEvent axes asserts
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_X) ==
- common::V1_0::Axis::X);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_Y) ==
- common::V1_0::Axis::Y);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_PRESSURE) ==
- common::V1_0::Axis::PRESSURE);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_SIZE) ==
- common::V1_0::Axis::SIZE);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_TOUCH_MAJOR) ==
- common::V1_0::Axis::TOUCH_MAJOR);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_TOUCH_MINOR) ==
- common::V1_0::Axis::TOUCH_MINOR);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_TOOL_MAJOR) ==
- common::V1_0::Axis::TOOL_MAJOR);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_TOOL_MINOR) ==
- common::V1_0::Axis::TOOL_MINOR);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_ORIENTATION) ==
- common::V1_0::Axis::ORIENTATION);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_VSCROLL) ==
- common::V1_0::Axis::VSCROLL);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_HSCROLL) ==
- common::V1_0::Axis::HSCROLL);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_Z) ==
- common::V1_0::Axis::Z);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RX) ==
- common::V1_0::Axis::RX);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RY) ==
- common::V1_0::Axis::RY);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RZ) ==
- common::V1_0::Axis::RZ);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_HAT_X) ==
- common::V1_0::Axis::HAT_X);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_HAT_Y) ==
- common::V1_0::Axis::HAT_Y);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_LTRIGGER) ==
- common::V1_0::Axis::LTRIGGER);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RTRIGGER) ==
- common::V1_0::Axis::RTRIGGER);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_THROTTLE) ==
- common::V1_0::Axis::THROTTLE);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RUDDER) ==
- common::V1_0::Axis::RUDDER);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_WHEEL) ==
- common::V1_0::Axis::WHEEL);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GAS) ==
- common::V1_0::Axis::GAS);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_BRAKE) ==
- common::V1_0::Axis::BRAKE);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_DISTANCE) ==
- common::V1_0::Axis::DISTANCE);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_TILT) ==
- common::V1_0::Axis::TILT);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_SCROLL) ==
- common::V1_0::Axis::SCROLL);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RELATIVE_X) ==
- common::V1_0::Axis::RELATIVE_X);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_RELATIVE_Y) ==
- common::V1_0::Axis::RELATIVE_Y);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_1) ==
- common::V1_0::Axis::GENERIC_1);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_2) ==
- common::V1_0::Axis::GENERIC_2);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_3) ==
- common::V1_0::Axis::GENERIC_3);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_4) ==
- common::V1_0::Axis::GENERIC_4);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_5) ==
- common::V1_0::Axis::GENERIC_5);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_6) ==
- common::V1_0::Axis::GENERIC_6);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_7) ==
- common::V1_0::Axis::GENERIC_7);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_8) ==
- common::V1_0::Axis::GENERIC_8);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_9) ==
- common::V1_0::Axis::GENERIC_9);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_10) ==
- common::V1_0::Axis::GENERIC_10);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_11) ==
- common::V1_0::Axis::GENERIC_11);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_12) ==
- common::V1_0::Axis::GENERIC_12);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_13) ==
- common::V1_0::Axis::GENERIC_13);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_14) ==
- common::V1_0::Axis::GENERIC_14);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_15) ==
- common::V1_0::Axis::GENERIC_15);
-static_assert(static_cast<common::V1_0::Axis>(AMOTION_EVENT_AXIS_GENERIC_16) ==
- common::V1_0::Axis::GENERIC_16);
-
-static common::V1_0::VideoFrame getHalVideoFrame(const TouchVideoFrame& frame) {
- common::V1_0::VideoFrame out;
- out.width = frame.getWidth();
- out.height = frame.getHeight();
- out.data = frame.getData();
- struct timeval timestamp = frame.getTimestamp();
- out.timestamp = seconds_to_nanoseconds(timestamp.tv_sec) +
- microseconds_to_nanoseconds(timestamp.tv_usec);
- return out;
-}
-
-static std::vector<common::V1_0::VideoFrame> convertVideoFrames(
- const std::vector<TouchVideoFrame>& frames) {
- std::vector<common::V1_0::VideoFrame> out;
- for (const TouchVideoFrame& frame : frames) {
- out.push_back(getHalVideoFrame(frame));
- }
- return out;
-}
-
-static void getHidlPropertiesAndCoords(const NotifyMotionArgs& args,
- std::vector<common::V1_0::PointerProperties>* outPointerProperties,
- std::vector<common::V1_0::PointerCoords>* outPointerCoords) {
- outPointerProperties->reserve(args.pointerCount);
- outPointerCoords->reserve(args.pointerCount);
- for (size_t i = 0; i < args.pointerCount; i++) {
- common::V1_0::PointerProperties properties;
- properties.id = args.pointerProperties[i].id;
- properties.toolType = getToolType(args.pointerProperties[i].toolType);
- outPointerProperties->push_back(properties);
-
- common::V1_0::PointerCoords coords;
- // OK to copy bits because we have static_assert for pointerCoords axes
- coords.bits = args.pointerCoords[i].bits;
- coords.values = std::vector<float>(
- args.pointerCoords[i].values,
- args.pointerCoords[i].values + BitSet64::count(args.pointerCoords[i].bits));
- outPointerCoords->push_back(coords);
- }
-}
-
-common::V1_0::MotionEvent notifyMotionArgsToHalMotionEvent(const NotifyMotionArgs& args) {
- common::V1_0::MotionEvent event;
- event.deviceId = args.deviceId;
- event.source = getSource(args.source);
- event.displayId = args.displayId;
- event.downTime = args.downTime;
- event.eventTime = args.eventTime;
- event.deviceTimestamp = 0;
- event.action = getAction(args.action & AMOTION_EVENT_ACTION_MASK);
- event.actionIndex = MotionEvent::getActionIndex(args.action);
- event.actionButton = getActionButton(args.actionButton);
- event.flags = getFlags(args.flags);
- event.policyFlags = getPolicyFlags(args.policyFlags);
- event.edgeFlags = getEdgeFlags(args.edgeFlags);
- event.metaState = getMetastate(args.metaState);
- event.buttonState = getButtonState(args.buttonState);
- event.xPrecision = args.xPrecision;
- event.yPrecision = args.yPrecision;
-
- std::vector<common::V1_0::PointerProperties> pointerProperties;
- std::vector<common::V1_0::PointerCoords> pointerCoords;
- getHidlPropertiesAndCoords(args, /*out*/&pointerProperties, /*out*/&pointerCoords);
- event.pointerProperties = pointerProperties;
- event.pointerCoords = pointerCoords;
-
- event.frames = convertVideoFrames(args.videoFrames);
-
- return event;
-}
-
-} // namespace android
diff --git a/services/inputflinger/InputCommonConverter.cpp b/services/inputflinger/InputCommonConverter.cpp
new file mode 100644
index 0000000..8aee39f
--- /dev/null
+++ b/services/inputflinger/InputCommonConverter.cpp
@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+#include "InputCommonConverter.h"
+
+using namespace ::aidl::android::hardware::input;
+
+namespace android {
+
+static common::Source getSource(uint32_t source) {
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_UNKNOWN) == common::Source::UNKNOWN,
+ "SOURCE_UNKNOWN mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_KEYBOARD) == common::Source::KEYBOARD,
+ "SOURCE_KEYBOARD mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_DPAD) == common::Source::DPAD,
+ "SOURCE_DPAD mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_GAMEPAD) == common::Source::GAMEPAD,
+ "SOURCE_GAMEPAD mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_TOUCHSCREEN) ==
+ common::Source::TOUCHSCREEN,
+ "SOURCE_TOUCHSCREEN mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_MOUSE) == common::Source::MOUSE,
+ "SOURCE_MOUSE mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_STYLUS) == common::Source::STYLUS,
+ "SOURCE_STYLUS mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_BLUETOOTH_STYLUS) ==
+ common::Source::BLUETOOTH_STYLUS,
+ "SOURCE_BLUETOOTH_STYLUS mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_TRACKBALL) == common::Source::TRACKBALL,
+ "SOURCE_TRACKBALL mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_MOUSE_RELATIVE) ==
+ common::Source::MOUSE_RELATIVE,
+ "SOURCE_MOUSE_RELATIVE mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_TOUCHPAD) == common::Source::TOUCHPAD,
+ "SOURCE_TOUCHPAD mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_TOUCH_NAVIGATION) ==
+ common::Source::TOUCH_NAVIGATION,
+ "SOURCE_TOUCH_NAVIGATION mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_JOYSTICK) == common::Source::JOYSTICK,
+ "SOURCE_JOYSTICK mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_ROTARY_ENCODER) ==
+ common::Source::ROTARY_ENCODER,
+ "SOURCE_ROTARY_ENCODER mismatch");
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_HDMI) == common::Source::HDMI);
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_SENSOR) == common::Source::SENSOR);
+ static_assert(static_cast<common::Source>(AINPUT_SOURCE_ANY) == common::Source::ANY,
+ "SOURCE_ANY mismatch");
+ return static_cast<common::Source>(source);
+}
+
+static common::Action getAction(int32_t actionMasked) {
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_DOWN) == common::Action::DOWN,
+ "ACTION_DOWN mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_UP) == common::Action::UP,
+ "ACTION_UP mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_MOVE) == common::Action::MOVE,
+ "ACTION_MOVE mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_CANCEL) ==
+ common::Action::CANCEL,
+ "ACTION_CANCEL mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_OUTSIDE) ==
+ common::Action::OUTSIDE,
+ "ACTION_OUTSIDE mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_POINTER_DOWN) ==
+ common::Action::POINTER_DOWN,
+ "ACTION_POINTER_DOWN mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_POINTER_UP) ==
+ common::Action::POINTER_UP,
+ "ACTION_POINTER_UP mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_HOVER_MOVE) ==
+ common::Action::HOVER_MOVE,
+ "ACTION_HOVER_MOVE mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_SCROLL) ==
+ common::Action::SCROLL,
+ "ACTION_SCROLL mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_HOVER_ENTER) ==
+ common::Action::HOVER_ENTER,
+ "ACTION_HOVER_ENTER mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_HOVER_EXIT) ==
+ common::Action::HOVER_EXIT,
+ "ACTION_HOVER_EXIT mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_BUTTON_PRESS) ==
+ common::Action::BUTTON_PRESS,
+ "ACTION_BUTTON_PRESS mismatch");
+ static_assert(static_cast<common::Action>(AMOTION_EVENT_ACTION_BUTTON_RELEASE) ==
+ common::Action::BUTTON_RELEASE,
+ "ACTION_BUTTON_RELEASE mismatch");
+ return static_cast<common::Action>(actionMasked);
+}
+
+static common::Button getActionButton(int32_t actionButton) {
+ static_assert(static_cast<common::Button>(0) == common::Button::NONE, "BUTTON_NONE mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_PRIMARY) ==
+ common::Button::PRIMARY,
+ "BUTTON_PRIMARY mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_SECONDARY) ==
+ common::Button::SECONDARY,
+ "BUTTON_SECONDARY mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_TERTIARY) ==
+ common::Button::TERTIARY,
+ "BUTTON_TERTIARY mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_BACK) == common::Button::BACK,
+ "BUTTON_BACK mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_FORWARD) ==
+ common::Button::FORWARD,
+ "BUTTON_FORWARD mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_STYLUS_PRIMARY) ==
+ common::Button::STYLUS_PRIMARY,
+ "BUTTON_STYLUS_PRIMARY mismatch");
+ static_assert(static_cast<common::Button>(AMOTION_EVENT_BUTTON_STYLUS_SECONDARY) ==
+ common::Button::STYLUS_SECONDARY,
+ "BUTTON_STYLUS_SECONDARY mismatch");
+ return static_cast<common::Button>(actionButton);
+}
+
+static common::Flag getFlags(int32_t flags) {
+ static_assert(static_cast<common::Flag>(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED) ==
+ common::Flag::WINDOW_IS_OBSCURED);
+ static_assert(static_cast<common::Flag>(AMOTION_EVENT_FLAG_IS_GENERATED_GESTURE) ==
+ common::Flag::IS_GENERATED_GESTURE);
+ static_assert(static_cast<common::Flag>(AMOTION_EVENT_FLAG_TAINTED) == common::Flag::TAINTED);
+ return static_cast<common::Flag>(flags);
+}
+
+static common::PolicyFlag getPolicyFlags(int32_t flags) {
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_WAKE) == common::PolicyFlag::WAKE);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_VIRTUAL) ==
+ common::PolicyFlag::VIRTUAL);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_FUNCTION) ==
+ common::PolicyFlag::FUNCTION);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_GESTURE) ==
+ common::PolicyFlag::GESTURE);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_INJECTED) ==
+ common::PolicyFlag::INJECTED);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_TRUSTED) ==
+ common::PolicyFlag::TRUSTED);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_FILTERED) ==
+ common::PolicyFlag::FILTERED);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_DISABLE_KEY_REPEAT) ==
+ common::PolicyFlag::DISABLE_KEY_REPEAT);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_INTERACTIVE) ==
+ common::PolicyFlag::INTERACTIVE);
+ static_assert(static_cast<common::PolicyFlag>(POLICY_FLAG_PASS_TO_USER) ==
+ common::PolicyFlag::PASS_TO_USER);
+ return static_cast<common::PolicyFlag>(flags);
+}
+
+static common::EdgeFlag getEdgeFlags(int32_t flags) {
+ static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_NONE) ==
+ common::EdgeFlag::NONE);
+ static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_TOP) ==
+ common::EdgeFlag::TOP);
+ static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_BOTTOM) ==
+ common::EdgeFlag::BOTTOM);
+ static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_LEFT) ==
+ common::EdgeFlag::LEFT);
+ static_assert(static_cast<common::EdgeFlag>(AMOTION_EVENT_EDGE_FLAG_RIGHT) ==
+ common::EdgeFlag::RIGHT);
+ return static_cast<common::EdgeFlag>(flags);
+}
+
+static common::Meta getMetastate(int32_t state) {
+ static_assert(static_cast<common::Meta>(AMETA_NONE) == common::Meta::NONE);
+ static_assert(static_cast<common::Meta>(AMETA_ALT_ON) == common::Meta::ALT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_ALT_LEFT_ON) == common::Meta::ALT_LEFT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_ALT_RIGHT_ON) == common::Meta::ALT_RIGHT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_SHIFT_ON) == common::Meta::SHIFT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_SHIFT_LEFT_ON) == common::Meta::SHIFT_LEFT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_SHIFT_RIGHT_ON) == common::Meta::SHIFT_RIGHT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_SYM_ON) == common::Meta::SYM_ON);
+ static_assert(static_cast<common::Meta>(AMETA_FUNCTION_ON) == common::Meta::FUNCTION_ON);
+ static_assert(static_cast<common::Meta>(AMETA_CTRL_ON) == common::Meta::CTRL_ON);
+ static_assert(static_cast<common::Meta>(AMETA_CTRL_LEFT_ON) == common::Meta::CTRL_LEFT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_CTRL_RIGHT_ON) == common::Meta::CTRL_RIGHT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_META_ON) == common::Meta::META_ON);
+ static_assert(static_cast<common::Meta>(AMETA_META_LEFT_ON) == common::Meta::META_LEFT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_META_RIGHT_ON) == common::Meta::META_RIGHT_ON);
+ static_assert(static_cast<common::Meta>(AMETA_CAPS_LOCK_ON) == common::Meta::CAPS_LOCK_ON);
+ static_assert(static_cast<common::Meta>(AMETA_NUM_LOCK_ON) == common::Meta::NUM_LOCK_ON);
+ static_assert(static_cast<common::Meta>(AMETA_SCROLL_LOCK_ON) == common::Meta::SCROLL_LOCK_ON);
+ return static_cast<common::Meta>(state);
+}
+
+static common::Button getButtonState(int32_t buttonState) {
+ // No need for static_assert here.
+ // The button values have already been asserted in getActionButton(..) above
+ return static_cast<common::Button>(buttonState);
+}
+
+static common::ToolType getToolType(int32_t toolType) {
+ static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_UNKNOWN) ==
+ common::ToolType::UNKNOWN);
+ static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_FINGER) ==
+ common::ToolType::FINGER);
+ static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_STYLUS) ==
+ common::ToolType::STYLUS);
+ static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_MOUSE) ==
+ common::ToolType::MOUSE);
+ static_assert(static_cast<common::ToolType>(AMOTION_EVENT_TOOL_TYPE_ERASER) ==
+ common::ToolType::ERASER);
+ return static_cast<common::ToolType>(toolType);
+}
+
+// MotionEvent axes asserts
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_X) == common::Axis::X);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_Y) == common::Axis::Y);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_PRESSURE) == common::Axis::PRESSURE);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_SIZE) == common::Axis::SIZE);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOUCH_MAJOR) ==
+ common::Axis::TOUCH_MAJOR);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOUCH_MINOR) ==
+ common::Axis::TOUCH_MINOR);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOOL_MAJOR) == common::Axis::TOOL_MAJOR);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TOOL_MINOR) == common::Axis::TOOL_MINOR);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_ORIENTATION) ==
+ common::Axis::ORIENTATION);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_VSCROLL) == common::Axis::VSCROLL);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_HSCROLL) == common::Axis::HSCROLL);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_Z) == common::Axis::Z);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RX) == common::Axis::RX);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RY) == common::Axis::RY);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RZ) == common::Axis::RZ);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_HAT_X) == common::Axis::HAT_X);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_HAT_Y) == common::Axis::HAT_Y);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_LTRIGGER) == common::Axis::LTRIGGER);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RTRIGGER) == common::Axis::RTRIGGER);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_THROTTLE) == common::Axis::THROTTLE);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RUDDER) == common::Axis::RUDDER);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_WHEEL) == common::Axis::WHEEL);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GAS) == common::Axis::GAS);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_BRAKE) == common::Axis::BRAKE);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_DISTANCE) == common::Axis::DISTANCE);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_TILT) == common::Axis::TILT);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_SCROLL) == common::Axis::SCROLL);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RELATIVE_X) == common::Axis::RELATIVE_X);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_RELATIVE_Y) == common::Axis::RELATIVE_Y);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_1) == common::Axis::GENERIC_1);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_2) == common::Axis::GENERIC_2);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_3) == common::Axis::GENERIC_3);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_4) == common::Axis::GENERIC_4);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_5) == common::Axis::GENERIC_5);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_6) == common::Axis::GENERIC_6);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_7) == common::Axis::GENERIC_7);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_8) == common::Axis::GENERIC_8);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_9) == common::Axis::GENERIC_9);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_10) == common::Axis::GENERIC_10);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_11) == common::Axis::GENERIC_11);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_12) == common::Axis::GENERIC_12);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_13) == common::Axis::GENERIC_13);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_14) == common::Axis::GENERIC_14);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_15) == common::Axis::GENERIC_15);
+static_assert(static_cast<common::Axis>(AMOTION_EVENT_AXIS_GENERIC_16) == common::Axis::GENERIC_16);
+
+static common::VideoFrame getHalVideoFrame(const TouchVideoFrame& frame) {
+ common::VideoFrame out;
+ out.width = frame.getWidth();
+ out.height = frame.getHeight();
+ std::vector<char16_t> unsignedData(frame.getData().begin(), frame.getData().end());
+ out.data = unsignedData;
+ struct timeval timestamp = frame.getTimestamp();
+ out.timestamp = seconds_to_nanoseconds(timestamp.tv_sec) +
+ microseconds_to_nanoseconds(timestamp.tv_usec);
+ return out;
+}
+
+static std::vector<common::VideoFrame> convertVideoFrames(
+ const std::vector<TouchVideoFrame>& frames) {
+ std::vector<common::VideoFrame> out;
+ for (const TouchVideoFrame& frame : frames) {
+ out.push_back(getHalVideoFrame(frame));
+ }
+ return out;
+}
+
+static void getHalPropertiesAndCoords(const NotifyMotionArgs& args,
+ std::vector<common::PointerProperties>& outPointerProperties,
+ std::vector<common::PointerCoords>& outPointerCoords) {
+ outPointerProperties.reserve(args.pointerCount);
+ outPointerCoords.reserve(args.pointerCount);
+ for (size_t i = 0; i < args.pointerCount; i++) {
+ common::PointerProperties properties;
+ properties.id = args.pointerProperties[i].id;
+ properties.toolType = getToolType(args.pointerProperties[i].toolType);
+ outPointerProperties.push_back(properties);
+
+ common::PointerCoords coords;
+ // OK to copy bits because we have static_assert for pointerCoords axes
+ coords.bits = args.pointerCoords[i].bits;
+ coords.values = std::vector<float>(args.pointerCoords[i].values,
+ args.pointerCoords[i].values +
+ BitSet64::count(args.pointerCoords[i].bits));
+ outPointerCoords.push_back(coords);
+ }
+}
+
+common::MotionEvent notifyMotionArgsToHalMotionEvent(const NotifyMotionArgs& args) {
+ common::MotionEvent event;
+ event.deviceId = args.deviceId;
+ event.source = getSource(args.source);
+ event.displayId = args.displayId;
+ event.downTime = args.downTime;
+ event.eventTime = args.eventTime;
+ event.deviceTimestamp = 0;
+ event.action = getAction(args.action & AMOTION_EVENT_ACTION_MASK);
+ event.actionIndex = MotionEvent::getActionIndex(args.action);
+ event.actionButton = getActionButton(args.actionButton);
+ event.flags = getFlags(args.flags);
+ event.policyFlags = getPolicyFlags(args.policyFlags);
+ event.edgeFlags = getEdgeFlags(args.edgeFlags);
+ event.metaState = getMetastate(args.metaState);
+ event.buttonState = getButtonState(args.buttonState);
+ event.xPrecision = args.xPrecision;
+ event.yPrecision = args.yPrecision;
+
+ std::vector<common::PointerProperties> pointerProperties;
+ std::vector<common::PointerCoords> pointerCoords;
+ getHalPropertiesAndCoords(args, /*out*/ pointerProperties, /*out*/ pointerCoords);
+ event.pointerProperties = pointerProperties;
+ event.pointerCoords = pointerCoords;
+
+ event.frames = convertVideoFrames(args.videoFrames);
+
+ return event;
+}
+
+} // namespace android
diff --git a/services/inputflinger/InputClassifierConverter.h b/services/inputflinger/InputCommonConverter.h
similarity index 65%
rename from services/inputflinger/InputClassifierConverter.h
rename to services/inputflinger/InputCommonConverter.h
index 5154b0b..4d3b768 100644
--- a/services/inputflinger/InputClassifierConverter.h
+++ b/services/inputflinger/InputCommonConverter.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2019 The Android Open Source Project
+ * Copyright (C) 2022 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.
@@ -14,21 +14,18 @@
* limitations under the License.
*/
-#ifndef _UI_INPUT_CLASSIFIER_CONVERTER_H
-#define _UI_INPUT_CLASSIFIER_CONVERTER_H
+#pragma once
+#include <aidl/android/hardware/input/common/Axis.h>
+#include <aidl/android/hardware/input/common/MotionEvent.h>
#include "InputListener.h"
-#include <android/hardware/input/common/1.0/types.h>
-
namespace android {
/**
- * Convert from framework's NotifyMotionArgs to hidl's common::V1_0::MotionEvent
+ * Convert from framework's NotifyMotionArgs to hidl's common::MotionEvent
*/
-::android::hardware::input::common::V1_0::MotionEvent notifyMotionArgsToHalMotionEvent(
+::aidl::android::hardware::input::common::MotionEvent notifyMotionArgsToHalMotionEvent(
const NotifyMotionArgs& args);
} // namespace android
-
-#endif // _UI_INPUT_CLASSIFIER_CONVERTER_H
diff --git a/services/inputflinger/tests/InputClassifierConverter_test.cpp b/services/inputflinger/tests/InputClassifierConverter_test.cpp
index f626d56..81ef9b9 100644
--- a/services/inputflinger/tests/InputClassifierConverter_test.cpp
+++ b/services/inputflinger/tests/InputClassifierConverter_test.cpp
@@ -14,13 +14,13 @@
* limitations under the License.
*/
-#include "../InputClassifierConverter.h"
+#include "../InputCommonConverter.h"
#include <gtest/gtest.h>
#include <gui/constants.h>
#include <utils/BitSet.h>
-using namespace android::hardware::input;
+using namespace aidl::android::hardware::input;
namespace android {
@@ -50,8 +50,7 @@
return motionArgs;
}
-static float getMotionEventAxis(common::V1_0::PointerCoords coords,
- common::V1_0::Axis axis) {
+static float getMotionEventAxis(common::PointerCoords coords, common::Axis axis) {
uint32_t index = BitSet64::getIndexOfBit(static_cast<uint64_t>(coords.bits),
static_cast<uint64_t>(axis));
return coords.values[index];
@@ -68,14 +67,14 @@
ASSERT_EQ(0.5, motionArgs.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_SIZE));
ASSERT_EQ(3U, BitSet64::count(motionArgs.pointerCoords[0].bits));
- common::V1_0::MotionEvent motionEvent = notifyMotionArgsToHalMotionEvent(motionArgs);
+ common::MotionEvent motionEvent = notifyMotionArgsToHalMotionEvent(motionArgs);
- ASSERT_EQ(getMotionEventAxis(motionEvent.pointerCoords[0], common::V1_0::Axis::X),
- motionArgs.pointerCoords[0].getX());
- ASSERT_EQ(getMotionEventAxis(motionEvent.pointerCoords[0], common::V1_0::Axis::Y),
- motionArgs.pointerCoords[0].getY());
- ASSERT_EQ(getMotionEventAxis(motionEvent.pointerCoords[0], common::V1_0::Axis::SIZE),
- motionArgs.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_SIZE));
+ ASSERT_EQ(getMotionEventAxis(motionEvent.pointerCoords[0], common::Axis::X),
+ motionArgs.pointerCoords[0].getX());
+ ASSERT_EQ(getMotionEventAxis(motionEvent.pointerCoords[0], common::Axis::Y),
+ motionArgs.pointerCoords[0].getY());
+ ASSERT_EQ(getMotionEventAxis(motionEvent.pointerCoords[0], common::Axis::SIZE),
+ motionArgs.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_SIZE));
ASSERT_EQ(BitSet64::count(motionArgs.pointerCoords[0].bits),
BitSet64::count(motionEvent.pointerCoords[0].bits));
}
diff --git a/services/inputflinger/tests/InputClassifier_test.cpp b/services/inputflinger/tests/InputClassifier_test.cpp
index f13187d..3a77127 100644
--- a/services/inputflinger/tests/InputClassifier_test.cpp
+++ b/services/inputflinger/tests/InputClassifier_test.cpp
@@ -20,12 +20,14 @@
#include "TestInputListener.h"
-#include <android/hardware/input/classifier/1.0/IInputClassifier.h>
+#include <aidl/android/hardware/input/processor/BnInputProcessor.h>
+#include <aidl/android/hardware/input/processor/IInputProcessor.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
-using namespace android::hardware::input;
-using android::hardware::Return;
-using android::hardware::Void;
-using android::hardware::input::common::V1_0::Classification;
+using namespace aidl::android::hardware::input;
+using aidl::android::hardware::input::common::Classification;
+using aidl::android::hardware::input::processor::IInputProcessor;
namespace android {
@@ -154,22 +156,17 @@
/**
* A minimal implementation of IInputClassifier.
*/
-struct TestHal : public android::hardware::input::classifier::V1_0::IInputClassifier {
- Return<Classification> classify(
- const android::hardware::input::common::V1_0::MotionEvent& event) override {
- return Classification::NONE;
- };
- Return<void> reset() override { return Void(); };
- Return<void> resetDevice(int32_t deviceId) override { return Void(); };
-};
-
-/**
- * An entity that will be subscribed to the HAL death.
- */
-class TestDeathRecipient : public android::hardware::hidl_death_recipient {
-public:
- virtual void serviceDied(uint64_t cookie,
- const wp<android::hidl::base::V1_0::IBase>& who) override{};
+class TestHal : public aidl::android::hardware::input::processor::BnInputProcessor {
+ ::ndk::ScopedAStatus classify(
+ const ::aidl::android::hardware::input::common::MotionEvent& in_event,
+ ::aidl::android::hardware::input::common::Classification* _aidl_return) override {
+ *_aidl_return = Classification::NONE;
+ return ndk::ScopedAStatus::ok();
+ }
+ ::ndk::ScopedAStatus reset() override { return ndk::ScopedAStatus::ok(); }
+ ::ndk::ScopedAStatus resetDevice(int32_t in_deviceId) override {
+ return ndk::ScopedAStatus::ok();
+ }
};
// --- MotionClassifierTest ---
@@ -178,15 +175,9 @@
protected:
std::unique_ptr<MotionClassifierInterface> mMotionClassifier;
- virtual void SetUp() override {
- mMotionClassifier = MotionClassifier::create(new TestDeathRecipient());
- if (mMotionClassifier == nullptr) {
- // If the device running this test does not have IInputClassifier service,
- // use the test HAL instead.
- // Using 'new' to access non-public constructor
- mMotionClassifier =
- std::unique_ptr<MotionClassifier>(new MotionClassifier(new TestHal()));
- }
+ void SetUp() override {
+ std::shared_ptr<IInputProcessor> service = ndk::SharedRefBase::make<TestHal>();
+ mMotionClassifier = MotionClassifier::create(std::move(service));
}
};
