1 /*
2  * Copyright (C) 2020 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 "Fingerprint.h"
18 #include "Session.h"
19 
20 #include <android-base/properties.h>
21 #include <fingerprint.sysprop.h>
22 
23 #include <android-base/file.h>
24 #include <android-base/logging.h>
25 #include <android-base/stringprintf.h>
26 
27 using namespace ::android::fingerprint::virt;
28 
29 namespace aidl::android::hardware::biometrics::fingerprint {
30 namespace {
31 constexpr size_t MAX_WORKER_QUEUE_SIZE = 5;
32 constexpr int SENSOR_ID = 5;
33 constexpr common::SensorStrength SENSOR_STRENGTH = common::SensorStrength::STRONG;
34 constexpr int MAX_ENROLLMENTS_PER_USER = 5;
35 constexpr bool SUPPORTS_NAVIGATION_GESTURES = true;
36 constexpr char HW_COMPONENT_ID[] = "fingerprintSensor";
37 constexpr char HW_VERSION[] = "vendor/model/revision";
38 constexpr char FW_VERSION[] = "1.01";
39 constexpr char SERIAL_NUMBER[] = "00000001";
40 constexpr char SW_COMPONENT_ID[] = "matchingAlgorithm";
41 constexpr char SW_VERSION[] = "vendor/version/revision";
42 
43 }  // namespace
44 
Fingerprint()45 Fingerprint::Fingerprint() : mWorker(MAX_WORKER_QUEUE_SIZE) {
46     std::string sensorTypeProp = Fingerprint::cfg().get<std::string>("type");
47     if (sensorTypeProp == "" || sensorTypeProp == "default" || sensorTypeProp == "rear") {
48         mSensorType = FingerprintSensorType::REAR;
49         mEngine = std::make_unique<FakeFingerprintEngineRear>();
50     } else if (sensorTypeProp == "udfps") {
51         mSensorType = FingerprintSensorType::UNDER_DISPLAY_OPTICAL;
52         mEngine = std::make_unique<FakeFingerprintEngineUdfps>();
53     } else if (sensorTypeProp == "side") {
54         mSensorType = FingerprintSensorType::POWER_BUTTON;
55         mEngine = std::make_unique<FakeFingerprintEngineSide>();
56     } else {
57         mSensorType = FingerprintSensorType::UNKNOWN;
58         mEngine = std::make_unique<FakeFingerprintEngineRear>();
59         UNIMPLEMENTED(FATAL) << "unrecognized or unimplemented fingerprint behavior: "
60                              << sensorTypeProp;
61     }
62     LOG(INFO) << "sensorTypeProp:" << sensorTypeProp;
63     LOG(INFO) << "ro.product.name=" << ::android::base::GetProperty("ro.product.name", "UNKNOWN");
64 }
65 
getSensorProps(std::vector<SensorProps> * out)66 ndk::ScopedAStatus Fingerprint::getSensorProps(std::vector<SensorProps>* out) {
67     std::vector<common::ComponentInfo> componentInfo = {
68             {HW_COMPONENT_ID, HW_VERSION, FW_VERSION, SERIAL_NUMBER, "" /* softwareVersion */},
69             {SW_COMPONENT_ID, "" /* hardwareVersion */, "" /* firmwareVersion */,
70              "" /* serialNumber */, SW_VERSION}};
71     auto sensorId = Fingerprint::cfg().get<std::int32_t>("sensor_id");
72     auto sensorStrength = Fingerprint::cfg().get<std::int32_t>("sensor_strength");
73     auto maxEnrollments = Fingerprint::cfg().get<std::int32_t>("max_enrollments");
74     auto navigationGuesture = Fingerprint::cfg().get<bool>("navigation_guesture");
75     auto detectInteraction = Fingerprint::cfg().get<bool>("detect_interaction");
76     auto displayTouch = Fingerprint::cfg().get<bool>("display_touch");
77     auto controlIllumination = Fingerprint::cfg().get<bool>("control_illumination");
78 
79     common::CommonProps commonProps = {sensorId, (common::SensorStrength)sensorStrength,
80                                        maxEnrollments, componentInfo};
81 
82     SensorLocation sensorLocation = mEngine->getSensorLocation();
83 
84     LOG(INFO) << "sensor type:" << ::android::internal::ToString(mSensorType)
85               << " location:" << sensorLocation.toString();
86 
87     *out = {{commonProps,
88              mSensorType,
89              {sensorLocation},
90              navigationGuesture,
91              detectInteraction,
92              displayTouch,
93              controlIllumination,
94              std::nullopt}};
95     return ndk::ScopedAStatus::ok();
96 }
97 
createSession(int32_t sensorId,int32_t userId,const std::shared_ptr<ISessionCallback> & cb,std::shared_ptr<ISession> * out)98 ndk::ScopedAStatus Fingerprint::createSession(int32_t sensorId, int32_t userId,
99                                               const std::shared_ptr<ISessionCallback>& cb,
100                                               std::shared_ptr<ISession>* out) {
101     CHECK(mSession == nullptr || mSession->isClosed()) << "Open session already exists!";
102 
103     mSession = SharedRefBase::make<Session>(sensorId, userId, cb, mEngine.get(), &mWorker);
104     *out = mSession;
105 
106     mSession->linkToDeath(cb->asBinder().get());
107 
108     LOG(INFO) << __func__ << ": sensorId:" << sensorId << " userId:" << userId;
109     return ndk::ScopedAStatus::ok();
110 }
111 
dump(int fd,const char **,uint32_t numArgs)112 binder_status_t Fingerprint::dump(int fd, const char** /*args*/, uint32_t numArgs) {
113     if (fd < 0) {
114         LOG(ERROR) << __func__ << "fd invalid: " << fd;
115         return STATUS_BAD_VALUE;
116     } else {
117         LOG(INFO) << __func__ << " fd:" << fd << "numArgs:" << numArgs;
118     }
119 
120     dprintf(fd, "----- FingerprintVirtualHal::dump -----\n");
121     std::vector<SensorProps> sps(1);
122     getSensorProps(&sps);
123     for (auto& sp : sps) {
124         ::android::base::WriteStringToFd(sp.toString(), fd);
125     }
126     ::android::base::WriteStringToFd(mEngine->toString(), fd);
127 
128     ::android::base::WriteStringToFd(Fingerprint::cfg().toString(), fd);
129 
130     fsync(fd);
131     return STATUS_OK;
132 }
133 
handleShellCommand(int in,int out,int err,const char ** args,uint32_t numArgs)134 binder_status_t Fingerprint::handleShellCommand(int in, int out, int err, const char** args,
135                                                 uint32_t numArgs) {
136     LOG(INFO) << __func__ << " in:" << in << " out:" << out << " err:" << err
137               << " numArgs:" << numArgs;
138 
139     if (numArgs == 0) {
140         LOG(INFO) << __func__ << ": available commands";
141         onHelp(out);
142         return STATUS_OK;
143     }
144 
145     for (auto&& str : std::vector<std::string_view>(args, args + numArgs)) {
146         std::string option = str.data();
147         if (option.find("clearconfig") != std::string::npos ||
148             option.find("resetconfig") != std::string::npos) {
149             resetConfigToDefault();
150         }
151         if (option.find("help") != std::string::npos) {
152             onHelp(out);
153         }
154     }
155 
156     return STATUS_OK;
157 }
158 
onHelp(int fd)159 void Fingerprint::onHelp(int fd) {
160     dprintf(fd, "Virtual HAL commands:\n");
161     dprintf(fd, "         help: print this help\n");
162     dprintf(fd, "  resetconfig: reset all configuration to default\n");
163     dprintf(fd, "\n");
164     fsync(fd);
165 }
166 
resetConfigToDefault()167 void Fingerprint::resetConfigToDefault() {
168     LOG(INFO) << __func__ << ": reset virtual HAL configuration to default";
169     Fingerprint::cfg().init();
170 #ifdef FPS_DEBUGGABLE
171     clearConfigSysprop();
172 #endif
173 }
174 
clearConfigSysprop()175 void Fingerprint::clearConfigSysprop() {
176     LOG(INFO) << __func__ << ": clear all sysprop configuration";
177 #define RESET_CONFIG_O(__NAME__) \
178     if (FingerprintHalProperties::__NAME__()) FingerprintHalProperties::__NAME__(std::nullopt)
179 #define RESET_CONFIG_V(__NAME__)                       \
180     if (!FingerprintHalProperties::__NAME__().empty()) \
181     FingerprintHalProperties::__NAME__({std::nullopt})
182 
183     RESET_CONFIG_O(type);
184     RESET_CONFIG_V(enrollments);
185     RESET_CONFIG_O(enrollment_hit);
186     RESET_CONFIG_O(authenticator_id);
187     RESET_CONFIG_O(challenge);
188     RESET_CONFIG_O(lockout);
189     RESET_CONFIG_O(operation_authenticate_fails);
190     RESET_CONFIG_O(operation_detect_interaction_error);
191     RESET_CONFIG_O(operation_enroll_error);
192     RESET_CONFIG_V(operation_authenticate_latency);
193     RESET_CONFIG_V(operation_detect_interaction_latency);
194     RESET_CONFIG_V(operation_enroll_latency);
195     RESET_CONFIG_O(operation_authenticate_duration);
196     RESET_CONFIG_O(operation_authenticate_error);
197     RESET_CONFIG_O(sensor_location);
198     RESET_CONFIG_O(operation_authenticate_acquired);
199     RESET_CONFIG_O(operation_detect_interaction_duration);
200     RESET_CONFIG_O(operation_detect_interaction_acquired);
201     RESET_CONFIG_O(sensor_id);
202     RESET_CONFIG_O(sensor_strength);
203     RESET_CONFIG_O(max_enrollments);
204     RESET_CONFIG_O(navigation_guesture);
205     RESET_CONFIG_O(detect_interaction);
206     RESET_CONFIG_O(display_touch);
207     RESET_CONFIG_O(control_illumination);
208     RESET_CONFIG_O(lockout_enable);
209     RESET_CONFIG_O(lockout_timed_threshold);
210     RESET_CONFIG_O(lockout_timed_duration);
211     RESET_CONFIG_O(lockout_permanent_threshold);
212 }
213 
type2String(FingerprintSensorType type)214 const char* Fingerprint::type2String(FingerprintSensorType type) {
215     switch (type) {
216         case FingerprintSensorType::REAR:
217             return "rear";
218         case FingerprintSensorType::POWER_BUTTON:
219             return "side";
220         case FingerprintSensorType::UNDER_DISPLAY_OPTICAL:
221             return "udfps";
222         case FingerprintSensorType::UNDER_DISPLAY_ULTRASONIC:
223             return "udfps";
224         default:
225             return "unknown";
226     }
227 }
228 
229 }  // namespace aidl::android::hardware::biometrics::fingerprint
230