Evolution-x-devices/device_motorola_rtwo
2
0
Fork 0
mirror of https://github.com/Evolution-X-Devices/device_motorola_rtwo synced 2026-01-27 07:50:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "eqs: sensors: Create input event polling one shot sensor"

Browse Source 
This reverts commit 19f1c1d6f0.
This commit is contained in:
Cosmin Tanislav
2023-01-14 01:13:50 +02:00
parent ba5cfd5c43
commit 616fd9ae2b
8 changed files with 12 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
sensors/Android.bp
View File

@@ -5,7 +5,7 @@
//
cc_library_shared {
name: "sensors.eqs",
name: "sensors.dubai",
defaults: ["hidl_defaults"],
srcs: [
"Sensor.cpp",
@@ -16,7 +16,6 @@ cc_library_shared {
"android.hardware.sensors@2.0",
"android.hardware.sensors@2.0-ScopedWakelock",
"android.hardware.sensors@2.1",
"libc",
"libcutils",
"libfmq",
"libhardware",
@@ -30,7 +29,7 @@ cc_library_shared {
"android.hardware.sensors@2.X-multihal",
],
cflags: [
"-DLOG_TAG=\"sensors.eqs\"",
"-DLOG_TAG=\"sensors.dubai\"",
],
vendor: true,
}

200
sensors/Sensor.cpp
View File

@@ -17,44 +17,9 @@
#include "Sensor.h"
#include <hardware/sensors.h>
#include <log/log.h>
#include <utils/SystemClock.h>
#include <cmath>
#include <linux/input.h>
static bool readEvent(int fd, struct input_event *event) {
int rc;
rc = read(fd, event, sizeof(struct input_event));
if (rc != sizeof(struct input_event)) {
ALOGE("failed to read event from fd, err: %d", rc);
return false;
}
return true;
}
static bool readBool(int fd, bool seek) {
char c;
int rc;
if (seek) {
rc = lseek(fd, 0, SEEK_SET);
if (rc) {
ALOGE("failed to seek: %d", rc);
return false;
}
}
rc = read(fd, &c, sizeof(c));
if (rc != 1) {
ALOGE("failed to read bool: %d", rc);
return false;
}
return c != '0';
}
namespace android {
namespace hardware {
@@ -226,171 +191,6 @@ OneShotSensor::OneShotSensor(int32_t sensorHandle, ISensorsEventCallback* callba
mSensorInfo.flags |= SensorFlagBits::ONE_SHOT_MODE;
}
#define INPUT_DT2W_SENSOR_PATH "/dev/input/event10"
#define INPUT_TOUCHSCREEN_PATH "/dev/input/event11"
#define GESTURE_PATH "/sys/class/touchscreen/primary/gesture"
InputEventDT2WSensor::InputEventDT2WSensor(
int32_t sensorHandle, ISensorsEventCallback* callback)
: OneShotSensor(sensorHandle, callback) {
mSensorInfo.name = "DT2W sensor";
mSensorInfo.type = static_cast<SensorType>(static_cast<int32_t>(SensorType::DEVICE_PRIVATE_BASE) + 1);
mSensorInfo.typeAsString = "org.lineageos.sensor.dt2w";
mSensorInfo.maxRange = 2048.0f;
mSensorInfo.resolution = 1.0f;
mSensorInfo.power = 0;
mSensorInfo.flags |= SensorFlagBits::WAKE_UP;
std::ofstream mGestureEnable;
mGestureEnable.open(GESTURE_PATH);
if(!mGestureEnable) {
ALOGE("could not open gesture path");
mStopThread = true;
return;
}
mGestureEnable << "49" << std::flush;
int rc;
rc = pipe(mWaitPipeFd);
if (rc < 0) {
mWaitPipeFd[0] = -1;
mWaitPipeFd[1] = -1;
ALOGE("failed to open wait pipe: %d", rc);
}
mPollFds[0] = open(INPUT_DT2W_SENSOR_PATH, O_RDONLY | O_NONBLOCK);
if (mPollFds[0] < 0) {
ALOGE("failed to open poll fd: %d", mPollFds[0]);
}
mPollFds[1] = open(INPUT_TOUCHSCREEN_PATH, O_RDONLY | O_NONBLOCK);
if (mPollFds[1] < 0) {
ALOGE("failed to open poll fd: %d", mPollFds[1]);
}
if (mWaitPipeFd[0] < 0 || mWaitPipeFd[1] < 0 || mPollFds[0] < 0 || mPollFds[1] < 0) {
mStopThread = true;
return;
}
mPolls[0] = {
.fd = mWaitPipeFd[0],
.events = POLLIN,
};
mPolls[1] = {
.fd = mPollFds[0],
.events = POLLIN,
};
mPolls[2] = {
.fd = mPollFds[1],
.events = POLLIN,
};
}
InputEventDT2WSensor::~InputEventDT2WSensor() {
interruptPoll();
}
void InputEventDT2WSensor::activate(bool enable) {
std::lock_guard<std::mutex> lock(mRunMutex);
if (mIsEnabled != enable) {
mIsEnabled = enable;
interruptPoll();
mWaitCV.notify_all();
}
}
void InputEventDT2WSensor::setOperationMode(OperationMode mode) {
Sensor::setOperationMode(mode);
interruptPoll();
}
void InputEventDT2WSensor::run() {
std::unique_lock<std::mutex> runLock(mRunMutex);
long old_time = 0;
long new_time = 0;
int old_x = 0;
int new_x = 0;
int old_y = 0;
int new_y = 0;
while (!mStopThread) {
if (!mIsEnabled || mMode == OperationMode::DATA_INJECTION) {
mWaitCV.wait(runLock, [&] {
return ((mIsEnabled && mMode == OperationMode::NORMAL) || mStopThread);
});
} else {
// Cannot hold lock while polling.
runLock.unlock();
int rc = poll(mPolls, 3, -1);
runLock.lock();
struct input_event event;
if (rc < 0) {
ALOGE("failed to poll: %d", rc);
mStopThread = true;
continue;
}
if((mPolls[1].revents == mPolls[1].events) && readEvent(mPolls[1].fd, &event)) {
if(event.type == EV_KEY && event.value == 1 && event.code == KEY_F4) {
mIsEnabled = false;
mCallback->postEvents(readEvents(), isWakeUpSensor());
}
} else if((mPolls[2].revents == mPolls[2].events) && readEvent(mPolls[2].fd, &event)) {
if(event.type == EV_KEY && event.value == 1) { // Touchscreen down/up
old_time = new_time;
new_time = event.time.tv_sec * 1000000 + event.time.tv_usec;
if((new_time - old_time < 200000) && // 200ms
(abs(sqrt(pow(old_x, 2) + pow(old_y, 2)) - sqrt(pow(new_x, 2) + pow(new_y, 2))) < 500)) {
mIsEnabled = false;
mCallback->postEvents(readEvents(), isWakeUpSensor());
}
} else if(event.type == EV_ABS) { // send order: touch pos x -> touch y -> down/up
if(event.code == ABS_MT_POSITION_X) {
old_x = new_x;
new_x = event.value;
} else if (event.code == ABS_MT_POSITION_Y) {
old_y = new_y;
new_y = event.value;
}
}
} else if (mPolls[0].revents == mPolls[0].events) {
readBool(mWaitPipeFd[0], false /* seek */);
}
}
}
}
void InputEventDT2WSensor::interruptPoll() {
if (mWaitPipeFd[1] < 0) return;
char c = '1';
write(mWaitPipeFd[1], &c, sizeof(c));
}
std::vector<Event> InputEventDT2WSensor::readEvents() {
std::vector<Event> events;
Event event;
event.sensorHandle = mSensorInfo.sensorHandle;
event.sensorType = mSensorInfo.type;
event.timestamp = ::android::elapsedRealtimeNano();
event.u.data[0] = 0;
event.u.data[1] = 0;
events.push_back(event);
return events;
}
} // namespace implementation
} // namespace subhal
} // namespace V2_1

29
sensors/Sensor.h
View File

@@ -17,12 +17,8 @@
#pragma once
#include <android/hardware/sensors/2.1/types.h>
#include <fcntl.h>
#include <poll.h>
#include <unistd.h>
#include <condition_variable>
#include <fstream>
#include <memory>
#include <mutex>
#include <thread>
@@ -92,31 +88,6 @@ class OneShotSensor : public Sensor {
virtual Result flush() override { return Result::BAD_VALUE; }
};
class InputEventDT2WSensor : public OneShotSensor {
public:
InputEventDT2WSensor(int32_t sensorHandle, ISensorsEventCallback* callback);
virtual ~InputEventDT2WSensor() override;
virtual void activate(bool enable) override;
virtual void activate(bool enable, bool notify, bool lock);
virtual void writeEnable(bool enable);
virtual void setOperationMode(OperationMode mode) override;
virtual std::vector<Event> readEvents() override;
virtual void fillEventData(Event& event);
protected:
virtual void run() override;
std::ofstream mGestureEnable;
private:
void interruptPoll();
struct pollfd mPolls[3];
int mWaitPipeFd[2];
int mPollFds[2];
};
} // namespace implementation
} // namespace subhal
} // namespace V2_1

4
sensors/SensorsSubHal.cpp
View File

@@ -32,9 +32,7 @@ namespace implementation {
using ::android::hardware::Void;
using ::android::hardware::sensors::V2_0::implementation::ScopedWakelock;
SensorsSubHal::SensorsSubHal() : mCallback(nullptr), mNextHandle(1) {
AddSensor<InputEventDT2WSensor>();
}
SensorsSubHal::SensorsSubHal() : mCallback(nullptr), mNextHandle(1) {}
Return<void> SensorsSubHal::getSensorsList_2_1(ISensors::getSensorsList_2_1_cb _hidl_cb) {
std::vector<SensorInfo> sensors;

2
sensors/hals.conf
View File

@@ -1,3 +1,3 @@
sensors.ssc.so
sensors.moto.so
sensors.eqs.so
sensors.dubai.so