050b56244f
Exposed the new "min delay" sensor property through native and java sensor apis. This allows the caller to know what is the maximum rate at which a sensor can return events, or, if a sensor works in "update" mode (events returned only when the value changes). Also augmented SensorManager.regusterSensorEvent() so that it can accept a value in microsecond in addition to the 4 constants already defined. Change-Id: If425e9979892666df8c989d7de3c362230fa19e0
156 lines
4.2 KiB
C++
156 lines
4.2 KiB
C++
/*
|
|
* Copyright (C) 2009 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.
|
|
*/
|
|
|
|
#define LOG_TAG "sensor"
|
|
#include <utils/Log.h>
|
|
|
|
#include <android/looper.h>
|
|
#include <android/sensor.h>
|
|
|
|
#include <utils/RefBase.h>
|
|
#include <utils/PollLoop.h>
|
|
#include <utils/Timers.h>
|
|
|
|
#include <gui/Sensor.h>
|
|
#include <gui/SensorManager.h>
|
|
#include <gui/SensorEventQueue.h>
|
|
|
|
#include <poll.h>
|
|
|
|
using android::sp;
|
|
using android::Sensor;
|
|
using android::SensorManager;
|
|
using android::SensorEventQueue;
|
|
using android::String8;
|
|
|
|
/*****************************************************************************/
|
|
|
|
ASensorManager* ASensorManager_getInstance()
|
|
{
|
|
return &SensorManager::getInstance();
|
|
}
|
|
|
|
int ASensorManager_getSensorList(ASensorManager* manager,
|
|
ASensorList* list)
|
|
{
|
|
Sensor const* const* l;
|
|
int c = static_cast<SensorManager*>(manager)->getSensorList(&l);
|
|
if (list) {
|
|
*list = reinterpret_cast<ASensorList>(l);
|
|
}
|
|
return c;
|
|
}
|
|
|
|
ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type)
|
|
{
|
|
return static_cast<SensorManager*>(manager)->getDefaultSensor(type);
|
|
}
|
|
|
|
ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager,
|
|
ALooper* looper, ALooper_callbackFunc* callback, void* data)
|
|
{
|
|
sp<SensorEventQueue> queue =
|
|
static_cast<SensorManager*>(manager)->createEventQueue();
|
|
if (queue != 0) {
|
|
ALooper_addFd(looper, queue->getFd(), POLLIN, callback, data);
|
|
queue->looper = looper;
|
|
queue->incStrong(manager);
|
|
}
|
|
return static_cast<ASensorEventQueue*>(queue.get());
|
|
}
|
|
|
|
int ASensorManager_destroyEventQueue(ASensorManager* manager,
|
|
ASensorEventQueue* inQueue)
|
|
{
|
|
sp<SensorEventQueue> queue = static_cast<SensorEventQueue*>(inQueue);
|
|
ALooper_removeFd(queue->looper, queue->getFd());
|
|
queue->decStrong(manager);
|
|
return 0;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
int ASensorEventQueue_enableSensor(ASensorEventQueue* queue, ASensor const* sensor)
|
|
{
|
|
return static_cast<SensorEventQueue*>(queue)->enableSensor(
|
|
static_cast<Sensor const*>(sensor));
|
|
}
|
|
|
|
int ASensorEventQueue_disableSensor(ASensorEventQueue* queue, ASensor const* sensor)
|
|
{
|
|
return static_cast<SensorEventQueue*>(queue)->disableSensor(
|
|
static_cast<Sensor const*>(sensor));
|
|
}
|
|
|
|
int ASensorEventQueue_setEventRate(ASensorEventQueue* queue, ASensor const* sensor,
|
|
int32_t usec)
|
|
{
|
|
return static_cast<SensorEventQueue*>(queue)->setEventRate(
|
|
static_cast<Sensor const*>(sensor), us2ns(usec));
|
|
}
|
|
|
|
int ASensorEventQueue_hasEvents(ASensorEventQueue* queue)
|
|
{
|
|
struct pollfd pfd;
|
|
pfd.fd = static_cast<SensorEventQueue*>(queue)->getFd();
|
|
pfd.events = POLLIN;
|
|
pfd.revents = 0;
|
|
|
|
int nfd = poll(&pfd, 1, 0);
|
|
|
|
if (nfd < 0)
|
|
return -errno;
|
|
|
|
if (pfd.revents != POLLIN)
|
|
return -1;
|
|
|
|
return (nfd == 0) ? 0 : 1;
|
|
}
|
|
|
|
ssize_t ASensorEventQueue_getEvents(ASensorEventQueue* queue,
|
|
ASensorEvent* events, size_t count)
|
|
{
|
|
return static_cast<SensorEventQueue*>(queue)->read(events, count);
|
|
}
|
|
|
|
|
|
/*****************************************************************************/
|
|
|
|
const char* ASensor_getName(ASensor const* sensor)
|
|
{
|
|
return static_cast<Sensor const*>(sensor)->getName().string();
|
|
}
|
|
|
|
const char* ASensor_getVendor(ASensor const* sensor)
|
|
{
|
|
return static_cast<Sensor const*>(sensor)->getVendor().string();
|
|
}
|
|
|
|
int ASensor_getType(ASensor const* sensor)
|
|
{
|
|
return static_cast<Sensor const*>(sensor)->getType();
|
|
}
|
|
|
|
float ASensor_getResolution(ASensor const* sensor)
|
|
{
|
|
return static_cast<Sensor const*>(sensor)->getResolution();
|
|
}
|
|
|
|
int ASensor_getMinDelay(ASensor const* sensor)
|
|
{
|
|
return static_cast<Sensor const*>(sensor)->getMinDelay();
|
|
}
|