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_EVENT_CONNECTION_H
18#define ANDROID_SENSOR_EVENT_CONNECTION_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/AndroidThreads.h>
28#include <utils/RefBase.h>
29#include <utils/Looper.h>
30#include <utils/String8.h>
31
32#include <binder/BinderService.h>
33
34#include <sensor/Sensor.h>
35#include <sensor/BitTube.h>
36#include <sensor/ISensorServer.h>
37#include <sensor/ISensorEventConnection.h>
38
39#include "SensorService.h"
40
41namespace android {
42
43class SensorService;
44
45class SensorService::SensorEventConnection:
46    public BnSensorEventConnection, public LooperCallback {
47
48    friend class SensorService;
49
50public:
51    SensorEventConnection(const sp<SensorService>& service, uid_t uid, String8 packageName,
52                          bool isDataInjectionMode, const String16& opPackageName);
53
54    status_t sendEvents(sensors_event_t const* buffer, size_t count, sensors_event_t* scratch,
55                        wp<const SensorEventConnection> const * mapFlushEventsToConnections = NULL);
56    bool hasSensor(int32_t handle) const;
57    bool hasAnySensor() const;
58    bool hasOneShotSensors() const;
59    bool addSensor(int32_t handle);
60    bool removeSensor(int32_t handle);
61    void setFirstFlushPending(int32_t handle, bool value);
62    void dump(String8& result);
63    bool needsWakeLock();
64    void resetWakeLockRefCount();
65    String8 getPackageName() const;
66
67    uid_t getUid() const { return mUid; }
68
69private:
70    virtual ~SensorEventConnection();
71    virtual void onFirstRef();
72    virtual sp<BitTube> getSensorChannel() const;
73    virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
74                                   nsecs_t maxBatchReportLatencyNs, int reservedFlags);
75    virtual status_t setEventRate(int handle, nsecs_t samplingPeriodNs);
76    virtual status_t flush();
77    virtual int32_t configureChannel(int handle, int rateLevel);
78
79    // Count the number of flush complete events which are about to be dropped in the buffer.
80    // Increment mPendingFlushEventsToSend in mSensorInfo. These flush complete events will be sent
81    // separately before the next batch of events.
82    void countFlushCompleteEventsLocked(sensors_event_t const* scratch, int numEventsDropped);
83
84    // Check if there are any wake up events in the buffer. If yes, return the index of the first
85    // wake_up sensor event in the buffer else return -1.  This wake_up sensor event will have the
86    // flag WAKE_UP_SENSOR_EVENT_NEEDS_ACK set. Exactly one event per packet will have the wake_up
87    // flag set. SOCK_SEQPACKET ensures that either the entire packet is read or dropped.
88    int findWakeUpSensorEventLocked(sensors_event_t const* scratch, int count);
89
90    // Send pending flush_complete events. There may have been flush_complete_events that are
91    // dropped which need to be sent separately before other events. On older HALs (1_0) this method
92    // emulates the behavior of flush().
93    void sendPendingFlushEventsLocked();
94
95    // Writes events from mEventCache to the socket.
96    void writeToSocketFromCache();
97
98    // Compute the approximate cache size from the FIFO sizes of various sensors registered for this
99    // connection. Wake up and non-wake up sensors have separate FIFOs but FIFO may be shared
100    // amongst wake-up sensors and non-wake up sensors.
101    int computeMaxCacheSizeLocked() const;
102
103    // When more sensors register, the maximum cache size desired may change.  Compute max cache
104    // size, reallocate memory and copy over events from the older cache.
105    void reAllocateCacheLocked(sensors_event_t const* scratch, int count);
106
107    // LooperCallback method. If there is data to read on this fd, it is an ack from the app that it
108    // has read events from a wake up sensor, decrement mWakeLockRefCount.  If this fd is available
109    // for writing send the data from the cache.
110    virtual int handleEvent(int fd, int events, void* data);
111
112    // Increment mPendingFlushEventsToSend for the given sensor handle.
113    void incrementPendingFlushCount(int32_t handle);
114
115    // Add or remove the file descriptor associated with the BitTube to the looper. If mDead is set
116    // to true or there are no more sensors for this connection, the file descriptor is removed if
117    // it has been previously added to the Looper. Depending on the state of the connection FD may
118    // be added to the Looper. The flags to set are determined by the internal state of the
119    // connection. FDs are added to the looper when wake-up sensors are registered (to poll for
120    // acknowledgements) and when write fails on the socket when there are too many error and the
121    // other end hangs up or when this client unregisters for this connection.
122    void updateLooperRegistration(const sp<Looper>& looper); void
123            updateLooperRegistrationLocked(const sp<Looper>& looper);
124
125    sp<SensorService> const mService;
126    sp<BitTube> mChannel;
127    uid_t mUid;
128    mutable Mutex mConnectionLock;
129    // Number of events from wake up sensors which are still pending and haven't been delivered to
130    // the corresponding application. It is incremented by one unit for each write to the socket.
131    uint32_t mWakeLockRefCount;
132
133    // If this flag is set to true, it means that the file descriptor associated with the BitTube
134    // has been added to the Looper in SensorService. This flag is typically set when this
135    // connection has wake-up sensors associated with it or when write has failed on this connection
136    // and we're storing some events in the cache.
137    bool mHasLooperCallbacks;
138    // If there are any errors associated with the Looper this flag is set to true and
139    // mWakeLockRefCount is reset to zero. needsWakeLock method will always return false, if this
140    // flag is set.
141    bool mDead;
142
143    bool mDataInjectionMode;
144    struct FlushInfo {
145        // The number of flush complete events dropped for this sensor is stored here.  They are
146        // sent separately before the next batch of events.
147        int mPendingFlushEventsToSend;
148
149        // Every activate is preceded by a flush. Only after the first flush complete is received,
150        // the events for the sensor are sent on that *connection*.
151        bool mFirstFlushPending;
152
153        FlushInfo() : mPendingFlushEventsToSend(0), mFirstFlushPending(false) {}
154    };
155    // protected by SensorService::mLock. Key for this vector is the sensor handle.
156    KeyedVector<int, FlushInfo> mSensorInfo;
157
158    sensors_event_t *mEventCache;
159    int mCacheSize, mMaxCacheSize;
160    String8 mPackageName;
161    const String16 mOpPackageName;
162#if DEBUG_CONNECTIONS
163    int mEventsReceived, mEventsSent, mEventsSentFromCache;
164    int mTotalAcksNeeded, mTotalAcksReceived;
165#endif
166
167};
168
169} // namepsace android
170
171#endif // ANDROID_SENSOR_EVENT_CONNECTION_H
172
173