Home | History | Annotate | Download | only in android 
      1 /*
      2  * Copyright (C) 2009 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 #define LOG_TAG "sensor"
     18 #include <utils/Log.h>
     19 
     20 #include <android/looper.h>
     21 #include <android/sensor.h>
     22 
     23 #include <utils/RefBase.h>
     24 #include <utils/Looper.h>
     25 #include <utils/Timers.h>
     26 
     27 #include <gui/Sensor.h>
     28 #include <gui/SensorManager.h>
     29 #include <gui/SensorEventQueue.h>
     30 
     31 #include <poll.h>
     32 
     33 using android::sp;
     34 using android::Sensor;
     35 using android::SensorManager;
     36 using android::SensorEventQueue;
     37 using android::String8;
     38 
     39 /*****************************************************************************/
     40 
     41 ASensorManager* ASensorManager_getInstance()
     42 {
     43     return &SensorManager::getInstance();
     44 }
     45 
     46 int ASensorManager_getSensorList(ASensorManager* manager,
     47         ASensorList* list)
     48 {
     49     Sensor const* const* l;
     50     int c = static_cast<SensorManager*>(manager)->getSensorList(&l);
     51     if (list) {
     52         *list = reinterpret_cast<ASensorList>(l);
     53     }
     54     return c;
     55 }
     56 
     57 ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type)
     58 {
     59     return static_cast<SensorManager*>(manager)->getDefaultSensor(type);
     60 }
     61 
     62 ASensorEventQueue* ASensorManager_createEventQueue(ASensorManager* manager,
     63         ALooper* looper, int ident, ALooper_callbackFunc callback, void* data)
     64 {
     65     sp<SensorEventQueue> queue =
     66             static_cast<SensorManager*>(manager)->createEventQueue();
     67     if (queue != 0) {
     68         ALooper_addFd(looper, queue->getFd(), ident, ALOOPER_EVENT_INPUT, callback, data);
     69         queue->looper = looper;
     70         queue->incStrong(manager);
     71     }
     72     return static_cast<ASensorEventQueue*>(queue.get());
     73 }
     74 
     75 int ASensorManager_destroyEventQueue(ASensorManager* manager,
     76         ASensorEventQueue* inQueue)
     77 {
     78     sp<SensorEventQueue> queue = static_cast<SensorEventQueue*>(inQueue);
     79     ALooper_removeFd(queue->looper, queue->getFd());
     80     queue->decStrong(manager);
     81     return 0;
     82 }
     83 
     84 /*****************************************************************************/
     85 
     86 int ASensorEventQueue_enableSensor(ASensorEventQueue* queue, ASensor const* sensor)
     87 {
     88     return static_cast<SensorEventQueue*>(queue)->enableSensor(
     89             static_cast<Sensor const*>(sensor));
     90 }
     91 
     92 int ASensorEventQueue_disableSensor(ASensorEventQueue* queue, ASensor const* sensor)
     93 {
     94     return static_cast<SensorEventQueue*>(queue)->disableSensor(
     95             static_cast<Sensor const*>(sensor));
     96 }
     97 
     98 int ASensorEventQueue_setEventRate(ASensorEventQueue* queue, ASensor const* sensor,
     99         int32_t usec)
    100 {
    101     return static_cast<SensorEventQueue*>(queue)->setEventRate(
    102             static_cast<Sensor const*>(sensor), us2ns(usec));
    103 }
    104 
    105 int ASensorEventQueue_hasEvents(ASensorEventQueue* queue)
    106 {
    107     struct pollfd pfd;
    108     pfd.fd = static_cast<SensorEventQueue*>(queue)->getFd();
    109     pfd.events = POLLIN;
    110     pfd.revents = 0;
    111 
    112     int nfd = poll(&pfd, 1, 0);
    113 
    114     if (nfd < 0)
    115         return -errno;
    116 
    117     if (pfd.revents != POLLIN)
    118         return -1;
    119 
    120     return (nfd == 0) ? 0 : 1;
    121 }
    122 
    123 ssize_t ASensorEventQueue_getEvents(ASensorEventQueue* queue,
    124                 ASensorEvent* events, size_t count)
    125 {
    126     return static_cast<SensorEventQueue*>(queue)->read(events, count);
    127 }
    128 
    129 
    130 /*****************************************************************************/
    131 
    132 const char* ASensor_getName(ASensor const* sensor)
    133 {
    134     return static_cast<Sensor const*>(sensor)->getName().string();
    135 }
    136 
    137 const char* ASensor_getVendor(ASensor const* sensor)
    138 {
    139     return static_cast<Sensor const*>(sensor)->getVendor().string();
    140 }
    141 
    142 int ASensor_getType(ASensor const* sensor)
    143 {
    144     return static_cast<Sensor const*>(sensor)->getType();
    145 }
    146 
    147 float ASensor_getResolution(ASensor const* sensor)
    148 {
    149     return static_cast<Sensor const*>(sensor)->getResolution();
    150 }
    151 
    152 int ASensor_getMinDelay(ASensor const* sensor)
    153 {
    154     return static_cast<Sensor const*>(sensor)->getMinDelay();
    155 }
    156