1 /* 2 * Copyright (C) 2016 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_UTIL_SENSOR_LIST_H 18 #define ANDROID_SENSOR_SERVICE_UTIL_SENSOR_LIST_H 19 20 #include "SensorInterface.h" 21 #include "SensorServiceUtils.h" 22 23 #include <sensor/Sensor.h> 24 #include <utils/String8.h> 25 #include <utils/Vector.h> 26 27 #include <map> 28 #include <mutex> 29 #include <unordered_set> 30 #include <vector> 31 32 namespace android { 33 class SensorInterface; 34 35 namespace SensorServiceUtil { 36 37 class SensorList : public Dumpable { 38 public: 39 // After SensorInterface * is added into SensorList, it can be assumed that SensorList own the 40 // object it pointed to and the object should not be released elsewhere. 41 bool add(int handle, SensorInterface* si, bool isForDebug = false, bool isVirtual = false); 42 43 // After a handle is removed, the object that SensorInterface * pointing to may get deleted if 44 // no more sp<> of the same object exist. 45 bool remove(int handle); 46 47 inline bool hasAnySensor() const { return mHandleMap.size() > 0;} 48 49 //helper functions 50 const Vector<Sensor> getUserSensors() const; 51 const Vector<Sensor> getUserDebugSensors() const; 52 const Vector<Sensor> getDynamicSensors() const; 53 const Vector<Sensor> getVirtualSensors() const; 54 55 String8 getName(int handle) const; 56 sp<SensorInterface> getInterface(int handle) const; 57 bool isNewHandle(int handle) const; 58 59 // Iterate through Sensor in sensor list and perform operation f on each Sensor object. 60 // 61 // TF is a function with the signature: 62 // bool f(const Sensor &); 63 // A return value of 'false' stops the iteration immediately. 64 // 65 // Note: in the function f, it is illegal to make calls to member functions of the same 66 // SensorList object on which forEachSensor is invoked. 67 template <typename TF> 68 void forEachSensor(const TF& f) const; 69 70 const Sensor& getNonSensor() const { return mNonSensor;} 71 72 // Dumpable interface 73 virtual std::string dump() const override; 74 75 virtual ~SensorList(); 76 private: 77 struct Entry { 78 sp<SensorInterface> si; 79 const bool isForDebug; 80 const bool isVirtual; 81 Entry(SensorInterface* si_, bool debug_, bool virtual_) : 82 si(si_), isForDebug(debug_), isVirtual(virtual_) { 83 } 84 }; 85 86 const static Sensor mNonSensor; //.getName() == "unknown", 87 88 // Iterate through Entry in sensor list and perform operation f on each Entry. 89 // 90 // TF is a function with the signature: 91 // bool f(const Entry &); 92 // A return value of 'false' stops the iteration over entries immediately. 93 // 94 // Note: in the function being passed in, it is illegal to make calls to member functions of the 95 // same SensorList object on which forEachSensor is invoked. 96 template <typename TF> 97 void forEachEntry(const TF& f) const; 98 99 template <typename T, typename TF> 100 T getOne(int handle, const TF& accessor, T def = T()) const; 101 102 mutable std::mutex mLock; 103 std::map<int, Entry> mHandleMap; 104 std::unordered_set<int> mUsedHandle; 105 }; 106 107 template <typename TF> 108 void SensorList::forEachSensor(const TF& f) const { 109 // lock happens in forEachEntry 110 forEachEntry([&f] (const Entry& e) -> bool { return f(e.si->getSensor());}); 111 } 112 113 template <typename TF> 114 void SensorList::forEachEntry(const TF& f) const { 115 std::lock_guard<std::mutex> lk(mLock); 116 117 for (auto&& i : mHandleMap) { 118 if (!f(i.second)){ 119 break; 120 } 121 } 122 } 123 124 template <typename T, typename TF> 125 T SensorList::getOne(int handle, const TF& accessor, T def) const { 126 std::lock_guard<std::mutex> lk(mLock); 127 auto i = mHandleMap.find(handle); 128 if (i != mHandleMap.end()) { 129 return accessor(i->second); 130 } else { 131 return def; 132 } 133 } 134 135 } // namespace SensorServiceUtil 136 } // namespace android 137 138 #endif // ANDROID_SENSOR_SERVICE_UTIL_SENSOR_LIST_H 139
