libs/sensor/SensorManager.cpp

   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 <binder/IBinder.h>
  30 #include <binder/IServiceManager.h>
  31
  32 #include <sensor/ISensorServer.h>
  33 #include <sensor/ISensorEventConnection.h>
  34 #include <sensor/Sensor.h>
  35 #include <sensor/SensorEventQueue.h>
  36
  37 // ----------------------------------------------------------------------------
  38 namespace android {
  39 // ----------------------------------------------------------------------------
  40
  41 Mutex SensorManager::sLock;
  42 std::map<String16, SensorManager*> SensorManager::sPackageInstances;
  43
  44 SensorManager& SensorManager::getInstanceForPackage(const String16& packageName) {
  45     waitForSensorService(nullptr);
  46
  47     Mutex::Autolock _l(sLock);
  48     SensorManager* sensorManager;
  49     auto iterator = sPackageInstances.find(packageName);
  50
  51     if (iterator != sPackageInstances.end()) {
  52         sensorManager = iterator->second;
  53     } else {
  54         String16 opPackageName = packageName;
  55
  56         // It is possible that the calling code has no access to the package name.
  57         // In this case we will get the packages for the calling UID and pick the
  58         // first one for attributing the app op. This will work correctly for
  59         // runtime permissions as for legacy apps we will toggle the app op for
  60         // all packages in the UID. The caveat is that the operation may be attributed
  61         // to the wrong package and stats based on app ops may be slightly off.
  62         if (opPackageName.size() <= 0) {
  63             sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
  64             if (binder != 0) {
  65                 const uid_t uid = IPCThreadState::self()->getCallingUid();
  66                 Vector<String16> packages;
  67                 interface_cast<IPermissionController>(binder)->getPackagesForUid(uid, packages);
  68                 if (!packages.isEmpty()) {
  69                     opPackageName = packages[0];
  70                 } else {
  71                     ALOGE("No packages for calling UID");
  72                 }
  73             } else {
  74                 ALOGE("Cannot get permission service");
  75             }
  76         }
  77
  78         sensorManager = new SensorManager(opPackageName);
  79
  80         // If we had no package name, we looked it up from the UID and the sensor
  81         // manager instance we created should also be mapped to the empty package
  82         // name, to avoid looking up the packages for a UID and get the same result.
  83         if (packageName.size() <= 0) {
  84             sPackageInstances.insert(std::make_pair(String16(), sensorManager));
  85         }
  86
  87         // Stash the per package sensor manager.
  88         sPackageInstances.insert(std::make_pair(opPackageName, sensorManager));
  89     }
  90
  91     return *sensorManager;
  92 }
  93
  94 SensorManager::SensorManager(const String16& opPackageName)
  95     : mSensorList(0), mOpPackageName(opPackageName), mDirectConnectionHandle(1) {
  96     Mutex::Autolock _l(mLock);
  97     assertStateLocked();
  98 }
  99
 100 SensorManager::~SensorManager() {
 101     free(mSensorList);
 102 }
 103
 104 status_t SensorManager::waitForSensorService(sp<ISensorServer> *server) {
 105     // try for 300 seconds (60*5(getService() tries for 5 seconds)) before giving up ...
 106     sp<ISensorServer> s;
 107     const String16 name("sensorservice");
 108     for (int i = 0; i < 60; i++) {
 109         status_t err = getService(name, &s);
 110         switch (err) {
 111             case NAME_NOT_FOUND:
 112                 sleep(1);
 113                 continue;
 114             case NO_ERROR:
 115                 if (server != nullptr) {
 116                     *server = s;
 117                 }
 118                 return NO_ERROR;
 119             default:
 120                 return err;
 121         }
 122     }
 123     return TIMED_OUT;
 124 }
 125
 126 void SensorManager::sensorManagerDied() {
 127     Mutex::Autolock _l(mLock);
 128     mSensorServer.clear();
 129     free(mSensorList);
 130     mSensorList = NULL;
 131     mSensors.clear();
 132 }
 133
 134 status_t SensorManager::assertStateLocked() {
 135     bool initSensorManager = false;
 136     if (mSensorServer == NULL) {
 137         initSensorManager = true;
 138     } else {
 139         // Ping binder to check if sensorservice is alive.
 140         status_t err = IInterface::asBinder(mSensorServer)->pingBinder();
 141         if (err != NO_ERROR) {
 142             initSensorManager = true;
 143         }
 144     }
 145     if (initSensorManager) {
 146         waitForSensorService(&mSensorServer);
 147         LOG_ALWAYS_FATAL_IF(mSensorServer == nullptr, "getService(SensorService) NULL");
 148
 149         class DeathObserver : public IBinder::DeathRecipient {
 150             SensorManager& mSensorManager;
 151             virtual void binderDied(const wp<IBinder>& who) {
 152                 ALOGW("sensorservice died [%p]", who.unsafe_get());
 153                 mSensorManager.sensorManagerDied();
 154             }
 155         public:
 156             explicit DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { }
 157         };
 158
 159         mDeathObserver = new DeathObserver(*const_cast<SensorManager *>(this));
 160         IInterface::asBinder(mSensorServer)->linkToDeath(mDeathObserver);
 161
 162         mSensors = mSensorServer->getSensorList(mOpPackageName);
 163         size_t count = mSensors.size();
 164         mSensorList =
 165                 static_cast<Sensor const**>(malloc(count * sizeof(Sensor*)));
 166         LOG_ALWAYS_FATAL_IF(mSensorList == NULL, "mSensorList NULL");
 167
 168         for (size_t i=0 ; i<count ; i++) {
 169             mSensorList[i] = mSensors.array() + i;
 170         }
 171     }
 172
 173     return NO_ERROR;
 174 }
 175
 176 ssize_t SensorManager::getSensorList(Sensor const* const** list) {
 177     Mutex::Autolock _l(mLock);
 178     status_t err = assertStateLocked();
 179     if (err < 0) {
 180         return static_cast<ssize_t>(err);
 181     }
 182     *list = mSensorList;
 183     return static_cast<ssize_t>(mSensors.size());
 184 }
 185
 186 ssize_t SensorManager::getDynamicSensorList(Vector<Sensor> & dynamicSensors) {
 187     Mutex::Autolock _l(mLock);
 188     status_t err = assertStateLocked();
 189     if (err < 0) {
 190         return static_cast<ssize_t>(err);
 191     }
 192
 193     dynamicSensors = mSensorServer->getDynamicSensorList(mOpPackageName);
 194     size_t count = dynamicSensors.size();
 195
 196     return static_cast<ssize_t>(count);
 197 }
 198
 199 Sensor const* SensorManager::getDefaultSensor(int type)
 200 {
 201     Mutex::Autolock _l(mLock);
 202     if (assertStateLocked() == NO_ERROR) {
 203         bool wakeUpSensor = false;
 204         // For the following sensor types, return a wake-up sensor. These types are by default
 205         // defined as wake-up sensors. For the rest of the sensor types defined in sensors.h return
 206         // a non_wake-up version.
 207         if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
 208             type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
 209             type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE ||
 210             type == SENSOR_TYPE_WRIST_TILT_GESTURE ||
 211             type == SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT) {
 212             wakeUpSensor = true;
 213         }
 214         // For now we just return the first sensor of that type we find.
 215         // in the future it will make sense to let the SensorService make
 216         // that decision.
 217         for (size_t i=0 ; i<mSensors.size() ; i++) {
 218             if (mSensorList[i]->getType() == type &&
 219                 mSensorList[i]->isWakeUpSensor() == wakeUpSensor) {
 220                 return mSensorList[i];
 221             }
 222         }
 223     }
 224     return NULL;
 225 }
 226
 227 sp<SensorEventQueue> SensorManager::createEventQueue(String8 packageName, int mode) {
 228     sp<SensorEventQueue> queue;
 229
 230     Mutex::Autolock _l(mLock);
 231     while (assertStateLocked() == NO_ERROR) {
 232         sp<ISensorEventConnection> connection =
 233                 mSensorServer->createSensorEventConnection(packageName, mode, mOpPackageName);
 234         if (connection == NULL) {
 235             // SensorService just died or the app doesn't have required permissions.
 236             ALOGE("createEventQueue: connection is NULL.");
 237             return NULL;
 238         }
 239         queue = new SensorEventQueue(connection);
 240         break;
 241     }
 242     return queue;
 243 }
 244
 245 bool SensorManager::isDataInjectionEnabled() {
 246     Mutex::Autolock _l(mLock);
 247     if (assertStateLocked() == NO_ERROR) {
 248         return mSensorServer->isDataInjectionEnabled();
 249     }
 250     return false;
 251 }
 252
 253 int SensorManager::createDirectChannel(
 254         size_t size, int channelType, const native_handle_t *resourceHandle) {
 255     Mutex::Autolock _l(mLock);
 256     if (assertStateLocked() != NO_ERROR) {
 257         return NO_INIT;
 258     }
 259
 260     if (channelType != SENSOR_DIRECT_MEM_TYPE_ASHMEM
 261             && channelType != SENSOR_DIRECT_MEM_TYPE_GRALLOC) {
 262         ALOGE("Bad channel shared memory type %d", channelType);
 263         return BAD_VALUE;
 264     }
 265
 266     sp<ISensorEventConnection> conn =
 267               mSensorServer->createSensorDirectConnection(mOpPackageName,
 268                   static_cast<uint32_t>(size),
 269                   static_cast<int32_t>(channelType),
 270                   SENSOR_DIRECT_FMT_SENSORS_EVENT, resourceHandle);
 271     if (conn == nullptr) {
 272         return NO_MEMORY;
 273     }
 274
 275     int nativeHandle = mDirectConnectionHandle++;
 276     mDirectConnection.emplace(nativeHandle, conn);
 277     return nativeHandle;
 278 }
 279
 280 void SensorManager::destroyDirectChannel(int channelNativeHandle) {
 281     Mutex::Autolock _l(mLock);
 282     if (assertStateLocked() == NO_ERROR) {
 283         mDirectConnection.erase(channelNativeHandle);
 284     }
 285 }
 286
 287 int SensorManager::configureDirectChannel(int channelNativeHandle, int sensorHandle, int rateLevel) {
 288     Mutex::Autolock _l(mLock);
 289     if (assertStateLocked() != NO_ERROR) {
 290         return NO_INIT;
 291     }
 292
 293     auto i = mDirectConnection.find(channelNativeHandle);
 294     if (i == mDirectConnection.end()) {
 295         ALOGE("Cannot find the handle in client direct connection table");
 296         return BAD_VALUE;
 297     }
 298
 299     int ret;
 300     ret = i->second->configureChannel(sensorHandle, rateLevel);
 301     ALOGE_IF(ret < 0, "SensorManager::configureChannel (%d, %d) returns %d",
 302             static_cast<int>(sensorHandle), static_cast<int>(rateLevel),
 303             static_cast<int>(ret));
 304     return ret;
 305 }
 306
 307 int SensorManager::setOperationParameter(
 308         int handle, int type,
 309         const Vector<float> &floats, const Vector<int32_t> &ints) {
 310     Mutex::Autolock _l(mLock);
 311     if (assertStateLocked() != NO_ERROR) {
 312         return NO_INIT;
 313     }
 314     return mSensorServer->setOperationParameter(handle, type, floats, ints);
 315 }
 316
 317 // ----------------------------------------------------------------------------
 318 }; // namespace android