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 #ifndef ANDROID_SENSOR_INTERFACE_H
18 #define ANDROID_SENSOR_INTERFACE_H
19 
20 #include <sensor/Sensor.h>
21 #include <utils/RefBase.h>
22 
23 // ---------------------------------------------------------------------------
24 
25 namespace android {
26 // ---------------------------------------------------------------------------
27 class SensorDevice;
28 class SensorFusion;
29 class SensorService;
30 
31 class SensorInterface : public VirtualLightRefBase {
32 public:
~SensorInterface()33     virtual ~SensorInterface() {}
34 
35     virtual bool process(sensors_event_t* outEvent, const sensors_event_t& event) = 0;
36 
37     virtual status_t activate(void* ident, bool enabled) = 0;
38     virtual status_t setDelay(void* ident, int handle, int64_t ns) = 0;
39     virtual status_t batch(void* ident, int handle, int /*flags*/, int64_t samplingPeriodNs,
40                            int64_t maxBatchReportLatencyNs) = 0;
41 
42     virtual status_t flush(void* /*ident*/, int /*handle*/) = 0;
43 
44     virtual const Sensor& getSensor() const = 0;
45     virtual bool isVirtual() const = 0;
46     virtual void autoDisable(void* /*ident*/, int /*handle*/) = 0;
47 };
48 
49 class BaseSensor : public SensorInterface {
50 public:
51     explicit BaseSensor(const sensor_t& sensor);
52     BaseSensor(const sensor_t& sensor, const uint8_t (&uuid)[16]);
53 
54     // Not all sensors need to support batching.
batch(void * ident,int handle,int,int64_t samplingPeriodNs,int64_t maxBatchReportLatencyNs)55     virtual status_t batch(void* ident, int handle, int, int64_t samplingPeriodNs,
56                            int64_t maxBatchReportLatencyNs) override {
57         if (maxBatchReportLatencyNs == 0) {
58             return setDelay(ident, handle, samplingPeriodNs);
59         }
60         return -EINVAL;
61     }
62 
flush(void *,int)63     virtual status_t flush(void* /*ident*/, int /*handle*/) override {
64         return -EINVAL;
65     }
66 
getSensor()67     virtual const Sensor& getSensor() const override { return mSensor; }
autoDisable(void *,int)68     virtual void autoDisable(void* /*ident*/, int /*handle*/) override { }
69 
70 protected:
71     SensorDevice& mSensorDevice;
72     Sensor mSensor;
73 };
74 
75 // ---------------------------------------------------------------------------
76 
77 class HardwareSensor : public BaseSensor {
78 public:
79     explicit HardwareSensor(const sensor_t& sensor);
80     HardwareSensor(const sensor_t& sensor, const uint8_t (&uuid)[16]);
81 
82     virtual ~HardwareSensor();
83 
84     virtual bool process(sensors_event_t* outEvent,
85             const sensors_event_t& event);
86 
87     virtual status_t activate(void* ident, bool enabled) override;
88     virtual status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
89                            int64_t maxBatchReportLatencyNs) override;
90     virtual status_t setDelay(void* ident, int handle, int64_t ns) override;
91     virtual status_t flush(void* ident, int handle) override;
isVirtual()92     virtual bool isVirtual() const override { return false; }
93     virtual void autoDisable(void *ident, int handle) override;
94 };
95 
96 class VirtualSensor : public BaseSensor
97 {
98 public:
99     VirtualSensor();
isVirtual()100     virtual bool isVirtual() const override { return true; }
101 protected:
102     SensorFusion& mSensorFusion;
103 };
104 
105 // ---------------------------------------------------------------------------
106 
107 class RuntimeSensor : public BaseSensor {
108 public:
109     static constexpr int DEFAULT_DEVICE_ID = 0;
110 
111     class SensorCallback : public virtual RefBase {
112       public:
113         virtual status_t onConfigurationChanged(int handle, bool enabled, int64_t samplingPeriodNs,
114                                                 int64_t batchReportLatencyNs) = 0;
115     };
116     RuntimeSensor(const sensor_t& sensor, sp<SensorCallback> callback);
117     virtual status_t activate(void* ident, bool enabled) override;
118     virtual status_t batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
119                            int64_t maxBatchReportLatencyNs) override;
120     virtual status_t setDelay(void* ident, int handle, int64_t ns) override;
process(sensors_event_t *,const sensors_event_t &)121     virtual bool process(sensors_event_t*, const sensors_event_t&) { return false; }
isVirtual()122     virtual bool isVirtual() const override { return false; }
123 
124 private:
125     bool mEnabled = false;
126     int64_t mSamplingPeriodNs = 0;
127     int64_t mBatchReportLatencyNs = 0;
128     sp<SensorCallback> mCallback;
129 };
130 
131 // ---------------------------------------------------------------------------
132 
133 class ProximitySensor : public HardwareSensor {
134 public:
135     explicit ProximitySensor(const sensor_t& sensor, SensorService& service);
136 
137     status_t activate(void* ident, bool enabled) override;
138 
139 private:
140     SensorService& mSensorService;
141 };
142 
143 // ---------------------------------------------------------------------------
144 }; // namespace android
145 
146 #endif // ANDROID_SENSOR_INTERFACE_H
147