Add SensorManager support in inputflinger.
Add sensor device, sensor input mapper, sens event dispatcher support
into inputflinger.
Bug: 161634265
Test: atest inputflinger_tests
Change-Id: I2dcb2c35d9dccefc4cd8d939b79cf340931a9410
diff --git a/services/inputflinger/dispatcher/Entry.cpp b/services/inputflinger/dispatcher/Entry.cpp
index d8a6548..f0976b9 100644
--- a/services/inputflinger/dispatcher/Entry.cpp
+++ b/services/inputflinger/dispatcher/Entry.cpp
@@ -239,6 +239,41 @@
return msg;
}
+// --- SensorEntry ---
+
+SensorEntry::SensorEntry(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,
+ uint32_t policyFlags, nsecs_t hwTimestamp,
+ InputDeviceSensorType sensorType, InputDeviceSensorAccuracy accuracy,
+ bool accuracyChanged, std::vector<float> values)
+ : EventEntry(id, Type::SENSOR, eventTime, policyFlags),
+ deviceId(deviceId),
+ source(source),
+ sensorType(sensorType),
+ accuracy(accuracy),
+ accuracyChanged(accuracyChanged),
+ hwTimestamp(hwTimestamp),
+ values(std::move(values)) {}
+
+SensorEntry::~SensorEntry() {}
+
+std::string SensorEntry::getDescription() const {
+ std::string msg;
+ msg += StringPrintf("SensorEntry(deviceId=%d, source=0x%08x, sensorType=0x%08x, "
+ "accuracy=0x%08x, hwTimestamp=%" PRId64,
+ deviceId, source, sensorType, accuracy, hwTimestamp);
+
+ if (!GetBoolProperty("ro.debuggable", false)) {
+ for (size_t i = 0; i < values.size(); i++) {
+ if (i > 0) {
+ msg += ", ";
+ }
+ msg += StringPrintf("(%.3f)", values[i]);
+ }
+ }
+ msg += StringPrintf(", policyFlags=0x%08x", policyFlags);
+ return msg;
+}
+
// --- DispatchEntry ---
volatile int32_t DispatchEntry::sNextSeqAtomic;
diff --git a/services/inputflinger/dispatcher/Entry.h b/services/inputflinger/dispatcher/Entry.h
index fba5514..3a860f0 100644
--- a/services/inputflinger/dispatcher/Entry.h
+++ b/services/inputflinger/dispatcher/Entry.h
@@ -36,26 +36,10 @@
FOCUS,
KEY,
MOTION,
+ SENSOR,
POINTER_CAPTURE_CHANGED,
};
- static const char* typeToString(Type type) {
- switch (type) {
- case Type::CONFIGURATION_CHANGED:
- return "CONFIGURATION_CHANGED";
- case Type::DEVICE_RESET:
- return "DEVICE_RESET";
- case Type::FOCUS:
- return "FOCUS";
- case Type::KEY:
- return "KEY";
- case Type::MOTION:
- return "MOTION";
- case Type::POINTER_CAPTURE_CHANGED:
- return "POINTER_CAPTURE_CHANGED";
- }
- }
-
int32_t id;
Type type;
nsecs_t eventTime;
@@ -191,6 +175,25 @@
virtual ~MotionEntry();
};
+struct SensorEntry : EventEntry {
+ int32_t deviceId;
+ uint32_t source;
+ InputDeviceSensorType sensorType;
+ InputDeviceSensorAccuracy accuracy;
+ bool accuracyChanged;
+ nsecs_t hwTimestamp;
+
+ std::vector<float> values;
+
+ SensorEntry(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,
+ uint32_t policyFlags, nsecs_t hwTimestamp, InputDeviceSensorType sensorType,
+ InputDeviceSensorAccuracy accuracy, bool accuracyChanged,
+ std::vector<float> values);
+ std::string getDescription() const override;
+
+ virtual ~SensorEntry();
+};
+
// Tracks the progress of dispatching a particular event to a particular connection.
struct DispatchEntry {
const uint32_t seq; // unique sequence number, never 0
@@ -257,6 +260,7 @@
sp<Connection> connection;
nsecs_t eventTime;
std::shared_ptr<KeyEntry> keyEntry;
+ std::shared_ptr<SensorEntry> sensorEntry;
std::shared_ptr<InputApplicationHandle> inputApplicationHandle;
std::string reason;
int32_t userActivityEventType;
diff --git a/services/inputflinger/dispatcher/InputDispatcher.cpp b/services/inputflinger/dispatcher/InputDispatcher.cpp
index 6c44a54..3af3372 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.cpp
+++ b/services/inputflinger/dispatcher/InputDispatcher.cpp
@@ -47,8 +47,6 @@
// Log debug messages about hover events.
#define DEBUG_HOVER 0
-#include "InputDispatcher.h"
-
#include <android-base/chrono_utils.h>
#include <android-base/stringprintf.h>
#include <android/os/IInputConstants.h>
@@ -73,6 +71,7 @@
#include <sstream>
#include "Connection.h"
+#include "InputDispatcher.h"
#define INDENT " "
#define INDENT2 " "
@@ -758,6 +757,23 @@
done = dispatchMotionLocked(currentTime, motionEntry, &dropReason, nextWakeupTime);
break;
}
+
+ case EventEntry::Type::SENSOR: {
+ std::shared_ptr<SensorEntry> sensorEntry =
+ std::static_pointer_cast<SensorEntry>(mPendingEvent);
+ if (dropReason == DropReason::NOT_DROPPED && isAppSwitchDue) {
+ dropReason = DropReason::APP_SWITCH;
+ }
+ // Sensor timestamps use SYSTEM_TIME_BOOTTIME time base, so we can't use
+ // 'currentTime' here, get SYSTEM_TIME_BOOTTIME instead.
+ nsecs_t bootTime = systemTime(SYSTEM_TIME_BOOTTIME);
+ if (dropReason == DropReason::NOT_DROPPED && isStaleEvent(bootTime, *sensorEntry)) {
+ dropReason = DropReason::STALE;
+ }
+ dispatchSensorLocked(currentTime, sensorEntry, &dropReason, nextWakeupTime);
+ done = true;
+ break;
+ }
}
if (done) {
@@ -873,6 +889,7 @@
}
case EventEntry::Type::CONFIGURATION_CHANGED:
case EventEntry::Type::DEVICE_RESET:
+ case EventEntry::Type::SENSOR:
case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
// nothing to do
break;
@@ -883,7 +900,10 @@
}
void InputDispatcher::addRecentEventLocked(std::shared_ptr<EventEntry> entry) {
- mRecentQueue.push_back(entry);
+ // Do not store sensor event in recent queue to avoid flooding the queue.
+ if (entry->type != EventEntry::Type::SENSOR) {
+ mRecentQueue.push_back(entry);
+ }
if (mRecentQueue.size() > RECENT_QUEUE_MAX_SIZE) {
mRecentQueue.pop_front();
}
@@ -1006,13 +1026,16 @@
}
break;
}
+ case EventEntry::Type::SENSOR: {
+ break;
+ }
case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
break;
}
case EventEntry::Type::FOCUS:
case EventEntry::Type::CONFIGURATION_CHANGED:
case EventEntry::Type::DEVICE_RESET: {
- LOG_ALWAYS_FATAL("Should not drop %s events", EventEntry::typeToString(entry.type));
+ LOG_ALWAYS_FATAL("Should not drop %s events", NamedEnum::string(entry.type).c_str());
break;
}
}
@@ -1365,6 +1388,51 @@
#endif
}
+void InputDispatcher::doNotifySensorLockedInterruptible(CommandEntry* commandEntry) {
+ mLock.unlock();
+
+ const std::shared_ptr<SensorEntry>& entry = commandEntry->sensorEntry;
+ if (entry->accuracyChanged) {
+ mPolicy->notifySensorAccuracy(entry->deviceId, entry->sensorType, entry->accuracy);
+ }
+ mPolicy->notifySensorEvent(entry->deviceId, entry->sensorType, entry->accuracy,
+ entry->hwTimestamp, entry->values);
+ mLock.lock();
+}
+
+void InputDispatcher::dispatchSensorLocked(nsecs_t currentTime, std::shared_ptr<SensorEntry> entry,
+ DropReason* dropReason, nsecs_t* nextWakeupTime) {
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+ ALOGD("notifySensorEvent eventTime=%" PRId64 ", hwTimestamp=%" PRId64 ", deviceId=%d, "
+ "source=0x%x, sensorType=%s",
+ entry->eventTime, entry->hwTimestamp, entry->deviceId, entry->source,
+ NamedEnum::string(sensorType).c_str());
+#endif
+ std::unique_ptr<CommandEntry> commandEntry =
+ std::make_unique<CommandEntry>(&InputDispatcher::doNotifySensorLockedInterruptible);
+ commandEntry->sensorEntry = entry;
+ postCommandLocked(std::move(commandEntry));
+}
+
+bool InputDispatcher::flushSensor(int deviceId, InputDeviceSensorType sensorType) {
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+ ALOGD("flushSensor deviceId=%d, sensorType=%s", deviceId,
+ NamedEnum::string(sensorType).c_str());
+#endif
+ { // acquire lock
+ std::scoped_lock _l(mLock);
+
+ for (auto it = mInboundQueue.begin(); it != mInboundQueue.end(); it++) {
+ std::shared_ptr<EventEntry> entry = *it;
+ if (entry->type == EventEntry::Type::SENSOR) {
+ it = mInboundQueue.erase(it);
+ releaseInboundEventLocked(entry);
+ }
+ }
+ }
+ return true;
+}
+
bool InputDispatcher::dispatchMotionLocked(nsecs_t currentTime, std::shared_ptr<MotionEntry> entry,
DropReason* dropReason, nsecs_t* nextWakeupTime) {
ATRACE_CALL();
@@ -1553,8 +1621,9 @@
case EventEntry::Type::POINTER_CAPTURE_CHANGED:
case EventEntry::Type::FOCUS:
case EventEntry::Type::CONFIGURATION_CHANGED:
- case EventEntry::Type::DEVICE_RESET: {
- ALOGE("%s events do not have a target display", EventEntry::typeToString(entry.type));
+ case EventEntry::Type::DEVICE_RESET:
+ case EventEntry::Type::SENSOR: {
+ ALOGE("%s events do not have a target display", NamedEnum::string(entry.type).c_str());
return ADISPLAY_ID_NONE;
}
}
@@ -1608,7 +1677,7 @@
if (focusedWindowHandle == nullptr && focusedApplicationHandle == nullptr) {
ALOGI("Dropping %s event because there is no focused window or focused application in "
"display %" PRId32 ".",
- EventEntry::typeToString(entry.type), displayId);
+ NamedEnum::string(entry.type).c_str(), displayId);
return InputEventInjectionResult::FAILED;
}
@@ -1633,7 +1702,7 @@
} else if (currentTime > *mNoFocusedWindowTimeoutTime) {
// Already raised ANR. Drop the event
ALOGE("Dropping %s event because there is no focused window",
- EventEntry::typeToString(entry.type));
+ NamedEnum::string(entry.type).c_str());
return InputEventInjectionResult::FAILED;
} else {
// Still waiting for the focused window
@@ -2476,9 +2545,10 @@
case EventEntry::Type::FOCUS:
case EventEntry::Type::CONFIGURATION_CHANGED:
case EventEntry::Type::DEVICE_RESET:
+ case EventEntry::Type::SENSOR:
case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
LOG_ALWAYS_FATAL("%s events are not user activity",
- EventEntry::typeToString(eventEntry.type));
+ NamedEnum::string(eventEntry.type).c_str());
break;
}
}
@@ -2522,7 +2592,7 @@
if (inputTarget.flags & InputTarget::FLAG_SPLIT) {
LOG_ALWAYS_FATAL_IF(eventEntry->type != EventEntry::Type::MOTION,
"Entry type %s should not have FLAG_SPLIT",
- EventEntry::typeToString(eventEntry->type));
+ NamedEnum::string(eventEntry->type).c_str());
const MotionEntry& originalMotionEntry = static_cast<const MotionEntry&>(*eventEntry);
if (inputTarget.pointerIds.count() != originalMotionEntry.pointerCount) {
@@ -2692,10 +2762,14 @@
case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
break;
}
+ case EventEntry::Type::SENSOR: {
+ LOG_ALWAYS_FATAL("SENSOR events should not go to apps via input channel");
+ break;
+ }
case EventEntry::Type::CONFIGURATION_CHANGED:
case EventEntry::Type::DEVICE_RESET: {
LOG_ALWAYS_FATAL("%s events should not go to apps",
- EventEntry::typeToString(newEntry.type));
+ NamedEnum::string(newEntry.type).c_str());
break;
}
}
@@ -2913,9 +2987,10 @@
}
case EventEntry::Type::CONFIGURATION_CHANGED:
- case EventEntry::Type::DEVICE_RESET: {
+ case EventEntry::Type::DEVICE_RESET:
+ case EventEntry::Type::SENSOR: {
LOG_ALWAYS_FATAL("Should never start dispatch cycles for %s events",
- EventEntry::typeToString(eventEntry.type));
+ NamedEnum::string(eventEntry.type).c_str());
return;
}
}
@@ -3209,13 +3284,14 @@
case EventEntry::Type::FOCUS:
case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
LOG_ALWAYS_FATAL("Canceling %s events is not supported",
- EventEntry::typeToString(cancelationEventEntry->type));
+ NamedEnum::string(cancelationEventEntry->type).c_str());
break;
}
case EventEntry::Type::CONFIGURATION_CHANGED:
- case EventEntry::Type::DEVICE_RESET: {
+ case EventEntry::Type::DEVICE_RESET:
+ case EventEntry::Type::SENSOR: {
LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
- EventEntry::typeToString(cancelationEventEntry->type));
+ NamedEnum::string(cancelationEventEntry->type).c_str());
break;
}
}
@@ -3270,9 +3346,10 @@
case EventEntry::Type::FOCUS:
case EventEntry::Type::CONFIGURATION_CHANGED:
case EventEntry::Type::DEVICE_RESET:
- case EventEntry::Type::POINTER_CAPTURE_CHANGED: {
+ case EventEntry::Type::POINTER_CAPTURE_CHANGED:
+ case EventEntry::Type::SENSOR: {
LOG_ALWAYS_FATAL("%s event should not be found inside Connections's queue",
- EventEntry::typeToString(downEventEntry->type));
+ NamedEnum::string(downEventEntry->type).c_str());
break;
}
}
@@ -3605,6 +3682,34 @@
}
}
+void InputDispatcher::notifySensor(const NotifySensorArgs* args) {
+#if DEBUG_INBOUND_EVENT_DETAILS
+ ALOGD("notifySensor - id=%" PRIx32 " eventTime=%" PRId64 ", deviceId=%d, source=0x%x, "
+ " sensorType=%s",
+ args->id, args->eventTime, args->deviceId, args->source,
+ NamedEnum::string(args->sensorType).c_str());
+#endif
+
+ bool needWake;
+ { // acquire lock
+ mLock.lock();
+
+ // Just enqueue a new sensor event.
+ std::unique_ptr<SensorEntry> newEntry =
+ std::make_unique<SensorEntry>(args->id, args->eventTime, args->deviceId,
+ args->source, 0 /* policyFlags*/, args->hwTimestamp,
+ args->sensorType, args->accuracy,
+ args->accuracyChanged, args->values);
+
+ needWake = enqueueInboundEventLocked(std::move(newEntry));
+ mLock.unlock();
+ } // release lock
+
+ if (needWake) {
+ mLooper->wake();
+ }
+}
+
bool InputDispatcher::shouldSendMotionToInputFilterLocked(const NotifyMotionArgs* args) {
return mInputFilterEnabled;
}
diff --git a/services/inputflinger/dispatcher/InputDispatcher.h b/services/inputflinger/dispatcher/InputDispatcher.h
index 5d37645..3004701 100644
--- a/services/inputflinger/dispatcher/InputDispatcher.h
+++ b/services/inputflinger/dispatcher/InputDispatcher.h
@@ -94,6 +94,7 @@
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 notifyDeviceReset(const NotifyDeviceResetArgs* args) override;
virtual void notifyPointerCaptureChanged(const NotifyPointerCaptureChangedArgs* args) override;
@@ -128,6 +129,7 @@
virtual status_t removeInputChannel(const sp<IBinder>& connectionToken) override;
virtual status_t pilferPointers(const sp<IBinder>& token) override;
virtual void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) override;
+ virtual bool flushSensor(int deviceId, InputDeviceSensorType sensorType) override;
std::array<uint8_t, 32> sign(const VerifiedInputEvent& event) const;
@@ -392,7 +394,8 @@
DropReason& dropReason) REQUIRES(mLock);
void dispatchEventLocked(nsecs_t currentTime, std::shared_ptr<EventEntry> entry,
const std::vector<InputTarget>& inputTargets) REQUIRES(mLock);
-
+ void dispatchSensorLocked(nsecs_t currentTime, std::shared_ptr<SensorEntry> entry,
+ DropReason* dropReason, nsecs_t* nextWakeupTime) REQUIRES(mLock);
void logOutboundKeyDetails(const char* prefix, const KeyEntry& entry);
void logOutboundMotionDetails(const char* prefix, const MotionEntry& entry);
@@ -592,6 +595,7 @@
REQUIRES(mLock);
void doNotifyConnectionResponsiveLockedInterruptible(CommandEntry* commandEntry)
REQUIRES(mLock);
+ void doNotifySensorLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
void doNotifyUntrustedTouchLockedInterruptible(CommandEntry* commandEntry) REQUIRES(mLock);
void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry)
REQUIRES(mLock);
diff --git a/services/inputflinger/dispatcher/InputState.cpp b/services/inputflinger/dispatcher/InputState.cpp
index 1656a21..3bb0bc9 100644
--- a/services/inputflinger/dispatcher/InputState.cpp
+++ b/services/inputflinger/dispatcher/InputState.cpp
@@ -14,6 +14,8 @@
* limitations under the License.
*/
+#include "input/InputDevice.h"
+
#include "InputState.h"
#include "InputDispatcher.h"
diff --git a/services/inputflinger/dispatcher/include/InputDispatcherInterface.h b/services/inputflinger/dispatcher/include/InputDispatcherInterface.h
index 2909d69..6e76c92 100644
--- a/services/inputflinger/dispatcher/include/InputDispatcherInterface.h
+++ b/services/inputflinger/dispatcher/include/InputDispatcherInterface.h
@@ -25,6 +25,7 @@
#include <android/os/InputEventInjectionResult.h>
#include <android/os/InputEventInjectionSync.h>
#include <input/InputApplication.h>
+#include <input/InputDevice.h>
#include <input/InputTransport.h>
#include <input/InputWindow.h>
#include <unordered_map>
@@ -193,6 +194,11 @@
* InputDispatcher is the source of truth of Pointer Capture.
*/
virtual void requestPointerCapture(const sp<IBinder>& windowToken, bool enabled) = 0;
+ /* Flush input device motion sensor.
+ *
+ * Returns true on success.
+ */
+ virtual bool flushSensor(int deviceId, InputDeviceSensorType sensorType) = 0;
};
} // namespace android
diff --git a/services/inputflinger/dispatcher/include/InputDispatcherPolicyInterface.h b/services/inputflinger/dispatcher/include/InputDispatcherPolicyInterface.h
index c1821ab..d9ec020 100644
--- a/services/inputflinger/dispatcher/include/InputDispatcherPolicyInterface.h
+++ b/services/inputflinger/dispatcher/include/InputDispatcherPolicyInterface.h
@@ -68,6 +68,11 @@
/* Notifies the system that an input channel is unrecoverably broken. */
virtual void notifyInputChannelBroken(const sp<IBinder>& token) = 0;
virtual void notifyFocusChanged(const sp<IBinder>& oldToken, const sp<IBinder>& newToken) = 0;
+ virtual void notifySensorEvent(int32_t deviceId, InputDeviceSensorType sensorType,
+ InputDeviceSensorAccuracy accuracy, nsecs_t timestamp,
+ const std::vector<float>& values) = 0;
+ virtual void notifySensorAccuracy(int32_t deviceId, InputDeviceSensorType sensorType,
+ InputDeviceSensorAccuracy accuracy) = 0;
/* Notifies the system that an untrusted touch occurred. */
virtual void notifyUntrustedTouch(const std::string& obscuringPackage) = 0;