services/sensorservice/SensorDevice.cpp

   1 /*
   2  * Copyright (C) 2010 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdint.h>
  18 #include <math.h>
  19 #include <sys/types.h>
  20
  21 #include <utils/Atomic.h>
  22 #include <utils/Errors.h>
  23 #include <utils/Singleton.h>
  24
  25 #include <binder/BinderService.h>
  26 #include <binder/Parcel.h>
  27 #include <binder/IServiceManager.h>
  28
  29 #include <hardware/sensors.h>
  30
  31 #include "SensorDevice.h"
  32 #include "SensorService.h"
  33
  34 namespace android {
  35 // ---------------------------------------------------------------------------
  36
  37 ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)
  38
  39 SensorDevice::SensorDevice()
  40     :  mSensorDevice(0),
  41        mSensorModule(0)
  42 {
  43     status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
  44             (hw_module_t const**)&mSensorModule);
  45
  46     ALOGE_IF(err, "couldn't load %s module (%s)",
  47             SENSORS_HARDWARE_MODULE_ID, strerror(-err));
  48
  49     if (mSensorModule) {
  50         err = sensors_open(&mSensorModule->common, &mSensorDevice);
  51
  52         ALOGE_IF(err, "couldn't open device for module %s (%s)",
  53                 SENSORS_HARDWARE_MODULE_ID, strerror(-err));
  54
  55         if (mSensorDevice) {
  56             sensor_t const* list;
  57             ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
  58             mActivationCount.setCapacity(count);
  59             Info model;
  60             for (size_t i=0 ; i<size_t(count) ; i++) {
  61                 mActivationCount.add(list[i].handle, model);
  62                 mSensorDevice->activate(mSensorDevice, list[i].handle, 0);
  63             }
  64         }
  65     }
  66 }
  67
  68 void SensorDevice::dump(String8& result)
  69 {
  70     if (!mSensorModule) return;
  71     sensor_t const* list;
  72     ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
  73
  74     result.appendFormat("%d h/w sensors:\n", int(count));
  75
  76     Mutex::Autolock _l(mLock);
  77     for (size_t i=0 ; i<size_t(count) ; i++) {
  78         const Info& info = mActivationCount.valueFor(list[i].handle);
  79         result.appendFormat("handle=0x%08x, active-count=%d, rates(ms)={ ",
  80                 list[i].handle,
  81                 info.rates.size());
  82         for (size_t j=0 ; j<info.rates.size() ; j++) {
  83             result.appendFormat("%4.1f%s",
  84                     info.rates.valueAt(j) / 1e6f,
  85                     j<info.rates.size()-1 ? ", " : "");
  86         }
  87         result.appendFormat(" }, selected=%4.1f ms\n",  info.delay / 1e6f);
  88     }
  89 }
  90
  91 ssize_t SensorDevice::getSensorList(sensor_t const** list) {
  92     if (!mSensorModule) return NO_INIT;
  93     ssize_t count = mSensorModule->get_sensors_list(mSensorModule, list);
  94     return count;
  95 }
  96
  97 status_t SensorDevice::initCheck() const {
  98     return mSensorDevice && mSensorModule ? NO_ERROR : NO_INIT;
  99 }
 100
 101 ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
 102     if (!mSensorDevice) return NO_INIT;
 103     ssize_t c;
 104     do {
 105         c = mSensorDevice->poll(mSensorDevice, buffer, count);
 106     } while (c == -EINTR);
 107     return c;
 108 }
 109
 110 void SensorDevice::autoDisable(void *ident, int handle) {
 111     Info& info( mActivationCount.editValueFor(handle) );
 112     Mutex::Autolock _l(mLock);
 113     info.rates.removeItem(ident);
 114 }
 115
 116 status_t SensorDevice::activate(void* ident, int handle, int enabled)
 117 {
 118     if (!mSensorDevice) return NO_INIT;
 119     status_t err(NO_ERROR);
 120     bool actuateHardware = false;
 121
 122     Info& info( mActivationCount.editValueFor(handle) );
 123
 124
 125     ALOGD_IF(DEBUG_CONNECTIONS,
 126             "SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%d",
 127             ident, handle, enabled, info.rates.size());
 128
 129     if (enabled) {
 130         Mutex::Autolock _l(mLock);
 131         ALOGD_IF(DEBUG_CONNECTIONS, "... index=%ld",
 132                 info.rates.indexOfKey(ident));
 133
 134         if (info.rates.indexOfKey(ident) < 0) {
 135             info.rates.add(ident, DEFAULT_EVENTS_PERIOD);
 136             if (info.rates.size() == 1) {
 137                 actuateHardware = true;
 138             }
 139         } else {
 140             // sensor was already activated for this ident
 141         }
 142     } else {
 143         Mutex::Autolock _l(mLock);
 144         ALOGD_IF(DEBUG_CONNECTIONS, "... index=%ld",
 145                 info.rates.indexOfKey(ident));
 146
 147         ssize_t idx = info.rates.removeItem(ident);
 148         if (idx >= 0) {
 149             if (info.rates.size() == 0) {
 150                 actuateHardware = true;
 151             }
 152         } else {
 153             // sensor wasn't enabled for this ident
 154         }
 155     }
 156
 157     if (actuateHardware) {
 158         ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w");
 159
 160         err = mSensorDevice->activate(mSensorDevice, handle, enabled);
 161         ALOGE_IF(err, "Error %s sensor %d (%s)",
 162                 enabled ? "activating" : "disabling",
 163                 handle, strerror(-err));
 164
 165         if (err != NO_ERROR) {
 166             // clean-up on failure
 167             if (enabled) {
 168                 // failure when enabling the sensor
 169                 Mutex::Autolock _l(mLock);
 170                 info.rates.removeItem(ident);
 171             }
 172         }
 173     }
 174
 175     { // scope for the lock
 176         Mutex::Autolock _l(mLock);
 177         nsecs_t ns = info.selectDelay();
 178         mSensorDevice->setDelay(mSensorDevice, handle, ns);
 179     }
 180
 181     return err;
 182 }
 183
 184 status_t SensorDevice::setDelay(void* ident, int handle, int64_t ns)
 185 {
 186     if (!mSensorDevice) return NO_INIT;
 187     Mutex::Autolock _l(mLock);
 188     Info& info( mActivationCount.editValueFor(handle) );
 189     status_t err = info.setDelayForIdent(ident, ns);
 190     if (err < 0) return err;
 191     ns = info.selectDelay();
 192     return mSensorDevice->setDelay(mSensorDevice, handle, ns);
 193 }
 194
 195 int SensorDevice::getHalDeviceVersion() const {
 196     if (!mSensorDevice) return -1;
 197
 198     return mSensorDevice->common.version;
 199 }
 200
 201 // ---------------------------------------------------------------------------
 202
 203 status_t SensorDevice::Info::setDelayForIdent(void* ident, int64_t ns)
 204 {
 205     ssize_t index = rates.indexOfKey(ident);
 206     if (index < 0) {
 207         ALOGE("Info::setDelayForIdent(ident=%p, ns=%lld) failed (%s)",
 208                 ident, ns, strerror(-index));
 209         return BAD_INDEX;
 210     }
 211     rates.editValueAt(index) = ns;
 212     return NO_ERROR;
 213 }
 214
 215 nsecs_t SensorDevice::Info::selectDelay()
 216 {
 217     nsecs_t ns = rates.valueAt(0);
 218     for (size_t i=1 ; i<rates.size() ; i++) {
 219         nsecs_t cur = rates.valueAt(i);
 220         if (cur < ns) {
 221             ns = cur;
 222         }
 223     }
 224     delay = ns;
 225     return ns;
 226 }
 227
 228 // ---------------------------------------------------------------------------
 229 }; // namespace android
 230