зеркало из https://github.com/mozilla/pjs.git
168 строки
3.7 KiB
C++
168 строки
3.7 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include <pthread.h>
|
|
#include <stdio.h>
|
|
|
|
#include "Hal.h"
|
|
#include "HalSensor.h"
|
|
#include "hardware/sensors.h"
|
|
#include "mozilla/Util.h"
|
|
#include "SensorDevice.h"
|
|
|
|
using namespace mozilla::hal;
|
|
using namespace android;
|
|
|
|
static SensorType
|
|
HardwareSensorToHalSensor(int type)
|
|
{
|
|
switch(type) {
|
|
case SENSOR_TYPE_ORIENTATION:
|
|
return SENSOR_ORIENTATION;
|
|
case SENSOR_TYPE_ACCELEROMETER:
|
|
return SENSOR_ACCELERATION;
|
|
case SENSOR_TYPE_PROXIMITY:
|
|
return SENSOR_PROXIMITY;
|
|
default:
|
|
return SENSOR_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
static int
|
|
HalSensorToHardwareSensor(SensorType type)
|
|
{
|
|
switch(type) {
|
|
case SENSOR_ORIENTATION:
|
|
return SENSOR_TYPE_ORIENTATION;
|
|
case SENSOR_ACCELERATION:
|
|
return SENSOR_TYPE_ACCELEROMETER;
|
|
case SENSOR_PROXIMITY:
|
|
return SENSOR_TYPE_PROXIMITY;
|
|
default:
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static bool
|
|
SensorseventToSensorData(const sensors_event_t& data, SensorData* aSensorData)
|
|
{
|
|
aSensorData->sensor() = HardwareSensorToHalSensor(data.type);
|
|
|
|
if (aSensorData->sensor() == SENSOR_UNKNOWN)
|
|
return false;
|
|
|
|
aSensorData->timestamp() = data.timestamp;
|
|
aSensorData->values()[0] = data.data[0];
|
|
aSensorData->values()[1] = data.data[1];
|
|
aSensorData->values()[2] = data.data[2];
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
onSensorChanged(const sensors_event_t& data, SensorData* aSensorData)
|
|
{
|
|
mozilla::DebugOnly<bool> convertedData = SensorseventToSensorData(data, aSensorData);
|
|
MOZ_ASSERT(convertedData);
|
|
NotifySensorChange(*aSensorData);
|
|
}
|
|
|
|
namespace mozilla {
|
|
namespace hal_impl {
|
|
|
|
static pthread_t sThread;
|
|
static bool sInitialized = false;
|
|
static bool sContinue = false;
|
|
static int sActivatedSensors = 0;
|
|
static SensorData sSensordata[NUM_SENSOR_TYPE];
|
|
|
|
static void*
|
|
UpdateSensorData(void* /*unused*/)
|
|
{
|
|
SensorDevice &device = SensorDevice::getInstance();
|
|
const size_t numEventMax = 16;
|
|
sensors_event_t buffer[numEventMax];
|
|
int count = 0;
|
|
|
|
while (sContinue) {
|
|
count = device.poll(buffer, numEventMax);
|
|
if (count < 0) {
|
|
continue;
|
|
}
|
|
|
|
for (int i=0; i<count; i++) {
|
|
onSensorChanged(buffer[i], &sSensordata[HardwareSensorToHalSensor(buffer[i].type)]);
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
InitialResources()
|
|
{
|
|
pthread_create(&sThread, NULL, &UpdateSensorData, NULL);
|
|
sInitialized = true;
|
|
sContinue = true;
|
|
}
|
|
|
|
static void
|
|
ReleaseResources()
|
|
{
|
|
sContinue = false;
|
|
pthread_join(sThread, NULL);
|
|
sInitialized = false;
|
|
}
|
|
|
|
static void
|
|
SensorSwitch(SensorType aSensor, bool activate)
|
|
{
|
|
int type = HalSensorToHardwareSensor(aSensor);
|
|
const sensor_t* sensors = NULL;
|
|
SensorDevice& device = SensorDevice::getInstance();
|
|
size_t size = device.getSensorList(&sensors);
|
|
|
|
for (size_t i=0; i<size; i++) {
|
|
if (sensors[i].type == type) {
|
|
device.activate((void*)pthread_self(), sensors[i].handle, activate);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
EnableSensorNotifications(SensorType aSensor)
|
|
{
|
|
if (!sInitialized) {
|
|
InitialResources();
|
|
}
|
|
|
|
SensorSwitch(aSensor, true);
|
|
sActivatedSensors++;
|
|
}
|
|
|
|
void
|
|
DisableSensorNotifications(SensorType aSensor)
|
|
{
|
|
if (!sInitialized) {
|
|
NS_WARNING("Disable sensors without initializing first");
|
|
return;
|
|
}
|
|
|
|
SensorSwitch(aSensor, false);
|
|
sActivatedSensors--;
|
|
|
|
if (!sActivatedSensors) {
|
|
ReleaseResources();
|
|
}
|
|
}
|
|
|
|
void
|
|
GetCurrentSensorDataInformation(SensorType aSensor, SensorData* aSensorData) {
|
|
*aSensorData = sSensordata[aSensor];
|
|
}
|
|
|
|
} // hal_impl
|
|
} // mozilla
|