blob: e53533940c79b4e9fefda14a2b4737fe5ebd57cc [file] [log] [blame]
Mathias Agopianfc328812010-07-14 23:41:37 -07001/*
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>
Aravind Akella56ae4262014-07-10 16:01:10 -070027#include <utils/AndroidThreads.h>
Mathias Agopianfc328812010-07-14 23:41:37 -070028#include <utils/RefBase.h>
Aravind Akella56ae4262014-07-10 16:01:10 -070029#include <utils/Looper.h>
Aravind Akella4949c502015-02-11 15:54:35 -080030#include <utils/String8.h>
Mathias Agopianfc328812010-07-14 23:41:37 -070031
32#include <binder/BinderService.h>
Mathias Agopianfc328812010-07-14 23:41:37 -070033
34#include <gui/Sensor.h>
Mathias Agopianb3989272011-10-20 18:42:02 -070035#include <gui/BitTube.h>
Mathias Agopianfc328812010-07-14 23:41:37 -070036#include <gui/ISensorServer.h>
37#include <gui/ISensorEventConnection.h>
38
Mathias Agopianf001c922010-11-11 17:58:51 -080039#include "SensorInterface.h"
Peng Xu0cc8f802016-04-05 23:46:03 -070040#include "SensorList.h"
Mathias Agopianf001c922010-11-11 17:58:51 -080041
Bernhard Rosenkränzer72952ef2014-11-17 21:03:39 +010042#if __clang__
Peng Xueb4d6282015-12-10 18:02:41 -080043// Clang warns about SensorEventConnection::dump hiding BBinder::dump. The cause isn't fixable
44// without changing the API, so let's tell clang this is indeed intentional.
Bernhard Rosenkränzer72952ef2014-11-17 21:03:39 +010045#pragma clang diagnostic ignored "-Woverloaded-virtual"
46#endif
47
Mathias Agopianfc328812010-07-14 23:41:37 -070048// ---------------------------------------------------------------------------
Peng Xuf66684a2015-07-23 11:41:53 -070049#define IGNORE_HARDWARE_FUSION false
Mathias Agopiana1b7db92011-05-27 16:23:58 -070050#define DEBUG_CONNECTIONS false
Aravind Akella56ae4262014-07-10 16:01:10 -070051// Max size is 100 KB which is enough to accept a batch of about 1000 events.
52#define MAX_SOCKET_BUFFER_SIZE_BATCHED 100 * 1024
53// For older HALs which don't support batching, use a smaller socket buffer size.
Aravind Akella4c8b9512013-09-05 17:03:38 -070054#define SOCKET_BUFFER_SIZE_NON_BATCHED 4 * 1024
Mathias Agopiana1b7db92011-05-27 16:23:58 -070055
Aravind Akella18d6d512015-06-18 14:18:28 -070056#define SENSOR_REGISTRATIONS_BUF_SIZE 20
Aravind Akella444f2672015-05-07 12:40:52 -070057
Mathias Agopianfc328812010-07-14 23:41:37 -070058namespace android {
59// ---------------------------------------------------------------------------
60
61class SensorService :
62 public BinderService<SensorService>,
63 public BnSensorServer,
64 protected Thread
65{
Peng Xueb4d6282015-12-10 18:02:41 -080066 // nested class/struct for internal use
67 class SensorEventConnection;
68
69public:
70 void cleanupConnection(SensorEventConnection* connection);
71
72 status_t enable(const sp<SensorEventConnection>& connection, int handle,
73 nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs, int reservedFlags,
74 const String16& opPackageName);
75
76 status_t disable(const sp<SensorEventConnection>& connection, int handle);
77
78 status_t setEventRate(const sp<SensorEventConnection>& connection, int handle, nsecs_t ns,
79 const String16& opPackageName);
80
81 status_t flushSensor(const sp<SensorEventConnection>& connection,
82 const String16& opPackageName);
83
84private:
Mathias Agopianb6df7d02013-05-09 14:53:35 -070085 friend class BinderService<SensorService>;
Mathias Agopianfc328812010-07-14 23:41:37 -070086
Peng Xueb4d6282015-12-10 18:02:41 -080087 // nested class/struct for internal use
88 class SensorRecord;
89 class SensorEventAckReceiver;
90 struct TrimmedSensorEvent;
91 class MostRecentEventLogger;
92 struct SensorRegistrationInfo;
93
Aravind Akella4949c502015-02-11 15:54:35 -080094 enum Mode {
95 // The regular operating mode where any application can register/unregister/call flush on
96 // sensors.
97 NORMAL = 0,
Peng Xueb4d6282015-12-10 18:02:41 -080098 // This mode is only used for testing purposes. Not all HALs support this mode. In this mode,
99 // the HAL ignores the sensor data provided by physical sensors and accepts the data that is
100 // injected from the SensorService as if it were the real sensor data. This mode is primarily
101 // used for testing various algorithms like vendor provided SensorFusion, Step Counter and
102 // Step Detector etc. Typically in this mode, there will be a client (a
103 // SensorEventConnection) which will be injecting sensor data into the HAL. Normal apps can
104 // unregister and register for any sensor that supports injection. Registering to sensors
105 // that do not support injection will give an error. TODO(aakella) : Allow exactly one
106 // client to inject sensor data at a time.
Aravind Akellaa9e6cc32015-04-16 18:57:31 -0700107 DATA_INJECTION = 1,
Aravind Akella4949c502015-02-11 15:54:35 -0800108 // This mode is used only for testing sensors. Each sensor can be tested in isolation with
109 // the required sampling_rate and maxReportLatency parameters without having to think about
110 // the data rates requested by other applications. End user devices are always expected to be
111 // in NORMAL mode. When this mode is first activated, all active sensors from all connections
112 // are disabled. Calling flush() will return an error. In this mode, only the requests from
113 // selected apps whose package names are whitelisted are allowed (typically CTS apps). Only
Aravind Akellaa9e6cc32015-04-16 18:57:31 -0700114 // these apps can register/unregister/call flush() on sensors. If SensorService switches to
Aravind Akella4949c502015-02-11 15:54:35 -0800115 // NORMAL mode again, all sensors that were previously registered to are activated with the
116 // corresponding paramaters if the application hasn't unregistered for sensors in the mean
Peng Xueb4d6282015-12-10 18:02:41 -0800117 // time. NOTE: Non whitelisted app whose sensors were previously deactivated may still
118 // receive events if a whitelisted app requests data from the same sensor.
Aravind Akellaa9e6cc32015-04-16 18:57:31 -0700119 RESTRICTED = 2
120
121 // State Transitions supported.
122 // RESTRICTED <--- NORMAL ---> DATA_INJECTION
123 // ---> <---
Aravind Akella5c538052015-06-29 12:37:48 -0700124
125 // Shell commands to switch modes in SensorService.
126 // 1) Put SensorService in RESTRICTED mode with packageName .cts. If it is already in
127 // restricted mode it is treated as a NO_OP (and packageName is NOT changed).
Peng Xueb4d6282015-12-10 18:02:41 -0800128 //
129 // $ adb shell dumpsys sensorservice restrict .cts.
Aravind Akella5c538052015-06-29 12:37:48 -0700130 //
131 // 2) Put SensorService in DATA_INJECTION mode with packageName .xts. If it is already in
132 // data_injection mode it is treated as a NO_OP (and packageName is NOT changed).
Peng Xueb4d6282015-12-10 18:02:41 -0800133 //
134 // $ adb shell dumpsys sensorservice data_injection .xts.
Aravind Akella5c538052015-06-29 12:37:48 -0700135 //
136 // 3) Reset sensorservice back to NORMAL mode.
Peng Xueb4d6282015-12-10 18:02:41 -0800137 // $ adb shell dumpsys sensorservice enable
Aravind Akella4949c502015-02-11 15:54:35 -0800138 };
139
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700140 static const char* WAKE_LOCK_NAME;
Mathias Agopian7c1c5312010-07-21 15:59:50 -0700141
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700142 static char const* getServiceName() ANDROID_API { return "sensorservice"; }
143 SensorService() ANDROID_API;
Mathias Agopianfc328812010-07-14 23:41:37 -0700144 virtual ~SensorService();
145
146 virtual void onFirstRef();
147
148 // Thread interface
149 virtual bool threadLoop();
150
151 // ISensorServer interface
Svetoslavb412f6e2015-04-29 16:50:41 -0700152 virtual Vector<Sensor> getSensorList(const String16& opPackageName);
Peng Xu2576cb62016-01-20 00:22:09 -0800153 virtual Vector<Sensor> getDynamicSensorList(const String16& opPackageName);
Peng Xueb4d6282015-12-10 18:02:41 -0800154 virtual sp<ISensorEventConnection> createSensorEventConnection(
155 const String8& packageName,
156 int requestedMode, const String16& opPackageName);
Aravind Akella5c538052015-06-29 12:37:48 -0700157 virtual int isDataInjectionEnabled();
Mathias Agopianfc328812010-07-14 23:41:37 -0700158 virtual status_t dump(int fd, const Vector<String16>& args);
159
Aravind Akella444f2672015-05-07 12:40:52 -0700160 static int getNumEventsForSensorType(int sensor_event_type);
Mathias Agopianf001c922010-11-11 17:58:51 -0800161 String8 getSensorName(int handle) const;
Aravind Akellab4099e72013-10-15 15:43:10 -0700162 bool isVirtualSensor(int handle) const;
Peng Xu47e96012016-03-28 17:55:56 -0700163 SensorInterface* getSensorInterfaceFromHandle(int handle) const;
Peng Xu0cc8f802016-04-05 23:46:03 -0700164 const Sensor& getSensorFromHandle(int handle) const;
Aravind Akella9a844cf2014-02-11 18:58:52 -0800165 bool isWakeUpSensor(int type) const;
Aravind Akella0ec20662014-09-14 17:29:48 -0700166 void recordLastValueLocked(sensors_event_t const* buffer, size_t count);
Mathias Agopianf001c922010-11-11 17:58:51 -0800167 static void sortEventBuffer(sensors_event_t* buffer, size_t count);
Peng Xu0cc8f802016-04-05 23:46:03 -0700168 const Sensor& registerSensor(SensorInterface* sensor,
169 bool isDebug = false, bool isVirtual = false);
170 const Sensor& registerVirtualSensor(SensorInterface* sensor, bool isDebug = false);
171 const Sensor& registerDynamicSensor(SensorInterface* sensor, bool isDebug = false);
Peng Xu2576cb62016-01-20 00:22:09 -0800172 bool unregisterDynamicSensor(int handle);
Peng Xueb4d6282015-12-10 18:02:41 -0800173 status_t cleanupWithoutDisable(const sp<SensorEventConnection>& connection, int handle);
174 status_t cleanupWithoutDisableLocked(const sp<SensorEventConnection>& connection, int handle);
Aravind Akella9a844cf2014-02-11 18:58:52 -0800175 void cleanupAutoDisabledSensorLocked(const sp<SensorEventConnection>& connection,
Mathias Agopianb6df7d02013-05-09 14:53:35 -0700176 sensors_event_t const* buffer, const int count);
Svetoslavb412f6e2015-04-29 16:50:41 -0700177 static bool canAccessSensor(const Sensor& sensor, const char* operation,
178 const String16& opPackageName);
Aravind Akella9a844cf2014-02-11 18:58:52 -0800179 // SensorService acquires a partial wakelock for delivering events from wake up sensors. This
180 // method checks whether all the events from these wake up sensors have been delivered to the
181 // corresponding applications, if yes the wakelock is released.
182 void checkWakeLockState();
183 void checkWakeLockStateLocked();
Aravind Akellab4373ac2014-10-29 17:55:20 -0700184 bool isWakeLockAcquired();
Aravind Akella9a844cf2014-02-11 18:58:52 -0800185 bool isWakeUpSensorEvent(const sensors_event_t& event) const;
Aravind Akella56ae4262014-07-10 16:01:10 -0700186
187 sp<Looper> getLooper() const;
188
Aravind Akellab4373ac2014-10-29 17:55:20 -0700189 // Reset mWakeLockRefCounts for all SensorEventConnections to zero. This may happen if
190 // SensorService did not receive any acknowledgements from apps which have registered for
191 // wake_up sensors.
192 void resetAllWakeLockRefCounts();
193
Peng Xueb4d6282015-12-10 18:02:41 -0800194 // Acquire or release wake_lock. If wake_lock is acquired, set the timeout in the looper to 5
195 // seconds and wake the looper.
Aravind Akellab4373ac2014-10-29 17:55:20 -0700196 void setWakeLockAcquiredLocked(bool acquire);
197
198 // Send events from the event cache for this particular connection.
199 void sendEventsFromCache(const sp<SensorEventConnection>& connection);
200
201 // Promote all weak referecences in mActiveConnections vector to strong references and add them
202 // to the output vector.
Peng Xueb4d6282015-12-10 18:02:41 -0800203 void populateActiveConnections( SortedVector< sp<SensorEventConnection> >* activeConnections);
Aravind Akellab4373ac2014-10-29 17:55:20 -0700204
Aravind Akella4949c502015-02-11 15:54:35 -0800205 // If SensorService is operating in RESTRICTED mode, only select whitelisted packages are
206 // allowed to register for or call flush on sensors. Typically only cts test packages are
207 // allowed.
208 bool isWhiteListedPackage(const String8& packageName);
209
Aravind Akellaa9e6cc32015-04-16 18:57:31 -0700210 // Reset the state of SensorService to NORMAL mode.
211 status_t resetToNormalMode();
212 status_t resetToNormalModeLocked();
213
Peng Xu0cc8f802016-04-05 23:46:03 -0700214 SensorServiceUtil::SensorList mSensors;
Mathias Agopian50df2952010-07-19 19:09:10 -0700215 status_t mInitCheck;
Peng Xueb4d6282015-12-10 18:02:41 -0800216
Aravind Akella5466c3d2014-08-22 16:11:10 -0700217 // Socket buffersize used to initialize BitTube. This size depends on whether batching is
218 // supported or not.
Peng Xueb4d6282015-12-10 18:02:41 -0800219 uint32_t mSocketBufferSize; sp<Looper> mLooper; sp<SensorEventAckReceiver> mAckReceiver;
Mathias Agopianfc328812010-07-14 23:41:37 -0700220
221 // protected by mLock
222 mutable Mutex mLock;
Mathias Agopianfc328812010-07-14 23:41:37 -0700223 DefaultKeyedVector<int, SensorRecord*> mActiveSensors;
Mathias Agopianf001c922010-11-11 17:58:51 -0800224 DefaultKeyedVector<int, SensorInterface*> mActiveVirtualSensors;
Mathias Agopianfc328812010-07-14 23:41:37 -0700225 SortedVector< wp<SensorEventConnection> > mActiveConnections;
Aravind Akella9a844cf2014-02-11 18:58:52 -0800226 bool mWakeLockAcquired;
Aravind Akella8493b792014-09-08 15:45:47 -0700227 sensors_event_t *mSensorEventBuffer, *mSensorEventScratch;
228 SensorEventConnection const **mMapFlushEventsToConnections;
Peng Xu0cc8f802016-04-05 23:46:03 -0700229 KeyedVector<int32_t, MostRecentEventLogger*> mLastEventSeen;
Aravind Akellaa9e6cc32015-04-16 18:57:31 -0700230 Mode mCurrentOperatingMode;
Peng Xueb4d6282015-12-10 18:02:41 -0800231
Aravind Akella5c538052015-06-29 12:37:48 -0700232 // This packagaName is set when SensorService is in RESTRICTED or DATA_INJECTION mode. Only
233 // applications with this packageName are allowed to activate/deactivate or call flush on
234 // sensors. To run CTS this is can be set to ".cts." and only CTS tests will get access to
235 // sensors.
236 String8 mWhiteListedPackage;
Aravind Akella8493b792014-09-08 15:45:47 -0700237
Aravind Akella18d6d512015-06-18 14:18:28 -0700238 int mNextSensorRegIndex;
239 Vector<SensorRegistrationInfo> mLastNSensorRegistrations;
Mathias Agopianfc328812010-07-14 23:41:37 -0700240};
241
Peng Xueb4d6282015-12-10 18:02:41 -0800242} // namespace android
Mathias Agopianfc328812010-07-14 23:41:37 -0700243#endif // ANDROID_SENSOR_SERVICE_H