Home | History | Annotate | Download | only in sensorservice 
      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 #ifndef ANDROID_SENSOR_SERVICE_H
     18 #define ANDROID_SENSOR_SERVICE_H
     19 
     20 #include <stdint.h>
     21 #include <sys/types.h>
     22 
     23 #include <utils/Vector.h>
     24 #include <utils/SortedVector.h>
     25 #include <utils/KeyedVector.h>
     26 #include <utils/threads.h>
     27 #include <utils/RefBase.h>
     28 
     29 #include <binder/BinderService.h>
     30 
     31 #include <gui/Sensor.h>
     32 #include <gui/BitTube.h>
     33 #include <gui/ISensorServer.h>
     34 #include <gui/ISensorEventConnection.h>
     35 
     36 #include "SensorInterface.h"
     37 
     38 // ---------------------------------------------------------------------------
     39 
     40 #define DEBUG_CONNECTIONS   false
     41 
     42 struct sensors_poll_device_t;
     43 struct sensors_module_t;
     44 
     45 namespace android {
     46 // ---------------------------------------------------------------------------
     47 
     48 class SensorService :
     49         public BinderService<SensorService>,
     50         public BnSensorServer,
     51         protected Thread
     52 {
     53    friend class BinderService<SensorService>;
     54 
     55    static const nsecs_t MINIMUM_EVENTS_PERIOD =   1000000; // 1000 Hz
     56 
     57             SensorService();
     58     virtual ~SensorService();
     59 
     60     virtual void onFirstRef();
     61 
     62     // Thread interface
     63     virtual bool threadLoop();
     64 
     65     // ISensorServer interface
     66     virtual Vector<Sensor> getSensorList();
     67     virtual sp<ISensorEventConnection> createSensorEventConnection();
     68     virtual status_t dump(int fd, const Vector<String16>& args);
     69 
     70 
     71     class SensorEventConnection : public BnSensorEventConnection {
     72         virtual ~SensorEventConnection();
     73         virtual void onFirstRef();
     74         virtual sp<BitTube> getSensorChannel() const;
     75         virtual status_t enableDisable(int handle, bool enabled);
     76         virtual status_t setEventRate(int handle, nsecs_t ns);
     77 
     78         sp<SensorService> const mService;
     79         sp<BitTube> const mChannel;
     80         mutable Mutex mConnectionLock;
     81 
     82         // protected by SensorService::mLock
     83         SortedVector<int> mSensorInfo;
     84 
     85     public:
     86         SensorEventConnection(const sp<SensorService>& service);
     87 
     88         status_t sendEvents(sensors_event_t const* buffer, size_t count,
     89                 sensors_event_t* scratch = NULL);
     90         bool hasSensor(int32_t handle) const;
     91         bool hasAnySensor() const;
     92         bool addSensor(int32_t handle);
     93         bool removeSensor(int32_t handle);
     94     };
     95 
     96     class SensorRecord {
     97         SortedVector< wp<SensorEventConnection> > mConnections;
     98     public:
     99         SensorRecord(const sp<SensorEventConnection>& connection);
    100         bool addConnection(const sp<SensorEventConnection>& connection);
    101         bool removeConnection(const wp<SensorEventConnection>& connection);
    102         size_t getNumConnections() const { return mConnections.size(); }
    103     };
    104 
    105     SortedVector< wp<SensorEventConnection> > getActiveConnections() const;
    106     DefaultKeyedVector<int, SensorInterface*> getActiveVirtualSensors() const;
    107 
    108     String8 getSensorName(int handle) const;
    109     void recordLastValue(sensors_event_t const * buffer, size_t count);
    110     static void sortEventBuffer(sensors_event_t* buffer, size_t count);
    111     void registerSensor(SensorInterface* sensor);
    112     void registerVirtualSensor(SensorInterface* sensor);
    113 
    114     // constants
    115     Vector<Sensor> mSensorList;
    116     Vector<Sensor> mUserSensorList;
    117     DefaultKeyedVector<int, SensorInterface*> mSensorMap;
    118     Vector<SensorInterface *> mVirtualSensorList;
    119     status_t mInitCheck;
    120 
    121     // protected by mLock
    122     mutable Mutex mLock;
    123     DefaultKeyedVector<int, SensorRecord*> mActiveSensors;
    124     DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors;
    125     SortedVector< wp<SensorEventConnection> > mActiveConnections;
    126 
    127     // The size of this vector is constant, only the items are mutable
    128     KeyedVector<int32_t, sensors_event_t> mLastEventSeen;
    129 
    130 public:
    131     static char const* getServiceName() { return "sensorservice"; }
    132 
    133     void cleanupConnection(SensorEventConnection* connection);
    134     status_t enable(const sp<SensorEventConnection>& connection, int handle);
    135     status_t disable(const sp<SensorEventConnection>& connection, int handle);
    136     status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns);
    137 };
    138 
    139 // ---------------------------------------------------------------------------
    140 }; // namespace android
    141 
    142 #endif // ANDROID_SENSOR_SERVICE_H
    143