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 #pragma once
18 
19 #include <aidl/android/hardware/biometrics/fingerprint/BnSession.h>
20 #include <aidl/android/hardware/biometrics/fingerprint/ISessionCallback.h>
21 
22 #include "FakeFingerprintEngine.h"
23 #include "thread/WorkerThread.h"
24 
25 namespace aidl::android::hardware::biometrics::fingerprint {
26 
27 namespace common = aidl::android::hardware::biometrics::common;
28 namespace keymaster = aidl::android::hardware::keymaster;
29 
30 enum class SessionState {
31     IDLING,
32     CLOSED,
33     GENERATING_CHALLENGE,
34     REVOKING_CHALLENGE,
35     ENROLLING,
36     AUTHENTICATING,
37     DETECTING_INTERACTION,
38     ENUMERATING_ENROLLMENTS,
39     REMOVING_ENROLLMENTS,
40     GETTING_AUTHENTICATOR_ID,
41     INVALIDATING_AUTHENTICATOR_ID,
42     RESETTING_LOCKOUT,
43 };
44 
45 void onClientDeath(void* cookie);
46 
47 class Session : public BnSession {
48   public:
49     Session(int sensorId, int userId, std::shared_ptr<ISessionCallback> cb,
50             FakeFingerprintEngine* engine, WorkerThread* worker);
51 
52     ndk::ScopedAStatus generateChallenge() override;
53 
54     ndk::ScopedAStatus revokeChallenge(int64_t challenge) override;
55 
56     ndk::ScopedAStatus enroll(const keymaster::HardwareAuthToken& hat,
57                               std::shared_ptr<common::ICancellationSignal>* out) override;
58 
59     ndk::ScopedAStatus authenticate(int64_t operationId,
60                                     std::shared_ptr<common::ICancellationSignal>* out) override;
61 
62     ndk::ScopedAStatus detectInteraction(
63             std::shared_ptr<common::ICancellationSignal>* out) override;
64 
65     ndk::ScopedAStatus enumerateEnrollments() override;
66 
67     ndk::ScopedAStatus removeEnrollments(const std::vector<int32_t>& enrollmentIds) override;
68 
69     ndk::ScopedAStatus getAuthenticatorId() override;
70 
71     ndk::ScopedAStatus invalidateAuthenticatorId() override;
72 
73     ndk::ScopedAStatus resetLockout(const keymaster::HardwareAuthToken& hat) override;
74 
75     ndk::ScopedAStatus close() override;
76 
77     ndk::ScopedAStatus onPointerDown(int32_t pointerId, int32_t x, int32_t y, float minor,
78                                      float major) override;
79 
80     ndk::ScopedAStatus onPointerUp(int32_t pointerId) override;
81 
82     ndk::ScopedAStatus onUiReady() override;
83 
84     ndk::ScopedAStatus authenticateWithContext(
85             int64_t operationId, const common::OperationContext& context,
86             std::shared_ptr<common::ICancellationSignal>* out) override;
87 
88     ndk::ScopedAStatus enrollWithContext(
89             const keymaster::HardwareAuthToken& hat, const common::OperationContext& context,
90             std::shared_ptr<common::ICancellationSignal>* out) override;
91 
92     ndk::ScopedAStatus detectInteractionWithContext(
93             const common::OperationContext& context,
94             std::shared_ptr<common::ICancellationSignal>* out) override;
95 
96     ndk::ScopedAStatus onPointerDownWithContext(const PointerContext& context) override;
97 
98     ndk::ScopedAStatus onPointerUpWithContext(const PointerContext& context) override;
99 
100     ndk::ScopedAStatus onContextChanged(const common::OperationContext& context) override;
101 
102     ndk::ScopedAStatus onPointerCancelWithContext(const PointerContext& context) override;
103 
104     ndk::ScopedAStatus setIgnoreDisplayTouches(bool shouldIgnore) override;
105 
106     binder_status_t linkToDeath(AIBinder* binder);
107 
108     bool isClosed();
109 
110   private:
111     // Crashes the HAL if it's not currently idling because that would be an invalid state machine
112     // transition. Otherwise, sets the scheduled state to the given state.
113     void scheduleStateOrCrash(SessionState state);
114 
115     // Crashes the HAL if the provided state doesn't match the previously scheduled state.
116     // Otherwise, transitions into the provided state, clears the scheduled state, and notifies
117     // the client about the transition by calling ISessionCallback#onStateChanged.
118     void enterStateOrCrash(SessionState state);
119 
120     // Sets the current state to SessionState::IDLING and notifies the client about the transition
121     // by calling ISessionCallback#onStateChanged.
122     void enterIdling();
123 
124     // The sensor and user IDs for which this session was created.
125     int32_t mSensorId;
126     int32_t mUserId;
127 
128     // Callback for talking to the framework. This callback must only be called from non-binder
129     // threads to prevent nested binder calls and consequently a binder thread exhaustion.
130     // Practically, it means that this callback should always be called from the worker thread.
131     std::shared_ptr<ISessionCallback> mCb;
132 
133     // Module that communicates to the actual fingerprint hardware, keystore, TEE, etc. In real
134     // life such modules typically consume a lot of memory and are slow to initialize. This is here
135     // to showcase how such a module can be used within a Session without incurring the high
136     // initialization costs every time a Session is constructed.
137     FakeFingerprintEngine* mEngine;
138 
139     // Worker thread that allows to schedule tasks for asynchronous execution.
140     WorkerThread* mWorker;
141 
142     // Simple representation of the session's state machine. These are atomic because they can be
143     // modified from both the main and the worker threads.
144     std::atomic<SessionState> mScheduledState;
145     std::atomic<SessionState> mCurrentState;
146 
147     // Binder death handler.
148     AIBinder_DeathRecipient* mDeathRecipient;
149 };
150 
151 }  // namespace aidl::android::hardware::biometrics::fingerprint
152