1 /* 2 * Copyright (C) 2017 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 #include "ALooper.h" 18 #include "ASensorEventQueue.h" 19 #include "ASensorManager.h" 20 21 #define LOG_TAG "libsensorndkbridge" 22 #include <android-base/logging.h> 23 #include <android/looper.h> 24 #include <hidl/HidlTransportSupport.h> 25 #include <sensors/convert.h> 26 27 using android::hardware::sensors::V1_0::SensorInfo; 28 using android::frameworks::sensorservice::V1_0::IEventQueue; 29 using android::frameworks::sensorservice::V1_0::ISensorManager; 30 using android::frameworks::sensorservice::V1_0::Result; 31 using android::hardware::sensors::V1_0::SensorType; 32 using android::sp; 33 using android::wp; 34 using android::Mutex; 35 using android::status_t; 36 using android::OK; 37 using android::NO_INIT; 38 using android::BAD_VALUE; 39 using android::hardware::hidl_vec; 40 using android::hardware::Return; 41 42 static Mutex gLock; 43 44 // static 45 ASensorManager *ASensorManager::sInstance = NULL; 46 47 // static 48 ASensorManager *ASensorManager::getInstance() { 49 Mutex::Autolock autoLock(gLock); 50 if (sInstance == NULL) { 51 sInstance = new ASensorManager; 52 if (sInstance->initCheck() != OK) { 53 delete sInstance; 54 sInstance = NULL; 55 } 56 } 57 return sInstance; 58 } 59 60 void ASensorManager::SensorDeathRecipient::serviceDied( 61 uint64_t, const wp<::android::hidl::base::V1_0::IBase>&) { 62 LOG(ERROR) << "Sensor service died. Cleanup sensor manager instance!"; 63 Mutex::Autolock autoLock(gLock); 64 delete sInstance; 65 sInstance = NULL; 66 } 67 68 ASensorManager::ASensorManager() 69 : mInitCheck(NO_INIT) { 70 mManager = ISensorManager::getService(); 71 if (mManager != NULL) { 72 mDeathRecipient = new SensorDeathRecipient(); 73 Return<bool> linked = mManager->linkToDeath(mDeathRecipient, /*cookie*/ 0); 74 if (!linked.isOk()) { 75 LOG(ERROR) << "Transaction error in linking to sensor service death: " << 76 linked.description().c_str(); 77 } else if (!linked) { 78 LOG(WARNING) << "Unable to link to sensor service death notifications"; 79 } else { 80 LOG(DEBUG) << "Link to sensor service death notification successful"; 81 mInitCheck = OK; 82 } 83 } 84 } 85 86 status_t ASensorManager::initCheck() const { 87 return mInitCheck; 88 } 89 90 int ASensorManager::getSensorList(ASensorList *out) { 91 LOG(VERBOSE) << "ASensorManager::getSensorList"; 92 93 Mutex::Autolock autoLock(mLock); 94 95 if (mSensorList == NULL) { 96 Return<void> ret = 97 mManager->getSensorList([&](const auto &list, auto result) { 98 if (result != Result::OK) { 99 return; 100 } 101 102 mSensors = list; 103 }); 104 105 (void)ret.isOk(); 106 107 mSensorList.reset(new ASensorRef[mSensors.size()]); 108 for (size_t i = 0; i < mSensors.size(); ++i) { 109 mSensorList.get()[i] = 110 reinterpret_cast<ASensorRef>(&mSensors[i]); 111 } 112 } 113 114 if (out) { 115 *out = reinterpret_cast<ASensorList>(mSensorList.get()); 116 } 117 118 return mSensors.size(); 119 } 120 121 ASensorRef ASensorManager::getDefaultSensor(int type) { 122 (void)getSensorList(NULL /* list */); 123 124 ASensorRef defaultSensor = NULL; 125 126 Return<void> ret = mManager->getDefaultSensor( 127 static_cast<SensorType>(type), 128 [&](const auto &sensor, auto result) { 129 if (result != Result::OK) { 130 return; 131 } 132 133 for (size_t i = 0; i < mSensors.size(); ++i) { 134 if (sensor == mSensors[i]) { 135 defaultSensor = 136 reinterpret_cast<ASensorRef>(&mSensors[i]); 137 138 break; 139 } 140 } 141 }); 142 143 (void)ret.isOk(); 144 145 return defaultSensor; 146 } 147 148 ASensorRef ASensorManager::getDefaultSensorEx( 149 int /* type */, bool /* wakeup */) { 150 // XXX ISensorManager's getDefaultSensorEx() lacks a "wakeup" parameter. 151 return NULL; 152 } 153 154 ASensorEventQueue *ASensorManager::createEventQueue( 155 ALooper *looper, int ident, ALooper_callbackFunc callback, void *data) { 156 LOG(VERBOSE) << "ASensorManager::createEventQueue"; 157 158 sp<ASensorEventQueue> queue = 159 new ASensorEventQueue(looper, ident, callback, data); 160 161 ::android::hardware::setMinSchedulerPolicy(queue, SCHED_FIFO, 98); 162 Result result; 163 Return<void> ret = 164 mManager->createEventQueue( 165 queue, [&](const sp<IEventQueue> &queueImpl, auto tmpResult) { 166 result = tmpResult; 167 if (result != Result::OK) { 168 return; 169 } 170 171 queue->setImpl(queueImpl); 172 }); 173 174 if (!ret.isOk() || result != Result::OK) { 175 LOG(ERROR) << "FAILED to create event queue"; 176 return NULL; 177 } 178 179 queue->incStrong(NULL /* id */); 180 181 LOG(VERBOSE) << "Returning event queue " << queue.get(); 182 return queue.get(); 183 } 184 185 void ASensorManager::destroyEventQueue(ASensorEventQueue *queue) { 186 LOG(VERBOSE) << "ASensorManager::destroyEventQueue(" << queue << ")"; 187 188 queue->invalidate(); 189 190 queue->decStrong(NULL /* id */); 191 queue = NULL; 192 } 193 194 //////////////////////////////////////////////////////////////////////////////// 195 196 ASensorManager *ASensorManager_getInstance() { 197 return ASensorManager::getInstance(); 198 } 199 200 ASensorManager *ASensorManager_getInstanceForPackage( 201 const char* /* packageName */) { 202 return ASensorManager::getInstance(); 203 } 204 205 #define RETURN_IF_MANAGER_IS_NULL(x) \ 206 do { \ 207 if (manager == NULL) { \ 208 return x; \ 209 } \ 210 } while (0) 211 212 #define RETURN_IF_QUEUE_IS_NULL(x) \ 213 do { \ 214 if (queue == NULL) { \ 215 return x; \ 216 } \ 217 } while (0) 218 219 #define RETURN_IF_SENSOR_IS_NULL(x) \ 220 do { \ 221 if (sensor == NULL) { \ 222 return x; \ 223 } \ 224 } while (0) 225 226 int ASensorManager_getSensorList(ASensorManager* manager, ASensorList* list) { 227 RETURN_IF_MANAGER_IS_NULL(BAD_VALUE); 228 return manager->getSensorList(list); 229 } 230 231 ASensor const* ASensorManager_getDefaultSensor( 232 ASensorManager* manager, int type) { 233 RETURN_IF_MANAGER_IS_NULL(NULL); 234 235 return manager->getDefaultSensor(type); 236 } 237 238 #if 0 239 ASensor const* ASensorManager_getDefaultSensorEx( 240 ASensorManager* manager, int type, bool wakeUp) { 241 RETURN_IF_MANAGER_IS_NULL(NULL); 242 243 return manager->getDefaultSensorEx(type, wakeUp); 244 } 245 #endif 246 247 ASensorEventQueue* ASensorManager_createEventQueue( 248 ASensorManager* manager, 249 ALooper* looper, 250 int ident, 251 ALooper_callbackFunc callback, 252 void* data) { 253 RETURN_IF_MANAGER_IS_NULL(NULL); 254 255 if (looper == NULL) { 256 return NULL; 257 } 258 259 return manager->createEventQueue(looper, ident, callback, data); 260 } 261 262 int ASensorManager_destroyEventQueue( 263 ASensorManager* manager, ASensorEventQueue* queue) { 264 RETURN_IF_MANAGER_IS_NULL(BAD_VALUE); 265 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 266 267 manager->destroyEventQueue(queue); 268 queue = NULL; 269 270 return OK; 271 } 272 273 #if 0 274 int ASensorManager_createSharedMemoryDirectChannel( 275 ASensorManager* manager, int fd, size_t size) { 276 RETURN_IF_MANAGER_IS_NULL(BAD_VALUE); 277 278 return OK; 279 } 280 281 int ASensorManager_createHardwareBufferDirectChannel( 282 ASensorManager* manager, AHardwareBuffer const * buffer, size_t size) { 283 RETURN_IF_MANAGER_IS_NULL(BAD_VALUE); 284 285 return OK; 286 } 287 288 void ASensorManager_destroyDirectChannel( 289 ASensorManager* manager, int channelId) { 290 } 291 292 int ASensorManager_configureDirectReport( 293 ASensorManager* manager, 294 ASensor const* sensor, 295 int channelId,int rate) { 296 RETURN_IF_MANAGER_IS_NULL(BAD_VALUE); 297 return OK; 298 } 299 #endif 300 301 int ASensorEventQueue_registerSensor( 302 ASensorEventQueue* queue, 303 ASensor const* sensor, 304 int32_t samplingPeriodUs, 305 int64_t maxBatchReportLatencyUs) { 306 LOG(VERBOSE) << "ASensorEventQueue_registerSensor"; 307 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 308 return queue->registerSensor( 309 sensor, samplingPeriodUs, maxBatchReportLatencyUs); 310 } 311 312 int ASensorEventQueue_enableSensor( 313 ASensorEventQueue* queue, ASensor const* sensor) { 314 LOG(VERBOSE) << "ASensorEventQueue_enableSensor(queue " << queue << ")"; 315 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 316 return queue->enableSensor(sensor); 317 } 318 319 int ASensorEventQueue_disableSensor( 320 ASensorEventQueue* queue, ASensor const* sensor) { 321 LOG(VERBOSE) << "ASensorEventQueue_disableSensor"; 322 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 323 return queue->disableSensor(sensor); 324 } 325 326 int ASensorEventQueue_setEventRate( 327 ASensorEventQueue* queue, 328 ASensor const* sensor, 329 int32_t usec) { 330 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 331 return queue->setEventRate(sensor, usec); 332 } 333 334 int ASensorEventQueue_hasEvents(ASensorEventQueue* queue) { 335 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 336 return queue->hasEvents(); 337 } 338 339 ssize_t ASensorEventQueue_getEvents( 340 ASensorEventQueue* queue, ASensorEvent* events, size_t count) { 341 LOG(VERBOSE) << "ASensorEventQueue_getEvents"; 342 RETURN_IF_QUEUE_IS_NULL(BAD_VALUE); 343 return queue->getEvents(events, count); 344 } 345 346 const char *ASensor_getName(ASensor const* sensor) { 347 RETURN_IF_SENSOR_IS_NULL(NULL); 348 return reinterpret_cast<const SensorInfo *>(sensor)->name.c_str(); 349 } 350 351 const char *ASensor_getVendor(ASensor const* sensor) { 352 RETURN_IF_SENSOR_IS_NULL(NULL); 353 return reinterpret_cast<const SensorInfo *>(sensor)->vendor.c_str(); 354 } 355 356 int ASensor_getType(ASensor const* sensor) { 357 RETURN_IF_SENSOR_IS_NULL(ASENSOR_TYPE_INVALID); 358 return static_cast<int>( 359 reinterpret_cast<const SensorInfo *>(sensor)->type); 360 } 361 362 float ASensor_getResolution(ASensor const* sensor) { 363 RETURN_IF_SENSOR_IS_NULL(ASENSOR_RESOLUTION_INVALID); 364 return reinterpret_cast<const SensorInfo *>(sensor)->resolution; 365 } 366 367 int ASensor_getMinDelay(ASensor const* sensor) { 368 RETURN_IF_SENSOR_IS_NULL(ASENSOR_DELAY_INVALID); 369 return reinterpret_cast<const SensorInfo *>(sensor)->minDelay; 370 } 371 372 int ASensor_getFifoMaxEventCount(ASensor const* sensor) { 373 RETURN_IF_SENSOR_IS_NULL(ASENSOR_FIFO_COUNT_INVALID); 374 return reinterpret_cast<const SensorInfo *>(sensor)->fifoMaxEventCount; 375 } 376 377 int ASensor_getFifoReservedEventCount(ASensor const* sensor) { 378 RETURN_IF_SENSOR_IS_NULL(ASENSOR_FIFO_COUNT_INVALID); 379 return reinterpret_cast<const SensorInfo *>(sensor)->fifoReservedEventCount; 380 } 381 382 const char* ASensor_getStringType(ASensor const* sensor) { 383 RETURN_IF_SENSOR_IS_NULL(NULL); 384 return reinterpret_cast<const SensorInfo *>(sensor)->typeAsString.c_str(); 385 } 386 387 extern "C" float ASensor_getMaxRange(ASensor const* sensor) { 388 RETURN_IF_SENSOR_IS_NULL(nanf("")); 389 return reinterpret_cast<const SensorInfo *>(sensor)->maxRange; 390 } 391 392 #if 0 393 int ASensor_getReportingMode(ASensor const* sensor) { 394 RETURN_IF_SENSOR_IS_NULL(AREPORTING_MODE_INVALID); 395 return 0; 396 } 397 398 bool ASensor_isWakeUpSensor(ASensor const* sensor) { 399 RETURN_IF_SENSOR_IS_NULL(false); 400 return false; 401 } 402 403 bool ASensor_isDirectChannelTypeSupported( 404 ASensor const* sensor, int channelType) { 405 RETURN_IF_SENSOR_IS_NULL(false); 406 return false; 407 } 408 409 int ASensor_getHighestDirectReportRateLevel(ASensor const* sensor) { 410 RETURN_IF_SENSOR_IS_NULL(ASENSOR_DIRECT_RATE_STOP); 411 return 0; 412 } 413 #endif 414 415 static ALooper *getTheLooper() { 416 static ALooper *sLooper = NULL; 417 418 Mutex::Autolock autoLock(gLock); 419 if (sLooper == NULL) { 420 sLooper = new ALooper; 421 } 422 423 return sLooper; 424 } 425 426 427 ALooper *ALooper_forThread() { 428 LOG(VERBOSE) << "ALooper_forThread"; 429 return getTheLooper(); 430 } 431 432 ALooper *ALooper_prepare(int /* opts */) { 433 LOG(VERBOSE) << "ALooper_prepare"; 434 return getTheLooper(); 435 } 436 437 int ALooper_pollOnce( 438 int timeoutMillis, int* outFd, int* outEvents, void** outData) { 439 int res = getTheLooper()->pollOnce(timeoutMillis, outFd, outEvents, outData); 440 LOG(VERBOSE) << "ALooper_pollOnce => " << res; 441 return res; 442 } 443 444 void ALooper_wake(ALooper* looper) { 445 LOG(VERBOSE) << "ALooper_wake"; 446 looper->wake(); 447 } 448
