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