1 /*
2 * Copyright (C) 2018 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 <mutex>
18 #include <unistd.h>
19
20 #include <binder/Binder.h>
21 #include <binder/IServiceManager.h>
22 #include <sensorprivacy/SensorPrivacyManager.h>
23
24 #include <utils/SystemClock.h>
25
26 namespace android {
27
SensorPrivacyManager()28 SensorPrivacyManager::SensorPrivacyManager()
29 {
30 }
31
getService()32 sp<hardware::ISensorPrivacyManager> SensorPrivacyManager::getService()
33 {
34 std::lock_guard<Mutex> scoped_lock(mLock);
35 int64_t startTime = 0;
36 sp<hardware::ISensorPrivacyManager> service = mService;
37 while (service == nullptr || !IInterface::asBinder(service)->isBinderAlive()) {
38 sp<IBinder> binder = defaultServiceManager()->checkService(String16("sensor_privacy"));
39 if (binder == nullptr) {
40 // Wait for the sensor privacy service to come back...
41 if (startTime == 0) {
42 startTime = uptimeMillis();
43 ALOGI("Waiting for sensor privacy service");
44 } else if ((uptimeMillis() - startTime) > 1000000) {
45 ALOGW("Waiting too long for sensor privacy service, giving up");
46 service = nullptr;
47 break;
48 }
49 usleep(25000);
50 } else {
51 service = interface_cast<hardware::ISensorPrivacyManager>(binder);
52 mService = service;
53 }
54 }
55 return service;
56 }
57
supportsSensorToggle(int sensor)58 bool SensorPrivacyManager::supportsSensorToggle(int sensor) {
59 if (mSupportedCache.find(sensor) == mSupportedCache.end()) {
60 sp<hardware::ISensorPrivacyManager> service = getService();
61 if (service != nullptr) {
62 bool result;
63 service->supportsSensorToggle(sensor, &result);
64 mSupportedCache[sensor] = result;
65 return result;
66 }
67 // if the SensorPrivacyManager is not available then assume sensor privacy feature isn't
68 // supported
69 return false;
70 }
71 return mSupportedCache[sensor];
72 }
73
addSensorPrivacyListener(const sp<hardware::ISensorPrivacyListener> & listener)74 void SensorPrivacyManager::addSensorPrivacyListener(
75 const sp<hardware::ISensorPrivacyListener>& listener)
76 {
77 sp<hardware::ISensorPrivacyManager> service = getService();
78 if (service != nullptr) {
79 service->addSensorPrivacyListener(listener);
80 }
81 }
82
addIndividualSensorPrivacyListener(int userId,int sensor,const sp<hardware::ISensorPrivacyListener> & listener)83 status_t SensorPrivacyManager::addIndividualSensorPrivacyListener(int userId, int sensor,
84 const sp<hardware::ISensorPrivacyListener>& listener)
85 {
86 sp<hardware::ISensorPrivacyManager> service = getService();
87 if (service != nullptr) {
88 return service->addIndividualSensorPrivacyListener(userId, sensor, listener)
89 .transactionError();
90 }
91 return UNEXPECTED_NULL;
92 }
93
removeSensorPrivacyListener(const sp<hardware::ISensorPrivacyListener> & listener)94 void SensorPrivacyManager::removeSensorPrivacyListener(
95 const sp<hardware::ISensorPrivacyListener>& listener)
96 {
97 sp<hardware::ISensorPrivacyManager> service = getService();
98 if (service != nullptr) {
99 service->removeSensorPrivacyListener(listener);
100 }
101 }
102
removeIndividualSensorPrivacyListener(int sensor,const sp<hardware::ISensorPrivacyListener> & listener)103 void SensorPrivacyManager::removeIndividualSensorPrivacyListener(int sensor,
104 const sp<hardware::ISensorPrivacyListener>& listener)
105 {
106 sp<hardware::ISensorPrivacyManager> service = getService();
107 if (service != nullptr) {
108 service->removeIndividualSensorPrivacyListener(sensor, listener);
109 }
110 }
111
isSensorPrivacyEnabled()112 bool SensorPrivacyManager::isSensorPrivacyEnabled()
113 {
114 sp<hardware::ISensorPrivacyManager> service = getService();
115 if (service != nullptr) {
116 bool result;
117 service->isSensorPrivacyEnabled(&result);
118 return result;
119 }
120 // if the SensorPrivacyManager is not available then assume sensor privacy is disabled
121 return false;
122 }
123
isIndividualSensorPrivacyEnabled(int userId,int sensor)124 bool SensorPrivacyManager::isIndividualSensorPrivacyEnabled(int userId, int sensor)
125 {
126 sp<hardware::ISensorPrivacyManager> service = getService();
127 if (service != nullptr) {
128 bool result;
129 service->isIndividualSensorPrivacyEnabled(userId, sensor, &result);
130 return result;
131 }
132 // if the SensorPrivacyManager is not available then assume sensor privacy is disabled
133 return false;
134 }
135
isIndividualSensorPrivacyEnabled(int userId,int sensor,bool & returnVal)136 status_t SensorPrivacyManager::isIndividualSensorPrivacyEnabled(int userId, int sensor,
137 bool &returnVal)
138 {
139 sp<hardware::ISensorPrivacyManager> service = getService();
140 if (service != nullptr) {
141 binder::Status res = service->isIndividualSensorPrivacyEnabled(userId, sensor, &returnVal);
142 return res.transactionError();
143 }
144 // if the SensorPrivacyManager is not available then assume sensor privacy is disabled
145 returnVal = false;
146 return UNKNOWN_ERROR;
147 }
148
linkToDeath(const sp<IBinder::DeathRecipient> & recipient)149 status_t SensorPrivacyManager::linkToDeath(const sp<IBinder::DeathRecipient>& recipient)
150 {
151 sp<hardware::ISensorPrivacyManager> service = getService();
152 if (service != nullptr) {
153 return IInterface::asBinder(service)->linkToDeath(recipient);
154 }
155 return INVALID_OPERATION;
156 }
157
unlinkToDeath(const sp<IBinder::DeathRecipient> & recipient)158 status_t SensorPrivacyManager::unlinkToDeath(const sp<IBinder::DeathRecipient>& recipient)
159 {
160 sp<hardware::ISensorPrivacyManager> service = getService();
161 if (service != nullptr) {
162 return IInterface::asBinder(service)->unlinkToDeath(recipient);
163 }
164 return INVALID_OPERATION;
165 }
166
167 }; // namespace android
168