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
32namespace android {
33class SensorInterface;
34
35namespace SensorServiceUtil {
36
37class SensorList : public Dumpable {
38public:
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();
76private:
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
107template <typename TF>
108void 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
113template <typename TF>
114void 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
124template <typename T, typename TF>
125T 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