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    static const char* WAKE_LOCK_NAME;
     57 
     58             SensorService();
     59     virtual ~SensorService();
     60 
     61     virtual void onFirstRef();
     62 
     63     // Thread interface
     64     virtual bool threadLoop();
     65 
     66     // ISensorServer interface
     67     virtual Vector<Sensor> getSensorList();
     68     virtual sp<ISensorEventConnection> createSensorEventConnection();
     69     virtual status_t dump(int fd, const Vector<String16>& args);
     70 
     71 
     72     class SensorEventConnection : public BnSensorEventConnection {
     73         virtual ~SensorEventConnection();
     74         virtual void onFirstRef();
     75         virtual sp<BitTube> getSensorChannel() const;
     76         virtual status_t enableDisable(int handle, bool enabled);
     77         virtual status_t setEventRate(int handle, nsecs_t ns);
     78 
     79         sp<SensorService> const mService;
     80         sp<BitTube> const mChannel;
     81         uid_t mUid;
     82         mutable Mutex mConnectionLock;
     83 
     84         // protected by SensorService::mLock
     85         SortedVector<int> mSensorInfo;
     86 
     87     public:
     88         SensorEventConnection(const sp<SensorService>& service, uid_t uid);
     89 
     90         status_t sendEvents(sensors_event_t const* buffer, size_t count,
     91                 sensors_event_t* scratch = NULL);
     92         bool hasSensor(int32_t handle) const;
     93         bool hasAnySensor() const;
     94         bool addSensor(int32_t handle);
     95         bool removeSensor(int32_t handle);
     96 
     97         uid_t getUid() const { return mUid; }
     98     };
     99 
    100     class SensorRecord {
    101         SortedVector< wp<SensorEventConnection> > mConnections;
    102     public:
    103         SensorRecord(const sp<SensorEventConnection>& connection);
    104         bool addConnection(const sp<SensorEventConnection>& connection);
    105         bool removeConnection(const wp<SensorEventConnection>& connection);
    106         size_t getNumConnections() const { return mConnections.size(); }
    107     };
    108 
    109     SortedVector< wp<SensorEventConnection> > getActiveConnections() const;
    110     DefaultKeyedVector<int, SensorInterface*> getActiveVirtualSensors() const;
    111 
    112     String8 getSensorName(int handle) const;
    113     int getSensorType(int handle) const;
    114     void recordLastValue(sensors_event_t const * buffer, size_t count);
    115     static void sortEventBuffer(sensors_event_t* buffer, size_t count);
    116     void registerSensor(SensorInterface* sensor);
    117     void registerVirtualSensor(SensorInterface* sensor);
    118     status_t cleanupWithoutDisable(
    119             const sp<SensorEventConnection>& connection, int handle);
    120     status_t cleanupWithoutDisableLocked(
    121             const sp<SensorEventConnection>& connection, int handle);
    122     void cleanupAutoDisabledSensor(const sp<SensorEventConnection>& connection,
    123         sensors_event_t const* buffer, const int count);
    124 
    125     // constants
    126     Vector<Sensor> mSensorList;
    127     Vector<Sensor> mUserSensorListDebug;
    128     Vector<Sensor> mUserSensorList;
    129     DefaultKeyedVector<int, SensorInterface*> mSensorMap;
    130     Vector<SensorInterface *> mVirtualSensorList;
    131     status_t mInitCheck;
    132 
    133     // protected by mLock
    134     mutable Mutex mLock;
    135     DefaultKeyedVector<int, SensorRecord*> mActiveSensors;
    136     DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors;
    137     SortedVector< wp<SensorEventConnection> > mActiveConnections;
    138 
    139     // The size of this vector is constant, only the items are mutable
    140     KeyedVector<int32_t, sensors_event_t> mLastEventSeen;
    141 
    142 public:
    143     static char const* getServiceName() { return "sensorservice"; }
    144 
    145     void cleanupConnection(SensorEventConnection* connection);
    146     status_t enable(const sp<SensorEventConnection>& connection, int handle);
    147     status_t disable(const sp<SensorEventConnection>& connection, int handle);
    148     status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns);
    149 };
    150 
    151 // ---------------------------------------------------------------------------
    152 }; // namespace android
    153 
    154 #endif // ANDROID_SENSOR_SERVICE_H
    155