1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_SENSOR_EVENT_CONNECTION_H
#define ANDROID_SENSOR_EVENT_CONNECTION_H
#include <stdint.h>
#include <sys/types.h>
#include <unordered_map>
#include <utils/Vector.h>
#include <utils/SortedVector.h>
#include <utils/threads.h>
#include <utils/AndroidThreads.h>
#include <utils/RefBase.h>
#include <utils/Looper.h>
#include <utils/String8.h>
#include <binder/BinderService.h>
#include <sensor/Sensor.h>
#include <sensor/BitTube.h>
#include <sensor/ISensorServer.h>
#include <sensor/ISensorEventConnection.h>
#include "SensorService.h"
namespace android {
class SensorService;
class SensorService::SensorEventConnection:
public BnSensorEventConnection, public LooperCallback {
friend class SensorService;
public:
SensorEventConnection(const sp<SensorService>& service, uid_t uid, String8 packageName,
bool isDataInjectionMode, const String16& opPackageName);
status_t sendEvents(sensors_event_t const* buffer, size_t count, sensors_event_t* scratch,
wp<const SensorEventConnection> const * mapFlushEventsToConnections = nullptr);
bool hasSensor(int32_t handle) const;
bool hasAnySensor() const;
bool hasOneShotSensors() const;
bool addSensor(int32_t handle);
bool removeSensor(int32_t handle);
std::vector<int32_t> getActiveSensorHandles() const;
void setFirstFlushPending(int32_t handle, bool value);
void dump(String8& result);
void dump(util::ProtoOutputStream* proto) const;
bool needsWakeLock();
void resetWakeLockRefCount();
String8 getPackageName() const;
uid_t getUid() const { return mUid; }
private:
virtual ~SensorEventConnection();
virtual void onFirstRef();
virtual sp<BitTube> getSensorChannel() const;
virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
nsecs_t maxBatchReportLatencyNs, int reservedFlags);
virtual status_t setEventRate(int handle, nsecs_t samplingPeriodNs);
virtual status_t flush();
virtual int32_t configureChannel(int handle, int rateLevel);
virtual void destroy();
// Count the number of flush complete events which are about to be dropped in the buffer.
// Increment mPendingFlushEventsToSend in mSensorInfo. These flush complete events will be sent
// separately before the next batch of events.
void countFlushCompleteEventsLocked(sensors_event_t const* scratch, int numEventsDropped);
// Check if there are any wake up events in the buffer. If yes, return the index of the first
// wake_up sensor event in the buffer else return -1. This wake_up sensor event will have the
// flag WAKE_UP_SENSOR_EVENT_NEEDS_ACK set. Exactly one event per packet will have the wake_up
// flag set. SOCK_SEQPACKET ensures that either the entire packet is read or dropped.
int findWakeUpSensorEventLocked(sensors_event_t const* scratch, int count);
// Send pending flush_complete events. There may have been flush_complete_events that are
// dropped which need to be sent separately before other events. On older HALs (1_0) this method
// emulates the behavior of flush().
void sendPendingFlushEventsLocked();
// Writes events from mEventCache to the socket.
void writeToSocketFromCache();
// Compute the approximate cache size from the FIFO sizes of various sensors registered for this
// connection. Wake up and non-wake up sensors have separate FIFOs but FIFO may be shared
// amongst wake-up sensors and non-wake up sensors.
int computeMaxCacheSizeLocked() const;
// When more sensors register, the maximum cache size desired may change. Compute max cache
// size, reallocate memory and copy over events from the older cache.
void reAllocateCacheLocked(sensors_event_t const* scratch, int count);
// Add the events to the cache. If the cache would be exceeded, drop events at the beginning of
// the cache.
void appendEventsToCacheLocked(sensors_event_t const* events, int count);
// LooperCallback method. If there is data to read on this fd, it is an ack from the app that it
// has read events from a wake up sensor, decrement mWakeLockRefCount. If this fd is available
// for writing send the data from the cache.
virtual int handleEvent(int fd, int events, void* data);
// Increment mPendingFlushEventsToSend for the given handle if the connection has sensor access.
// Returns true if this connection does have sensor access.
bool incrementPendingFlushCountIfHasAccess(int32_t handle);
// Add or remove the file descriptor associated with the BitTube to the looper. If mDead is set
// to true or there are no more sensors for this connection, the file descriptor is removed if
// it has been previously added to the Looper. Depending on the state of the connection FD may
// be added to the Looper. The flags to set are determined by the internal state of the
// connection. FDs are added to the looper when wake-up sensors are registered (to poll for
// acknowledgements) and when write fails on the socket when there are too many error and the
// other end hangs up or when this client unregisters for this connection.
void updateLooperRegistration(const sp<Looper>& looper); void
updateLooperRegistrationLocked(const sp<Looper>& looper);
// Returns whether sensor access is available based on both the uid being active and sensor
// privacy not being enabled.
bool hasSensorAccess();
// Call noteOp for the sensor if the sensor requires a permission
bool noteOpIfRequired(const sensors_event_t& event);
sp<SensorService> const mService;
sp<BitTube> mChannel;
uid_t mUid;
mutable Mutex mConnectionLock;
// Number of events from wake up sensors which are still pending and haven't been delivered to
// the corresponding application. It is incremented by one unit for each write to the socket.
uint32_t mWakeLockRefCount;
// If this flag is set to true, it means that the file descriptor associated with the BitTube
// has been added to the Looper in SensorService. This flag is typically set when this
// connection has wake-up sensors associated with it or when write has failed on this connection
// and we're storing some events in the cache.
bool mHasLooperCallbacks;
// If there are any errors associated with the Looper this flag is set to true and
// mWakeLockRefCount is reset to zero. needsWakeLock method will always return false, if this
// flag is set.
bool mDead;
bool mDataInjectionMode;
struct FlushInfo {
// The number of flush complete events dropped for this sensor is stored here. They are
// sent separately before the next batch of events.
int mPendingFlushEventsToSend;
// Every activate is preceded by a flush. Only after the first flush complete is received,
// the events for the sensor are sent on that *connection*.
bool mFirstFlushPending;
FlushInfo() : mPendingFlushEventsToSend(0), mFirstFlushPending(false) {}
};
// protected by SensorService::mLock. Key for this map is the sensor handle.
std::unordered_map<int32_t, FlushInfo> mSensorInfo;
sensors_event_t *mEventCache;
int mCacheSize, mMaxCacheSize;
int64_t mTimeOfLastEventDrop;
int mEventsDropped;
String8 mPackageName;
const String16 mOpPackageName;
int mTargetSdk;
#if DEBUG_CONNECTIONS
int mEventsReceived, mEventsSent, mEventsSentFromCache;
int mTotalAcksNeeded, mTotalAcksReceived;
#endif
mutable Mutex mDestroyLock;
bool mDestroyed;
// Store a mapping of sensor handles to required AppOp for a sensor. This map only contains a
// valid mapping for sensors that require a permission in order to reduce the lookup time.
std::unordered_map<int32_t, int32_t> mHandleToAppOp;
};
} // namepsace android
#endif // ANDROID_SENSOR_EVENT_CONNECTION_H
|
