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 #define LOG_TAG "Sensors"
18
19 #include <sensor/SensorManager.h>
20
21 #include <stdint.h>
22 #include <sys/types.h>
23
24 #include <cutils/native_handle.h>
25 #include <utils/Errors.h>
26 #include <utils/RefBase.h>
27 #include <utils/Singleton.h>
28
29 #include <android/companion/virtualnative/IVirtualDeviceManagerNative.h>
30
31 #include <binder/IBinder.h>
32 #include <binder/IPermissionController.h>
33 #include <binder/IServiceManager.h>
34
35 #include <sensor/ISensorServer.h>
36 #include <sensor/ISensorEventConnection.h>
37 #include <sensor/Sensor.h>
38 #include <sensor/SensorEventQueue.h>
39
40 #include <com_android_hardware_libsensor_flags.h>
41 namespace libsensor_flags = com::android::hardware::libsensor::flags;
42
43 // ----------------------------------------------------------------------------
44 namespace android {
45 // ----------------------------------------------------------------------------
46
47 namespace {
48
49 using ::android::companion::virtualnative::IVirtualDeviceManagerNative;
50
51 static constexpr int DEVICE_ID_DEFAULT = 0;
52
53 // Returns the deviceId of the device where this uid is observed. If the uid is present on more than
54 // one devices, return the default deviceId.
getDeviceIdForUid(uid_t uid)55 int getDeviceIdForUid(uid_t uid) {
56 sp<IBinder> binder =
57 defaultServiceManager()->checkService(String16("virtualdevice_native"));
58 if (binder != nullptr) {
59 auto vdm = interface_cast<IVirtualDeviceManagerNative>(binder);
60 std::vector<int> deviceIds;
61 vdm->getDeviceIdsForUid(uid, &deviceIds);
62 // If the UID is associated with multiple virtual devices, use the default device's
63 // sensors as we cannot disambiguate here. This effectively means that the app has
64 // activities on different devices at the same time, so it must handle the device
65 // awareness by itself.
66 if (deviceIds.size() == 1) {
67 const int deviceId = deviceIds.at(0);
68 int devicePolicy = IVirtualDeviceManagerNative::DEVICE_POLICY_DEFAULT;
69 vdm->getDevicePolicy(deviceId,
70 IVirtualDeviceManagerNative::POLICY_TYPE_SENSORS,
71 &devicePolicy);
72 if (devicePolicy == IVirtualDeviceManagerNative::DEVICE_POLICY_CUSTOM) {
73 return deviceId;
74 }
75 }
76 }
77 return DEVICE_ID_DEFAULT;
78 }
79
findSensorNameInList(int32_t handle,const Vector<Sensor> & sensorList,std::string * outString)80 bool findSensorNameInList(int32_t handle, const Vector<Sensor>& sensorList,
81 std::string* outString) {
82 for (auto& sensor : sensorList) {
83 if (sensor.getHandle() == handle) {
84 std::ostringstream oss;
85 oss << sensor.getStringType() << ":" << sensor.getName();
86 if (outString) {
87 *outString = oss.str();
88 }
89 return true;
90 }
91 }
92 return false;
93 }
94
95 } // namespace
96
97 Mutex SensorManager::sLock;
98 std::map<String16, SensorManager*> SensorManager::sPackageInstances;
99
getInstanceForPackage(const String16 & packageName)100 SensorManager& SensorManager::getInstanceForPackage(const String16& packageName) {
101 waitForSensorService(nullptr);
102
103 Mutex::Autolock _l(sLock);
104 SensorManager* sensorManager;
105 auto iterator = sPackageInstances.find(packageName);
106
107 const uid_t uid = IPCThreadState::self()->getCallingUid();
108 const int deviceId = getDeviceIdForUid(uid);
109
110 // Return the cached instance if the device association of the package has not changed.
111 if (iterator != sPackageInstances.end()) {
112 sensorManager = iterator->second;
113 if (sensorManager->mDeviceId == deviceId) {
114 return *sensorManager;
115 }
116 }
117
118 // It is possible that the calling code has no access to the package name.
119 // In this case we will get the packages for the calling UID and pick the
120 // first one for attributing the app op. This will work correctly for
121 // runtime permissions as for legacy apps we will toggle the app op for
122 // all packages in the UID. The caveat is that the operation may be attributed
123 // to the wrong package and stats based on app ops may be slightly off.
124 String16 opPackageName = packageName;
125 if (opPackageName.size() <= 0) {
126 sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
127 if (binder != nullptr) {
128 Vector<String16> packages;
129 interface_cast<IPermissionController>(binder)->getPackagesForUid(uid, packages);
130 if (!packages.isEmpty()) {
131 opPackageName = packages[0];
132 } else {
133 ALOGE("No packages for calling UID");
134 }
135 } else {
136 ALOGE("Cannot get permission service");
137 }
138 }
139
140 sensorManager = new SensorManager(opPackageName, deviceId);
141
142 // If we had no package name, we looked it up from the UID and the sensor
143 // manager instance we created should also be mapped to the empty package
144 // name, to avoid looking up the packages for a UID and get the same result.
145 if (packageName.size() <= 0) {
146 sPackageInstances.insert(std::make_pair(String16(), sensorManager));
147 }
148
149 // Stash the per package sensor manager.
150 sPackageInstances.insert(std::make_pair(opPackageName, sensorManager));
151
152 return *sensorManager;
153 }
154
removeInstanceForPackage(const String16 & packageName)155 void SensorManager::removeInstanceForPackage(const String16& packageName) {
156 Mutex::Autolock _l(sLock);
157 auto iterator = sPackageInstances.find(packageName);
158 if (iterator != sPackageInstances.end()) {
159 SensorManager* sensorManager = iterator->second;
160 delete sensorManager;
161 sPackageInstances.erase(iterator);
162 }
163 }
164
SensorManager(const String16 & opPackageName,int deviceId)165 SensorManager::SensorManager(const String16& opPackageName, int deviceId)
166 : mSensorList(nullptr), mOpPackageName(opPackageName), mDeviceId(deviceId),
167 mDirectConnectionHandle(1) {
168 Mutex::Autolock _l(mLock);
169 assertStateLocked();
170 }
171
~SensorManager()172 SensorManager::~SensorManager() {
173 free(mSensorList);
174 free(mDynamicSensorList);
175 }
176
waitForSensorService(sp<ISensorServer> * server)177 status_t SensorManager::waitForSensorService(sp<ISensorServer> *server) {
178 // try for 300 seconds (60*5(getService() tries for 5 seconds)) before giving up ...
179 sp<ISensorServer> s;
180 const String16 name("sensorservice");
181 for (int i = 0; i < 60; i++) {
182 status_t err = getService(name, &s);
183 switch (err) {
184 case NAME_NOT_FOUND:
185 sleep(1);
186 continue;
187 case NO_ERROR:
188 if (server != nullptr) {
189 *server = s;
190 }
191 return NO_ERROR;
192 default:
193 return err;
194 }
195 }
196 return TIMED_OUT;
197 }
198
sensorManagerDied()199 void SensorManager::sensorManagerDied() {
200 Mutex::Autolock _l(mLock);
201 mSensorServer.clear();
202 free(mSensorList);
203 mSensorList = nullptr;
204 mSensors.clear();
205 free(mDynamicSensorList);
206 mDynamicSensorList = nullptr;
207 mDynamicSensors.clear();
208 }
209
assertStateLocked()210 status_t SensorManager::assertStateLocked() {
211 #if COM_ANDROID_HARDWARE_LIBSENSOR_FLAGS(SENSORMANAGER_PING_BINDER)
212 if (mSensorServer == nullptr) {
213 #else
214 bool initSensorManager = false;
215 if (mSensorServer == nullptr) {
216 initSensorManager = true;
217 } else {
218 // Ping binder to check if sensorservice is alive.
219 status_t err = IInterface::asBinder(mSensorServer)->pingBinder();
220 if (err != NO_ERROR) {
221 initSensorManager = true;
222 }
223 }
224 if (initSensorManager) {
225 #endif
226 waitForSensorService(&mSensorServer);
227 LOG_ALWAYS_FATAL_IF(mSensorServer == nullptr, "getService(SensorService) NULL");
228
229 class DeathObserver : public IBinder::DeathRecipient {
230 SensorManager& mSensorManager;
231 virtual void binderDied(const wp<IBinder>& who) {
232 ALOGW("sensorservice died [%p]", static_cast<void*>(who.unsafe_get()));
233 mSensorManager.sensorManagerDied();
234 }
235 public:
236 explicit DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { }
237 };
238
239 mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
240 IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver);
241
242 if (mDeviceId == DEVICE_ID_DEFAULT) {
243 mSensors = mSensorServer->getSensorList(mOpPackageName);
244 } else {
245 mSensors = mSensorServer->getRuntimeSensorList(mOpPackageName, mDeviceId);
246 }
247
248 size_t count = mSensors.size();
249 // If count is 0, mSensorList will be non-null. This is old
250 // existing behavior and callers expect this.
251 mSensorList =
252 static_cast<Sensor const**>(malloc(count * sizeof(Sensor*)));
253 LOG_ALWAYS_FATAL_IF(mSensorList == nullptr, "mSensorList NULL");
254
255 for (size_t i=0 ; i<count ; i++) {
256 mSensorList[i] = mSensors.array() + i;
257 }
258 }
259
260 return NO_ERROR;
261 }
262
263 ssize_t SensorManager::getSensorList(Sensor const* const** list) {
264 Mutex::Autolock _l(mLock);
265 status_t err = assertStateLocked();
266 if (err < 0) {
267 return static_cast<ssize_t>(err);
268 }
269 *list = mSensorList;
270 return static_cast<ssize_t>(mSensors.size());
271 }
272
273 ssize_t SensorManager::getDefaultDeviceSensorList(Vector<Sensor> & list) {
274 Mutex::Autolock _l(mLock);
275 status_t err = assertStateLocked();
276 if (err < 0) {
277 return static_cast<ssize_t>(err);
278 }
279
280 if (mDeviceId == DEVICE_ID_DEFAULT) {
281 list = mSensors;
282 } else {
283 list = mSensorServer->getSensorList(mOpPackageName);
284 }
285
286 return static_cast<ssize_t>(list.size());
287 }
288
289 ssize_t SensorManager::getDynamicSensorList(Vector<Sensor> & dynamicSensors) {
290 Mutex::Autolock _l(mLock);
291 status_t err = assertStateLocked();
292 if (err < 0) {
293 return static_cast<ssize_t>(err);
294 }
295
296 dynamicSensors = mSensorServer->getDynamicSensorList(mOpPackageName);
297 size_t count = dynamicSensors.size();
298
299 return static_cast<ssize_t>(count);
300 }
301
302 ssize_t SensorManager::getRuntimeSensorList(int deviceId, Vector<Sensor>& runtimeSensors) {
303 Mutex::Autolock _l(mLock);
304 status_t err = assertStateLocked();
305 if (err < 0) {
306 return static_cast<ssize_t>(err);
307 }
308
309 runtimeSensors = mSensorServer->getRuntimeSensorList(mOpPackageName, deviceId);
310 size_t count = runtimeSensors.size();
311
312 return static_cast<ssize_t>(count);
313 }
314
315 ssize_t SensorManager::getDynamicSensorList(Sensor const* const** list) {
316 Mutex::Autolock _l(mLock);
317 status_t err = assertStateLocked();
318 if (err < 0) {
319 return static_cast<ssize_t>(err);
320 }
321
322 free(mDynamicSensorList);
323 mDynamicSensorList = nullptr;
324 mDynamicSensors = mSensorServer->getDynamicSensorList(mOpPackageName);
325 size_t dynamicCount = mDynamicSensors.size();
326 if (dynamicCount > 0) {
327 mDynamicSensorList = static_cast<Sensor const**>(
328 malloc(dynamicCount * sizeof(Sensor*)));
329 if (mDynamicSensorList == nullptr) {
330 ALOGE("Failed to allocate dynamic sensor list for %zu sensors.",
331 dynamicCount);
332 return static_cast<ssize_t>(NO_MEMORY);
333 }
334
335 for (size_t i = 0; i < dynamicCount; i++) {
336 mDynamicSensorList[i] = mDynamicSensors.array() + i;
337 }
338 }
339
340 *list = mDynamicSensorList;
341 return static_cast<ssize_t>(mDynamicSensors.size());
342 }
343
344 Sensor const* SensorManager::getDefaultSensor(int type)
345 {
346 Mutex::Autolock _l(mLock);
347 if (assertStateLocked() == NO_ERROR) {
348 bool wakeUpSensor = false;
349 // For the following sensor types, return a wake-up sensor. These types are by default
350 // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
351 // a non_wake-up version.
352 if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
353 type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
354 type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE ||
355 type == SENSOR_TYPE_WRIST_TILT_GESTURE ||
356 type == SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT || type == SENSOR_TYPE_HINGE_ANGLE) {
357 wakeUpSensor = true;
358 }
359 // For now we just return the first sensor of that type we find.
360 // in the future it will make sense to let the SensorService make
361 // that decision.
362 for (size_t i=0 ; i<mSensors.size() ; i++) {
363 if (mSensorList[i]->getType() == type &&
364 mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
365 return mSensorList[i];
366 }
367 }
368 }
369 return nullptr;
370 }
371
372 std::optional<std::string_view> SensorManager::getSensorNameByHandle(int32_t handle) {
373 std::lock_guard<std::mutex> lock(mSensorHandleToNameMutex);
374 auto iterator = mSensorHandleToName.find(handle);
375 if (iterator != mSensorHandleToName.end()) {
376 return iterator->second;
377 }
378
379 std::string sensorName;
380 if (!findSensorNameInList(handle, mSensors, &sensorName) &&
381 !findSensorNameInList(handle, mDynamicSensors, &sensorName)) {
382 ALOGW("Cannot find sensor with handle %d", handle);
383 return std::nullopt;
384 }
385
386 mSensorHandleToName[handle] = std::move(sensorName);
387
388 return mSensorHandleToName[handle];
389 }
390
391 sp<SensorEventQueue> SensorManager::createEventQueue(
392 String8 packageName, int mode, String16 attributionTag) {
393 sp<SensorEventQueue> queue;
394
395 Mutex::Autolock _l(mLock);
396 while (assertStateLocked() == NO_ERROR) {
397 sp<ISensorEventConnection> connection = mSensorServer->createSensorEventConnection(
398 packageName, mode, mOpPackageName, attributionTag);
399 if (connection == nullptr) {
400 // SensorService just died or the app doesn't have required permissions.
401 ALOGE("createEventQueue: connection is NULL.");
402 return nullptr;
403 }
404 queue = new SensorEventQueue(connection, *this, packageName);
405 break;
406 }
407 return queue;
408 }
409
410 bool SensorManager::isDataInjectionEnabled() {
411 Mutex::Autolock _l(mLock);
412 if (assertStateLocked() == NO_ERROR) {
413 return mSensorServer->isDataInjectionEnabled();
414 }
415 return false;
416 }
417
418 bool SensorManager::isReplayDataInjectionEnabled() {
419 Mutex::Autolock _l(mLock);
420 if (assertStateLocked() == NO_ERROR) {
421 return mSensorServer->isReplayDataInjectionEnabled();
422 }
423 return false;
424 }
425
426 bool SensorManager::isHalBypassReplayDataInjectionEnabled() {
427 Mutex::Autolock _l(mLock);
428 if (assertStateLocked() == NO_ERROR) {
429 return mSensorServer->isHalBypassReplayDataInjectionEnabled();
430 }
431 return false;
432 }
433
434 int SensorManager::createDirectChannel(
435 size_t size, int channelType, const native_handle_t *resourceHandle) {
436 static constexpr int DEFAULT_DEVICE_ID = 0;
437 return createDirectChannel(DEFAULT_DEVICE_ID, size, channelType, resourceHandle);
438 }
439
440 int SensorManager::createDirectChannel(
441 int deviceId, size_t size, int channelType, const native_handle_t *resourceHandle) {
442 Mutex::Autolock _l(mLock);
443 if (assertStateLocked() != NO_ERROR) {
444 return NO_INIT;
445 }
446
447 if (channelType != SENSOR_DIRECT_MEM_TYPE_ASHMEM
448 && channelType != SENSOR_DIRECT_MEM_TYPE_GRALLOC) {
449 ALOGE("Bad channel shared memory type %d", channelType);
450 return BAD_VALUE;
451 }
452
453 sp<ISensorEventConnection> conn =
454 mSensorServer->createSensorDirectConnection(mOpPackageName, deviceId,
455 static_cast<uint32_t>(size),
456 static_cast<int32_t>(channelType),
457 SENSOR_DIRECT_FMT_SENSORS_EVENT, resourceHandle);
458 if (conn == nullptr) {
459 return NO_MEMORY;
460 }
461
462 int nativeHandle = mDirectConnectionHandle++;
463 mDirectConnection.emplace(nativeHandle, conn);
464 return nativeHandle;
465 }
466
467 void SensorManager::destroyDirectChannel(int channelNativeHandle) {
468 Mutex::Autolock _l(mLock);
469 if (assertStateLocked() == NO_ERROR) {
470 mDirectConnection.erase(channelNativeHandle);
471 }
472 }
473
474 int SensorManager::configureDirectChannel(int channelNativeHandle, int sensorHandle, int rateLevel) {
475 Mutex::Autolock _l(mLock);
476 if (assertStateLocked() != NO_ERROR) {
477 return NO_INIT;
478 }
479
480 auto i = mDirectConnection.find(channelNativeHandle);
481 if (i == mDirectConnection.end()) {
482 ALOGE("Cannot find the handle in client direct connection table");
483 return BAD_VALUE;
484 }
485
486 int ret;
487 ret = i->second->configureChannel(sensorHandle, rateLevel);
488 ALOGE_IF(ret < 0, "SensorManager::configureChannel (%d, %d) returns %d",
489 static_cast<int>(sensorHandle), static_cast<int>(rateLevel),
490 static_cast<int>(ret));
491 return ret;
492 }
493
494 int SensorManager::setOperationParameter(
495 int handle, int type,
496 const Vector<float> &floats, const Vector<int32_t> &ints) {
497 Mutex::Autolock _l(mLock);
498 if (assertStateLocked() != NO_ERROR) {
499 return NO_INIT;
500 }
501 return mSensorServer->setOperationParameter(handle, type, floats, ints);
502 }
503
504 // ----------------------------------------------------------------------------
505 }; // namespace android
506