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_DIRECT_CONNECTION_H
18 #define ANDROID_SENSOR_DIRECT_CONNECTION_H
19 
20 #include <optional>
21 #include <stdint.h>
22 #include <sys/types.h>
23 
24 #include <binder/BinderService.h>
25 
26 #include <sensor/Sensor.h>
27 #include <sensor/BitTube.h>
28 #include <sensor/ISensorServer.h>
29 #include <sensor/ISensorEventConnection.h>
30 
31 #include "SensorService.h"
32 
33 namespace android {
34 
35 class SensorService;
36 class BitTube;
37 
38 class SensorService::SensorDirectConnection: public BnSensorEventConnection {
39 public:
40     SensorDirectConnection(const sp<SensorService>& service, uid_t uid,
41             const sensors_direct_mem_t *mem, int32_t halChannelHandle,
42             const String16& opPackageName, int deviceId);
43     void dump(String8& result) const;
44     void dump(util::ProtoOutputStream* proto) const;
getUid()45     uid_t getUid() const { return mUid; }
getOpPackageName()46     const String16& getOpPackageName() const { return mOpPackageName; }
47     int32_t getHalChannelHandle() const;
48     bool isEquivalent(const sensors_direct_mem_t *mem) const;
49 
50     // Invoked when access to sensors for this connection has changed, e.g. lost or
51     // regained due to changes in the sensor restricted/privacy mode or the
52     // app changed to idle/active status.
53     void onSensorAccessChanged(bool hasAccess);
54     void onMicSensorAccessChanged(bool isMicToggleOn);
getUserId()55     userid_t getUserId() const { return mUserId; }
getDeviceId()56     int getDeviceId() const { return mDeviceId; }
57 
58 protected:
59     virtual ~SensorDirectConnection();
60     // ISensorEventConnection functions
61     virtual void onFirstRef();
62     virtual sp<BitTube> getSensorChannel() const;
63     virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
64                                    nsecs_t maxBatchReportLatencyNs, int reservedFlags);
65     virtual status_t setEventRate(int handle, nsecs_t samplingPeriodNs);
66     virtual status_t flush();
67     virtual int32_t configureChannel(int handle, int rateLevel);
68     virtual void destroy();
69 private:
70     bool hasSensorAccess() const;
71 
72     // Sends the configuration to the relevant sensor device.
73     int configure(int handle, const sensors_direct_cfg_t* config);
74 
75     // Stops all active sensor direct report requests.
76     //
77     // If backupRecord is true, stopped requests can be recovered
78     // by a subsequent recoverAll() call (e.g. when temporarily stopping
79     // sensors for sensor privacy/restrict mode or when an app becomes
80     // idle).
81     void stopAll(bool backupRecord = false);
82     // Same as stopAll() but with mConnectionLock held.
83     void stopAllLocked(bool backupRecord);
84 
85     // Recover sensor requests previously stopped by stopAll(true).
86     // This method can be called when a sensor access resumes (e.g.
87     // sensor privacy/restrict mode lifted or app becomes active).
88     //
89     // If no requests are backed up by stopAll(), this method is no-op.
90     void recoverAll();
91 
92     // Limits all active sensor direct report requests when the mic toggle is flipped to on.
93     void capRates();
94     // Recover sensor requests previously capped by capRates().
95     void uncapRates();
96 
97     const sp<SensorService> mService;
98     const uid_t mUid;
99     const sensors_direct_mem_t mMem;
100     const int32_t mHalChannelHandle;
101     const String16 mOpPackageName;
102     const int mDeviceId;
103 
104     mutable Mutex mConnectionLock;
105     std::unordered_map<int, int> mActivated;
106     std::unordered_map<int, int> mActivatedBackup;
107     std::unordered_map<int, int> mMicRateBackup;
108 
109     mutable Mutex mDestroyLock;
110     bool mDestroyed;
111     userid_t mUserId;
112 
113     std::optional<bool> mIsRateCappedBasedOnPermission;
114 
isRateCappedBasedOnPermission()115     bool isRateCappedBasedOnPermission() {
116       if (!mIsRateCappedBasedOnPermission.has_value()) {
117         mIsRateCappedBasedOnPermission =
118             mService->isRateCappedBasedOnPermission(mOpPackageName);
119       }
120       return mIsRateCappedBasedOnPermission.value();
121     }
122 };
123 
124 } // namepsace android
125 
126 #endif // ANDROID_SENSOR_DIRECT_CONNECTION_H
127 
128