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