SensorService.h revision 9a844cf78f09953145200b4074d47589257a408c
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// Max size is 1 MB which is enough to accept a batch of about 10k events. 42#define MAX_SOCKET_BUFFER_SIZE_BATCHED 1024 * 1024 43#define SOCKET_BUFFER_SIZE_NON_BATCHED 4 * 1024 44#define WAKE_UP_SENSOR_EVENT_NEEDS_ACK (1 << 31) 45 46struct sensors_poll_device_t; 47struct sensors_module_t; 48 49namespace android { 50// --------------------------------------------------------------------------- 51 52class SensorService : 53 public BinderService<SensorService>, 54 public BnSensorServer, 55 protected Thread 56{ 57 friend class BinderService<SensorService>; 58 59 static const char* WAKE_LOCK_NAME; 60 61 static char const* getServiceName() ANDROID_API { return "sensorservice"; } 62 SensorService() ANDROID_API; 63 virtual ~SensorService(); 64 65 virtual void onFirstRef(); 66 67 // Thread interface 68 virtual bool threadLoop(); 69 70 // ISensorServer interface 71 virtual Vector<Sensor> getSensorList(); 72 virtual sp<ISensorEventConnection> createSensorEventConnection(); 73 virtual status_t dump(int fd, const Vector<String16>& args); 74 75 class SensorEventConnection : public BnSensorEventConnection { 76 virtual ~SensorEventConnection(); 77 virtual void onFirstRef(); 78 virtual sp<BitTube> getSensorChannel() const; 79 virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs, 80 nsecs_t maxBatchReportLatencyNs, int reservedFlags); 81 virtual status_t setEventRate(int handle, nsecs_t samplingPeriodNs); 82 virtual status_t flush(); 83 void decreaseWakeLockRefCount(); 84 // Count the number of flush complete events which are about to be dropped in the buffer. 85 // Increment mPendingFlushEventsToSend in mSensorInfo. These flush complete events will be 86 // sent separately before the next batch of events. 87 void countFlushCompleteEventsLocked(sensors_event_t* scratch, int numEventsDropped); 88 89 // Check if there are any wake up events in the buffer. If yes, increment the ref count. 90 // Increment it by exactly one unit for each packet sent on the socket. SOCK_SEQPACKET for 91 // the socket ensures that either the entire packet is read or dropped. 92 // Return 1 if mWakeLockRefCount has been incremented, zero if not. 93 int countWakeUpSensorEventsLocked(sensors_event_t* scratch, const int count); 94 95 sp<SensorService> const mService; 96 sp<BitTube> mChannel; 97 uid_t mUid; 98 mutable Mutex mConnectionLock; 99 // Number of events from wake up sensors which are still pending and haven't been delivered 100 // to the corresponding application. It is incremented by one unit for each write to the 101 // socket. 102 int mWakeLockRefCount; 103 104 struct FlushInfo { 105 // The number of flush complete events dropped for this sensor is stored here. 106 // They are sent separately before the next batch of events. 107 int mPendingFlushEventsToSend; 108 // Every activate is preceded by a flush. Only after the first flush complete is 109 // received, the events for the sensor are sent on that *connection*. 110 bool mFirstFlushPending; 111 FlushInfo() : mPendingFlushEventsToSend(0), mFirstFlushPending(false) {} 112 }; 113 // protected by SensorService::mLock. Key for this vector is the sensor handle. 114 KeyedVector<int, FlushInfo> mSensorInfo; 115 116 public: 117 SensorEventConnection(const sp<SensorService>& service, uid_t uid); 118 119 status_t sendEvents(sensors_event_t const* buffer, size_t count, 120 sensors_event_t* scratch); 121 bool hasSensor(int32_t handle) const; 122 bool hasAnySensor() const; 123 bool addSensor(int32_t handle); 124 bool removeSensor(int32_t handle); 125 void setFirstFlushPending(int32_t handle, bool value); 126 void dump(String8& result); 127 bool needsWakeLock(); 128 129 uid_t getUid() const { return mUid; } 130 }; 131 132 class SensorRecord { 133 SortedVector< wp<SensorEventConnection> > mConnections; 134 public: 135 SensorRecord(const sp<SensorEventConnection>& connection); 136 bool addConnection(const sp<SensorEventConnection>& connection); 137 bool removeConnection(const wp<SensorEventConnection>& connection); 138 size_t getNumConnections() const { return mConnections.size(); } 139 }; 140 141 String8 getSensorName(int handle) const; 142 bool isVirtualSensor(int handle) const; 143 Sensor getSensorFromHandle(int handle) const; 144 bool isWakeUpSensor(int type) const; 145 void recordLastValueLocked(const sensors_event_t* buffer, size_t count); 146 static void sortEventBuffer(sensors_event_t* buffer, size_t count); 147 Sensor registerSensor(SensorInterface* sensor); 148 Sensor registerVirtualSensor(SensorInterface* sensor); 149 status_t cleanupWithoutDisable( 150 const sp<SensorEventConnection>& connection, int handle); 151 status_t cleanupWithoutDisableLocked( 152 const sp<SensorEventConnection>& connection, int handle); 153 void cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection, 154 sensors_event_t const* buffer, const int count); 155 static bool canAccessSensor(const Sensor& sensor); 156 static bool verifyCanAccessSensor(const Sensor& sensor, const char* operation); 157 // SensorService acquires a partial wakelock for delivering events from wake up sensors. This 158 // method checks whether all the events from these wake up sensors have been delivered to the 159 // corresponding applications, if yes the wakelock is released. 160 void checkWakeLockState(); 161 void checkWakeLockStateLocked(); 162 bool isWakeUpSensorEvent(const sensors_event_t& event) const; 163 // constants 164 Vector<Sensor> mSensorList; 165 Vector<Sensor> mUserSensorListDebug; 166 Vector<Sensor> mUserSensorList; 167 DefaultKeyedVector<int, SensorInterface*> mSensorMap; 168 Vector<SensorInterface *> mVirtualSensorList; 169 status_t mInitCheck; 170 size_t mSocketBufferSize; 171 172 // protected by mLock 173 mutable Mutex mLock; 174 DefaultKeyedVector<int, SensorRecord*> mActiveSensors; 175 DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors; 176 SortedVector< wp<SensorEventConnection> > mActiveConnections; 177 bool mWakeLockAcquired; 178 179 // The size of this vector is constant, only the items are mutable 180 KeyedVector<int32_t, sensors_event_t> mLastEventSeen; 181 182public: 183 void cleanupConnection(SensorEventConnection* connection); 184 status_t enable(const sp<SensorEventConnection>& connection, int handle, 185 nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags); 186 status_t disable(const sp<SensorEventConnection>& connection, int handle); 187 status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns); 188 status_t flushSensor(const sp<SensorEventConnection>& connection, int handle); 189}; 190 191// --------------------------------------------------------------------------- 192}; // namespace android 193 194#endif // ANDROID_SENSOR_SERVICE_H 195