LineageOS/android_device_google_contexthub
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "activity_hal: move static class methods to free functions" into nyc-mr1-dev

Browse Source
This commit is contained in:
Andrew Rossignol
2016-07-06 22:33:19 +00:00
committed by Android (Google) Code Review
parent 87cd6d9d69 4594a90716
commit 759d604909
3 changed files with 72 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
sensorhal/activity.cpp
View File

@@ -39,9 +39,52 @@ static const char *const kActivityList[] = {
ACTIVITY_TYPE_TILTING
};
static int ActivityClose(struct hw_device_t *dev) {
ActivityContext *context = reinterpret_cast<ActivityContext *>(dev);
delete context;
return 0;
}
static void RegisterActivityCallbackWrapper(
const struct activity_recognition_device *dev,
const activity_recognition_callback_procs_t *callback) {
const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))
->registerActivityCallback(callback);
}
static int EnableActivityEventWrapper(
const struct activity_recognition_device *dev,
uint32_t activity_handle,
uint32_t event_type,
int64_t max_batch_report_latency_ns) {
return const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))
->enableActivityEvent(
activity_handle, event_type, max_batch_report_latency_ns);
}
static int DisableActivityEventWrapper(
const struct activity_recognition_device *dev,
uint32_t activity_handle,
uint32_t event_type) {
return const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))
->disableActivityEvent(activity_handle, event_type);
}
static int FlushWrapper(const struct activity_recognition_device *dev) {
return const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))->flush();
}
static void HubCallbackWrapper(
void *me, uint64_t time_ms, bool is_flush, float x, float y, float z) {
static_cast<ActivityContext *>(me)->onActivityEvent(time_ms, is_flush, x, y, z);
}
ActivityContext::ActivityContext(const struct hw_module_t *module)
: mHubConnection(HubConnection::getInstance()),
mHubAlive(true),
mCallback(NULL),
mPrevActivity(-1),
mInitExitDone(false) {
@@ -50,23 +93,19 @@ ActivityContext::ActivityContext(const struct hw_module_t *module)
device.common.tag = HARDWARE_DEVICE_TAG;
device.common.version = ACTIVITY_RECOGNITION_API_VERSION_0_1;
device.common.module = const_cast<hw_module_t *>(module);
device.common.close = CloseWrapper;
device.common.close = ActivityClose;
device.register_activity_callback = RegisterActivityCallbackWrapper;
device.enable_activity_event = EnableActivityEventWrapper;
device.disable_activity_event = DisableActivityEventWrapper;
device.flush = FlushWrapper;
if (mHubConnection->initCheck() != (status_t)OK) {
mHubAlive = false;
} else {
if (mHubConnection->getAliveCheck() != (status_t)OK) {
mHubAlive = false;
} else {
mHubConnection->setActivityCallback(
this, &ActivityContext::HubCallbackWrapper);
mHubAlive = (mHubConnection->initCheck() == OK
&& mHubConnection->getAliveCheck() == OK);
mHubConnection->queueActivate(COMMS_SENSOR_ACTIVITY, false /* enable */);
}
if (mHubAlive) {
mHubConnection->setActivityCallback(this, &HubCallbackWrapper);
mHubConnection->queueActivate(
COMMS_SENSOR_ACTIVITY, false /* enable */);
}
}
@@ -74,17 +113,9 @@ ActivityContext::~ActivityContext() {
mHubConnection->setActivityCallback(NULL, NULL);
}
int ActivityContext::close() {
ALOGI("close");
delete this;
return 0;
}
void ActivityContext::onActivityEvent(
uint64_t when_us, bool is_flush, float x, float, float) {
Mutex::Autolock autoLock(mLock);
Mutex::Autolock autoLock(mCallbackLock);
if (!mCallback) {
return;
@@ -186,7 +217,7 @@ void ActivityContext::registerActivityCallback(
const activity_recognition_callback_procs_t *callback) {
ALOGI("registerActivityCallback");
Mutex::Autolock autoLock(mLock);
Mutex::Autolock autoLock(mCallbackLock);
mCallback = callback;
}
@@ -261,55 +292,6 @@ int ActivityContext::flush() {
return 0;
}
// static
int ActivityContext::CloseWrapper(struct hw_device_t *dev) {
return reinterpret_cast<ActivityContext *>(dev)->close();
}
// static
void ActivityContext::RegisterActivityCallbackWrapper(
const struct activity_recognition_device *dev,
const activity_recognition_callback_procs_t *callback) {
const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))
->registerActivityCallback(callback);
}
// static
int ActivityContext::EnableActivityEventWrapper(
const struct activity_recognition_device *dev,
uint32_t activity_handle,
uint32_t event_type,
int64_t max_batch_report_latency_ns) {
return const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))
->enableActivityEvent(
activity_handle, event_type, max_batch_report_latency_ns);
}
// static
int ActivityContext::DisableActivityEventWrapper(
const struct activity_recognition_device *dev,
uint32_t activity_handle,
uint32_t event_type) {
return const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))
->disableActivityEvent(activity_handle, event_type);
}
// static
int ActivityContext::FlushWrapper(
const struct activity_recognition_device *dev) {
return const_cast<ActivityContext *>(
reinterpret_cast<const ActivityContext *>(dev))->flush();
}
// static
void ActivityContext::HubCallbackWrapper(
void *me, uint64_t time_ms, bool is_flush, float x, float y, float z) {
static_cast<ActivityContext *>(me)->onActivityEvent(time_ms, is_flush, x, y, z);
}
bool ActivityContext::getHubAlive() {
return mHubAlive;
}
@@ -364,4 +346,3 @@ struct activity_recognition_module HAL_MODULE_INFO_SYM = {
},
.get_supported_activities_list = get_activity_list,
};

63
sensorhal/activity.h
View File

@@ -26,73 +26,46 @@
#define DEBUG_ACTIVITY_RECOGNITION 0
struct ActivityContext {
class ActivityContext {
public:
activity_recognition_device_t device;
explicit ActivityContext(const struct hw_module_t *module);
~ActivityContext();
void onActivityEvent(
uint64_t when_us, bool is_flush, float x, float y, float z);
bool getHubAlive();
private:
android::Mutex mLock;
void registerActivityCallback(
const activity_recognition_callback_procs_t *callback);
bool isEnabled(uint32_t activity_handle, uint32_t event_type) const;
int enableActivityEvent(uint32_t activity_handle,
uint32_t event_type, int64_t max_batch_report_latency_ns);
int disableActivityEvent(uint32_t activity_handle, uint32_t event_type);
int flush();
private:
android::sp<android::HubConnection> mHubConnection;
bool mHubAlive;
android::Mutex mCallbackLock;
const activity_recognition_callback_procs_t *mCallback;
bool mHubAlive;
android::KeyedVector<uint64_t, int64_t> mMaxBatchReportLatencyNs;
int mPrevActivity;
bool mInitExitDone;
~ActivityContext();
int close();
void registerActivityCallback(
const activity_recognition_callback_procs_t *callback);
bool isEnabled(uint32_t activity_handle, uint32_t event_type) const;
int enableActivityEvent(
uint32_t activity_handle,
uint32_t event_type,
int64_t max_batch_report_latency_ns);
int disableActivityEvent(uint32_t activity_handle, uint32_t event_type);
int flush();
int64_t calculateReportLatencyNs();
static int CloseWrapper(struct hw_device_t *dev);
static void RegisterActivityCallbackWrapper(
const struct activity_recognition_device *dev,
const activity_recognition_callback_procs_t *callback);
static int EnableActivityEventWrapper(
const struct activity_recognition_device *dev,
uint32_t activity_handle,
uint32_t event_type,
int64_t max_batch_report_latency_ns);
static int DisableActivityEventWrapper(
const struct activity_recognition_device *dev,
uint32_t activity_handle,
uint32_t event_type);
static int FlushWrapper(const struct activity_recognition_device *dev);
static void HubCallbackWrapper(
void *me, uint64_t time_ms, bool is_flush, float x, float y, float z);
DISALLOW_EVIL_CONSTRUCTORS(ActivityContext);
};

2
sensorhal/sensors.cpp
View File

@@ -32,7 +32,7 @@ using namespace android;
////////////////////////////////////////////////////////////////////////////////
SensorContext::SensorContext(const struct hw_module_t *module)
: mHubConnection(HubConnection::getInstance()), mHubAlive(true) {
: mHubConnection(HubConnection::getInstance()) {
memset(&device, 0, sizeof(device));
device.common.tag = HARDWARE_DEVICE_TAG;