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