SensorService.h revision 4369a4ebd5ae7567e7075bc82830b83178099ed5 
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
45struct sensors_poll_device_t;
46struct sensors_module_t;
47
48namespace android {
49// ---------------------------------------------------------------------------
50
51class SensorService :
52        public BinderService<SensorService>,
53        public BnSensorServer,
54        protected Thread
55{
56    friend class BinderService<SensorService>;
57
58    static const char* WAKE_LOCK_NAME;
59
60    static char const* getServiceName() ANDROID_API { return "sensorservice"; }
61    SensorService() ANDROID_API;
62    virtual ~SensorService();
63
64    virtual void onFirstRef();
65
66    // Thread interface
67    virtual bool threadLoop();
68
69    // ISensorServer interface
70    virtual Vector<Sensor> getSensorList();
71    virtual sp<ISensorEventConnection> createSensorEventConnection();
72    virtual status_t dump(int fd, const Vector<String16>& args);
73
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        // Count the number of flush complete events which are about to be dropped in the buffer.
84        // Increment mPendingFlushEventsToSend in mSensorInfo. These flush complete events will be
85        // sent separately before the next batch of events.
86        void countFlushCompleteEventsLocked(sensors_event_t* scratch, int numEventsDropped);
87
88        sp<SensorService> const mService;
89        sp<BitTube> mChannel;
90        uid_t mUid;
91        mutable Mutex mConnectionLock;
92
93        struct FlushInfo {
94            // The number of flush complete events dropped for this sensor is stored here.
95            // They are sent separately before the next batch of events.
96            int mPendingFlushEventsToSend;
97            // Every activate is preceded by a flush. Only after the first flush complete is
98            // received, the events for the sensor are sent on that *connection*.
99            bool mFirstFlushPending;
100            FlushInfo() : mPendingFlushEventsToSend(0), mFirstFlushPending(false) {}
101        };
102        // protected by SensorService::mLock. Key for this vector is the sensor handle.
103        KeyedVector<int, FlushInfo> mSensorInfo;
104
105    public:
106        SensorEventConnection(const sp<SensorService>& service, uid_t uid);
107
108        status_t sendEvents(sensors_event_t const* buffer, size_t count,
109                sensors_event_t* scratch = NULL);
110        bool hasSensor(int32_t handle) const;
111        bool hasAnySensor() const;
112        bool addSensor(int32_t handle);
113        bool removeSensor(int32_t handle);
114        void setFirstFlushPending(int32_t handle, bool value);
115        void dump(String8& result);
116
117        uid_t getUid() const { return mUid; }
118    };
119
120    class SensorRecord {
121        SortedVector< wp<SensorEventConnection> > mConnections;
122    public:
123        SensorRecord(const sp<SensorEventConnection>& connection);
124        bool addConnection(const sp<SensorEventConnection>& connection);
125        bool removeConnection(const wp<SensorEventConnection>& connection);
126        size_t getNumConnections() const { return mConnections.size(); }
127    };
128
129    SortedVector< wp<SensorEventConnection> > getActiveConnections() const;
130    DefaultKeyedVector<int, SensorInterface*> getActiveVirtualSensors() const;
131
132    String8 getSensorName(int handle) const;
133    bool isVirtualSensor(int handle) const;
134    void recordLastValue(const sensors_event_t* buffer, size_t count);
135    static void sortEventBuffer(sensors_event_t* buffer, size_t count);
136    Sensor registerSensor(SensorInterface* sensor);
137    Sensor registerVirtualSensor(SensorInterface* sensor);
138    status_t cleanupWithoutDisable(
139            const sp<SensorEventConnection>& connection, int handle);
140    status_t cleanupWithoutDisableLocked(
141            const sp<SensorEventConnection>& connection, int handle);
142    void cleanupAutoDisabledSensor(const sp<SensorEventConnection>& connection,
143            sensors_event_t const* buffer, const int count);
144
145    // constants
146    Vector<Sensor> mSensorList;
147    Vector<Sensor> mUserSensorListDebug;
148    Vector<Sensor> mUserSensorList;
149    DefaultKeyedVector<int, SensorInterface*> mSensorMap;
150    Vector<SensorInterface *> mVirtualSensorList;
151    status_t mInitCheck;
152    size_t mSocketBufferSize;
153
154    // protected by mLock
155    mutable Mutex mLock;
156    DefaultKeyedVector<int, SensorRecord*> mActiveSensors;
157    DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors;
158    SortedVector< wp<SensorEventConnection> > mActiveConnections;
159
160    // The size of this vector is constant, only the items are mutable
161    KeyedVector<int32_t, sensors_event_t> mLastEventSeen;
162
163public:
164    void cleanupConnection(SensorEventConnection* connection);
165    status_t enable(const sp<SensorEventConnection>& connection, int handle,
166                    nsecs_t samplingPeriodNs,  nsecs_t maxBatchReportLatencyNs, int reservedFlags);
167    status_t disable(const sp<SensorEventConnection>& connection, int handle);
168    status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns);
169    status_t flushSensor(const sp<SensorEventConnection>& connection, int handle);
170};
171
172// ---------------------------------------------------------------------------
173}; // namespace android
174
175#endif // ANDROID_SENSOR_SERVICE_H
176