common/sensors_example/sensors_hal.cpp

/*
 * Copyright (C) 2015 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.
 */

#include "sensors_hal.h"

#include <errno.h>
#include <string.h>

#include "example_sensors.h"

SensorContext::SensorContext(const hw_module_t* module) {
  memset(&device, 0, sizeof(device));

  device.common.tag = HARDWARE_DEVICE_TAG;
  device.common.version = SENSORS_DEVICE_API_VERSION_1_0;
  device.common.module = const_cast<hw_module_t*>(module);
  device.common.close = CloseWrapper;
  device.activate = ActivateWrapper;
  device.setDelay = SetDelayWrapper;
  device.poll = PollEventsWrapper;
  device.batch = BatchWrapper;
  device.flush = FlushWrapper;

  sensors[AvailableSensors::kAccelerometer] = new Accelerometer();
  sensors[AvailableSensors::kCustom] = new CustomSensor();
}

SensorContext::~SensorContext() {
  for (int i = 0; i < AvailableSensors::kNumSensors; i++) {
    if (sensors[i]) delete sensors[i];
  }
}

int SensorContext::activate(int handle, int enabled) {
  return sensors[handle]->activate(handle, enabled);
}

int SensorContext::setDelay(int handle, int64_t ns) {
  return sensors[handle]->setDelay(handle, ns);
}

int SensorContext::pollEvents(sensors_event_t* data, int count) {
  return sensors[0]->pollEvents(data, count);
}

int SensorContext::batch(int handle, int flags,
                         int64_t period_ns, int64_t timeout) {
  return sensors[handle]->batch(handle, flags, period_ns, timeout);
}

int SensorContext::flush(int handle) {
  return sensors[handle]->flush(handle);
}

// static
int SensorContext::CloseWrapper(hw_device_t* dev) {
  SensorContext* sensor_context = reinterpret_cast<SensorContext*>(dev);
  if (sensor_context) {
    delete sensor_context;
  }
  return 0;
}

// static
int SensorContext::ActivateWrapper(sensors_poll_device_t* dev,
                                   int handle, int enabled) {
  return reinterpret_cast<SensorContext*>(dev)->activate(handle, enabled);
}

// static
int SensorContext::SetDelayWrapper(sensors_poll_device_t* dev,
                                   int handle, int64_t ns) {
  return reinterpret_cast<SensorContext*>(dev)->setDelay(handle, ns);
}

// static
int SensorContext::PollEventsWrapper(sensors_poll_device_t* dev,
                                     sensors_event_t* data, int count) {
  return reinterpret_cast<SensorContext*>(dev)->pollEvents(data, count);
}

// static
int SensorContext::BatchWrapper(sensors_poll_device_1_t* dev, int handle,
                                int flags, int64_t period_ns, int64_t timeout) {
  return reinterpret_cast<SensorContext*>(dev)->batch(handle, flags, period_ns,
                                                      timeout);
}

// static
int SensorContext::FlushWrapper(sensors_poll_device_1_t* dev,
                                int handle) {
  return reinterpret_cast<SensorContext*>(dev)->flush(handle);
}


static int open_sensors(const struct hw_module_t* module,
                        const char* id, struct hw_device_t** device) {
  SensorContext* ctx = new SensorContext(module);
  *device = &ctx->device.common;

  return 0;
}

static struct hw_module_methods_t sensors_module_methods = {
  .open = open_sensors,
};

static struct sensor_t kSensorList[] = {
  { .name = "Broken Accelerometer",
    .vendor = "Unknown",
    .version = 1,
    .handle = SensorContext::AvailableSensors::kAccelerometer,
    .type = SENSOR_TYPE_ACCELEROMETER,
    .maxRange = static_cast<float>(Accelerometer::kMaxRange),
    .resolution = 100.0f,
    .power = 0.0f,
    .minDelay = 10000,
    .fifoReservedEventCount = 0,
    .fifoMaxEventCount = 0,
    .stringType = SENSOR_STRING_TYPE_ACCELEROMETER,
    .requiredPermission = "",
    .maxDelay = 0,
    .flags = SENSOR_FLAG_CONTINUOUS_MODE,
    .reserved = {},
  },
  { .name = "Custom Hour of Day Sensor",
    .vendor = "Unknown",
    .version = 1,
    .handle = SensorContext::AvailableSensors::kCustom,
    .type = SENSOR_TYPE_CUSTOM,
    .maxRange = 24.0f,
    .resolution = 1.0f,
    .power = 0.0f,
    .minDelay = 1,
    .fifoReservedEventCount = 0,
    .fifoMaxEventCount = 0,
    .stringType = SENSOR_STRING_TYPE_CUSTOM,
    .requiredPermission = "",
    .maxDelay = 0,
    .flags = SENSOR_FLAG_CONTINUOUS_MODE,
    .reserved = {},
  },
};

static int get_sensors_list(struct sensors_module_t* module,
                            struct sensor_t const** list) {
  if (!list) return 0;
  *list = kSensorList;
  return sizeof(kSensorList) / sizeof(kSensorList[0]);
}

struct sensors_module_t HAL_MODULE_INFO_SYM = {
    .common = {
        .tag = HARDWARE_MODULE_TAG,
        .version_major = 1,
        .version_minor = 0,
        .id = SENSORS_HARDWARE_MODULE_ID,
        .name = "Example Sensor Module",
        .author = "Google",
        .methods = &sensors_module_methods,
        .dso = NULL,
        .reserved = {0},
    },
    .get_sensors_list = get_sensors_list,
    .set_operation_mode = NULL
};