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 #include "SensorDevice.h"
18 #include "SensorDirectConnection.h"
19 #include <android/util/ProtoOutputStream.h>
20 #include <frameworks/base/core/proto/android/service/sensor_service.proto.h>
21 #include <hardware/sensors.h>
22
23 #define UNUSED(x) (void)(x)
24
25 namespace android {
26
27 using util::ProtoOutputStream;
28
SensorDirectConnection(const sp<SensorService> & service,uid_t uid,const sensors_direct_mem_t * mem,int32_t halChannelHandle,const String16 & opPackageName)29 SensorService::SensorDirectConnection::SensorDirectConnection(const sp<SensorService>& service,
30 uid_t uid, const sensors_direct_mem_t *mem, int32_t halChannelHandle,
31 const String16& opPackageName)
32 : mService(service), mUid(uid), mMem(*mem),
33 mHalChannelHandle(halChannelHandle),
34 mOpPackageName(opPackageName), mDestroyed(false) {
35 mIsRateCappedBasedOnPermission = mService->isRateCappedBasedOnPermission(mOpPackageName);
36 mUserId = multiuser_get_user_id(mUid);
37 ALOGD_IF(DEBUG_CONNECTIONS, "Created SensorDirectConnection");
38 }
39
~SensorDirectConnection()40 SensorService::SensorDirectConnection::~SensorDirectConnection() {
41 ALOGD_IF(DEBUG_CONNECTIONS, "~SensorDirectConnection %p", this);
42 destroy();
43 }
44
destroy()45 void SensorService::SensorDirectConnection::destroy() {
46 Mutex::Autolock _l(mDestroyLock);
47 // destroy once only
48 if (mDestroyed) {
49 return;
50 }
51
52 stopAll();
53 mService->cleanupConnection(this);
54 if (mMem.handle != nullptr) {
55 native_handle_close(mMem.handle);
56 native_handle_delete(const_cast<struct native_handle*>(mMem.handle));
57 }
58 mDestroyed = true;
59 }
60
onFirstRef()61 void SensorService::SensorDirectConnection::onFirstRef() {
62 }
63
dump(String8 & result) const64 void SensorService::SensorDirectConnection::dump(String8& result) const {
65 Mutex::Autolock _l(mConnectionLock);
66 result.appendFormat("\tPackage %s, HAL channel handle %d, total sensor activated %zu\n",
67 String8(mOpPackageName).string(), getHalChannelHandle(), mActivated.size());
68 for (auto &i : mActivated) {
69 result.appendFormat("\t\tSensor %#08x, rate %d\n", i.first, i.second);
70 }
71 }
72
73 /**
74 * Dump debugging information as android.service.SensorDirectConnectionProto protobuf message using
75 * ProtoOutputStream.
76 *
77 * See proto definition and some notes about ProtoOutputStream in
78 * frameworks/base/core/proto/android/service/sensor_service.proto
79 */
dump(ProtoOutputStream * proto) const80 void SensorService::SensorDirectConnection::dump(ProtoOutputStream* proto) const {
81 using namespace service::SensorDirectConnectionProto;
82 Mutex::Autolock _l(mConnectionLock);
83 proto->write(PACKAGE_NAME, std::string(String8(mOpPackageName).string()));
84 proto->write(HAL_CHANNEL_HANDLE, getHalChannelHandle());
85 proto->write(NUM_SENSOR_ACTIVATED, int(mActivated.size()));
86 for (auto &i : mActivated) {
87 uint64_t token = proto->start(SENSORS);
88 proto->write(SensorProto::SENSOR, i.first);
89 proto->write(SensorProto::RATE, i.second);
90 proto->end(token);
91 }
92 }
93
getSensorChannel() const94 sp<BitTube> SensorService::SensorDirectConnection::getSensorChannel() const {
95 return nullptr;
96 }
97
onSensorAccessChanged(bool hasAccess)98 void SensorService::SensorDirectConnection::onSensorAccessChanged(bool hasAccess) {
99 if (!hasAccess) {
100 stopAll(true /* backupRecord */);
101 } else {
102 recoverAll();
103 }
104 }
105
onMicSensorAccessChanged(bool isMicToggleOn)106 void SensorService::SensorDirectConnection::onMicSensorAccessChanged(bool isMicToggleOn) {
107 if (isMicToggleOn) {
108 capRates();
109 } else {
110 uncapRates();
111 }
112 }
113
hasSensorAccess() const114 bool SensorService::SensorDirectConnection::hasSensorAccess() const {
115 return mService->hasSensorAccess(mUid, mOpPackageName);
116 }
117
enableDisable(int handle,bool enabled,nsecs_t samplingPeriodNs,nsecs_t maxBatchReportLatencyNs,int reservedFlags)118 status_t SensorService::SensorDirectConnection::enableDisable(
119 int handle, bool enabled, nsecs_t samplingPeriodNs, nsecs_t maxBatchReportLatencyNs,
120 int reservedFlags) {
121 // SensorDirectConnection does not support enableDisable, parameters not used
122 UNUSED(handle);
123 UNUSED(enabled);
124 UNUSED(samplingPeriodNs);
125 UNUSED(maxBatchReportLatencyNs);
126 UNUSED(reservedFlags);
127 return INVALID_OPERATION;
128 }
129
setEventRate(int handle,nsecs_t samplingPeriodNs)130 status_t SensorService::SensorDirectConnection::setEventRate(
131 int handle, nsecs_t samplingPeriodNs) {
132 // SensorDirectConnection does not support setEventRate, parameters not used
133 UNUSED(handle);
134 UNUSED(samplingPeriodNs);
135 return INVALID_OPERATION;
136 }
137
flush()138 status_t SensorService::SensorDirectConnection::flush() {
139 // SensorDirectConnection does not support flush
140 return INVALID_OPERATION;
141 }
142
configureChannel(int handle,int rateLevel)143 int32_t SensorService::SensorDirectConnection::configureChannel(int handle, int rateLevel) {
144
145 if (handle == -1 && rateLevel == SENSOR_DIRECT_RATE_STOP) {
146 stopAll();
147 mMicRateBackup.clear();
148 return NO_ERROR;
149 }
150
151 if (!hasSensorAccess()) {
152 return PERMISSION_DENIED;
153 }
154
155 sp<SensorInterface> si = mService->getSensorInterfaceFromHandle(handle);
156 if (si == nullptr) {
157 return NAME_NOT_FOUND;
158 }
159
160 const Sensor& s = si->getSensor();
161 if (!SensorService::canAccessSensor(s, "config direct channel", mOpPackageName)) {
162 return PERMISSION_DENIED;
163 }
164
165 if (s.getHighestDirectReportRateLevel() == 0
166 || rateLevel > s.getHighestDirectReportRateLevel()
167 || !s.isDirectChannelTypeSupported(mMem.type)) {
168 return INVALID_OPERATION;
169 }
170
171 int requestedRateLevel = rateLevel;
172 if (mService->isSensorInCappedSet(s.getType()) && rateLevel != SENSOR_DIRECT_RATE_STOP) {
173 status_t err = mService->adjustRateLevelBasedOnMicAndPermission(&rateLevel, mOpPackageName);
174 if (err != OK) {
175 return err;
176 }
177 }
178
179 struct sensors_direct_cfg_t config = {
180 .rate_level = rateLevel
181 };
182
183 Mutex::Autolock _l(mConnectionLock);
184 SensorDevice& dev(SensorDevice::getInstance());
185 int ret = dev.configureDirectChannel(handle, getHalChannelHandle(), &config);
186
187 if (rateLevel == SENSOR_DIRECT_RATE_STOP) {
188 if (ret == NO_ERROR) {
189 mActivated.erase(handle);
190 mMicRateBackup.erase(handle);
191 } else if (ret > 0) {
192 ret = UNKNOWN_ERROR;
193 }
194 } else {
195 if (ret > 0) {
196 mActivated[handle] = rateLevel;
197 if (mService->isSensorInCappedSet(s.getType())) {
198 // Back up the rates that the app is allowed to have if the mic toggle is off
199 // This is used in the uncapRates() function.
200 if (!mIsRateCappedBasedOnPermission ||
201 requestedRateLevel <= SENSOR_SERVICE_CAPPED_SAMPLING_RATE_LEVEL) {
202 mMicRateBackup[handle] = requestedRateLevel;
203 } else {
204 mMicRateBackup[handle] = SENSOR_SERVICE_CAPPED_SAMPLING_RATE_LEVEL;
205 }
206 }
207 }
208 }
209
210 return ret;
211 }
212
capRates()213 void SensorService::SensorDirectConnection::capRates() {
214 Mutex::Autolock _l(mConnectionLock);
215 const struct sensors_direct_cfg_t capConfig = {
216 .rate_level = SENSOR_SERVICE_CAPPED_SAMPLING_RATE_LEVEL
217 };
218
219 const struct sensors_direct_cfg_t stopConfig = {
220 .rate_level = SENSOR_DIRECT_RATE_STOP
221 };
222
223 // If our requests are in the backup, then we shouldn't activate sensors from here
224 bool temporarilyStopped = mActivated.empty() && !mActivatedBackup.empty();
225 std::unordered_map<int, int>& existingConnections =
226 (!temporarilyStopped) ? mActivated : mActivatedBackup;
227
228 SensorDevice& dev(SensorDevice::getInstance());
229 for (auto &i : existingConnections) {
230 int handle = i.first;
231 int rateLevel = i.second;
232 sp<SensorInterface> si = mService->getSensorInterfaceFromHandle(handle);
233 if (si != nullptr) {
234 const Sensor& s = si->getSensor();
235 if (mService->isSensorInCappedSet(s.getType()) &&
236 rateLevel > SENSOR_SERVICE_CAPPED_SAMPLING_RATE_LEVEL) {
237 mMicRateBackup[handle] = rateLevel;
238 // Modify the rate kept by the existing map
239 existingConnections[handle] = SENSOR_SERVICE_CAPPED_SAMPLING_RATE_LEVEL;
240 // Only reconfigure the channel if it's ongoing
241 if (!temporarilyStopped) {
242 // Stopping before reconfiguring is the well-tested path in CTS
243 dev.configureDirectChannel(handle, getHalChannelHandle(), &stopConfig);
244 dev.configureDirectChannel(handle, getHalChannelHandle(), &capConfig);
245 }
246 }
247 }
248 }
249 }
250
uncapRates()251 void SensorService::SensorDirectConnection::uncapRates() {
252 Mutex::Autolock _l(mConnectionLock);
253
254 // If our requests are in the backup, then we shouldn't activate sensors from here
255 bool temporarilyStopped = mActivated.empty() && !mActivatedBackup.empty();
256 std::unordered_map<int, int>& existingConnections =
257 (!temporarilyStopped) ? mActivated : mActivatedBackup;
258
259 const struct sensors_direct_cfg_t stopConfig = {
260 .rate_level = SENSOR_DIRECT_RATE_STOP
261 };
262 SensorDevice& dev(SensorDevice::getInstance());
263 for (auto &i : mMicRateBackup) {
264 int handle = i.first;
265 int rateLevel = i.second;
266
267 const struct sensors_direct_cfg_t config = {
268 .rate_level = rateLevel
269 };
270
271 // Modify the rate kept by the existing map
272 existingConnections[handle] = rateLevel;
273
274 // Only reconfigure the channel if it's ongoing
275 if (!temporarilyStopped) {
276 // Stopping before reconfiguring is the well-tested path in CTS
277 dev.configureDirectChannel(handle, getHalChannelHandle(), &stopConfig);
278 dev.configureDirectChannel(handle, getHalChannelHandle(), &config);
279 }
280 }
281 mMicRateBackup.clear();
282 }
283
stopAll(bool backupRecord)284 void SensorService::SensorDirectConnection::stopAll(bool backupRecord) {
285 Mutex::Autolock _l(mConnectionLock);
286 stopAllLocked(backupRecord);
287 }
288
stopAllLocked(bool backupRecord)289 void SensorService::SensorDirectConnection::stopAllLocked(bool backupRecord) {
290 struct sensors_direct_cfg_t config = {
291 .rate_level = SENSOR_DIRECT_RATE_STOP
292 };
293
294 SensorDevice& dev(SensorDevice::getInstance());
295 for (auto &i : mActivated) {
296 dev.configureDirectChannel(i.first, getHalChannelHandle(), &config);
297 }
298
299 if (backupRecord && mActivatedBackup.empty()) {
300 mActivatedBackup = mActivated;
301 }
302 mActivated.clear();
303 }
304
recoverAll()305 void SensorService::SensorDirectConnection::recoverAll() {
306 Mutex::Autolock _l(mConnectionLock);
307 if (!mActivatedBackup.empty()) {
308 stopAllLocked(false);
309
310 SensorDevice& dev(SensorDevice::getInstance());
311
312 // recover list of report from backup
313 ALOG_ASSERT(mActivated.empty(),
314 "mActivated must be empty if mActivatedBackup was non-empty");
315 mActivated = mActivatedBackup;
316 mActivatedBackup.clear();
317
318 // re-enable them
319 for (auto &i : mActivated) {
320 struct sensors_direct_cfg_t config = {
321 .rate_level = i.second
322 };
323 dev.configureDirectChannel(i.first, getHalChannelHandle(), &config);
324 }
325 }
326 }
327
getHalChannelHandle() const328 int32_t SensorService::SensorDirectConnection::getHalChannelHandle() const {
329 return mHalChannelHandle;
330 }
331
isEquivalent(const sensors_direct_mem_t * mem) const332 bool SensorService::SensorDirectConnection::isEquivalent(const sensors_direct_mem_t *mem) const {
333 bool ret = false;
334
335 if (mMem.type == mem->type) {
336 switch (mMem.type) {
337 case SENSOR_DIRECT_MEM_TYPE_ASHMEM: {
338 // there is no known method to test if two ashmem fds are equivalent besides
339 // trivially comparing the fd values (ino number from fstat() are always the
340 // same, pointing to "/dev/ashmem").
341 int fd1 = mMem.handle->data[0];
342 int fd2 = mem->handle->data[0];
343 ret = (fd1 == fd2);
344 break;
345 }
346 case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
347 // there is no known method to test if two gralloc handle are equivalent
348 ret = false;
349 break;
350 default:
351 // should never happen
352 ALOGE("Unexpected mem type %d", mMem.type);
353 ret = true;
354 break;
355 }
356 }
357 return ret;
358 }
359
360 } // namespace android
361
362