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 package com.android.settings.biometrics.face;
18 
19 import static android.app.Activity.RESULT_OK;
20 
21 import static com.android.settings.biometrics.BiometricEnrollBase.CONFIRM_REQUEST;
22 import static com.android.settings.biometrics.BiometricEnrollBase.ENROLL_REQUEST;
23 import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_FINISHED;
24 import static com.android.settings.biometrics.BiometricEnrollBase.RESULT_TIMEOUT;
25 
26 import android.app.settings.SettingsEnums;
27 import android.content.Context;
28 import android.content.Intent;
29 import android.hardware.face.FaceManager;
30 import android.os.Bundle;
31 import android.os.UserHandle;
32 import android.os.UserManager;
33 import android.util.Log;
34 
35 import androidx.preference.Preference;
36 
37 import com.android.settings.R;
38 import com.android.settings.SettingsActivity;
39 import com.android.settings.Utils;
40 import com.android.settings.biometrics.BiometricEnrollBase;
41 import com.android.settings.biometrics.BiometricUtils;
42 import com.android.settings.dashboard.DashboardFragment;
43 import com.android.settings.overlay.FeatureFactory;
44 import com.android.settings.password.ChooseLockSettingsHelper;
45 import com.android.settings.search.BaseSearchIndexProvider;
46 import com.android.settingslib.core.AbstractPreferenceController;
47 import com.android.settingslib.search.SearchIndexable;
48 
49 import java.util.ArrayList;
50 import java.util.Arrays;
51 import java.util.List;
52 
53 /**
54  * Settings screen for face authentication.
55  */
56 @SearchIndexable
57 public class FaceSettings extends DashboardFragment {
58 
59     private static final String TAG = "FaceSettings";
60     private static final String KEY_TOKEN = "hw_auth_token";
61 
62     private static final String PREF_KEY_DELETE_FACE_DATA =
63             "security_settings_face_delete_faces_container";
64     private static final String PREF_KEY_ENROLL_FACE_UNLOCK =
65             "security_settings_face_enroll_faces_container";
66 
67     private UserManager mUserManager;
68     private FaceManager mFaceManager;
69     private int mUserId;
70     private int mSensorId;
71     private long mChallenge;
72     private byte[] mToken;
73     private FaceSettingsAttentionPreferenceController mAttentionController;
74     private FaceSettingsRemoveButtonPreferenceController mRemoveController;
75     private FaceSettingsEnrollButtonPreferenceController mEnrollController;
76     private FaceSettingsLockscreenBypassPreferenceController mLockscreenController;
77     private List<AbstractPreferenceController> mControllers;
78 
79     private List<Preference> mTogglePreferences;
80     private Preference mRemoveButton;
81     private Preference mEnrollButton;
82     private FaceFeatureProvider mFaceFeatureProvider;
83 
84     private boolean mConfirmingPassword;
85 
86     private final FaceSettingsRemoveButtonPreferenceController.Listener mRemovalListener = () -> {
87 
88         // Disable the toggles until the user re-enrolls
89         for (Preference preference : mTogglePreferences) {
90             preference.setEnabled(false);
91         }
92 
93         // Hide the "remove" button and show the "set up face authentication" button.
94         mRemoveButton.setVisible(false);
95         mEnrollButton.setVisible(true);
96     };
97 
98     private final FaceSettingsEnrollButtonPreferenceController.Listener mEnrollListener = intent ->
99             startActivityForResult(intent, ENROLL_REQUEST);
100 
101     /**
102      * @param context
103      * @return true if the Face hardware is detected.
104      */
isFaceHardwareDetected(Context context)105     public static boolean isFaceHardwareDetected(Context context) {
106         FaceManager manager = Utils.getFaceManagerOrNull(context);
107         boolean isHardwareDetected = false;
108         if (manager == null) {
109             Log.d(TAG, "FaceManager is null");
110         } else {
111             isHardwareDetected = manager.isHardwareDetected();
112             Log.d(TAG, "FaceManager is not null. Hardware detected: " + isHardwareDetected);
113         }
114         return manager != null && isHardwareDetected;
115     }
116 
117     @Override
getMetricsCategory()118     public int getMetricsCategory() {
119         return SettingsEnums.FACE;
120     }
121 
122     @Override
getPreferenceScreenResId()123     protected int getPreferenceScreenResId() {
124         return R.xml.security_settings_face;
125     }
126 
127     @Override
getLogTag()128     protected String getLogTag() {
129         return TAG;
130     }
131 
132     @Override
onSaveInstanceState(Bundle outState)133     public void onSaveInstanceState(Bundle outState) {
134         super.onSaveInstanceState(outState);
135         outState.putByteArray(KEY_TOKEN, mToken);
136     }
137 
138     @Override
onCreate(Bundle savedInstanceState)139     public void onCreate(Bundle savedInstanceState) {
140         super.onCreate(savedInstanceState);
141 
142         final Context context = getPrefContext();
143         if (!isFaceHardwareDetected(context)) {
144             Log.w(TAG, "no faceManager, finish this");
145             finish();
146             return;
147         }
148 
149         mUserManager = context.getSystemService(UserManager.class);
150         mFaceManager = context.getSystemService(FaceManager.class);
151         mToken = getIntent().getByteArrayExtra(KEY_TOKEN);
152         mSensorId = getIntent().getIntExtra(BiometricEnrollBase.EXTRA_KEY_SENSOR_ID, -1);
153         mChallenge = getIntent().getLongExtra(BiometricEnrollBase.EXTRA_KEY_CHALLENGE, 0L);
154 
155         mUserId = getActivity().getIntent().getIntExtra(
156                 Intent.EXTRA_USER_ID, UserHandle.myUserId());
157         mFaceFeatureProvider = FeatureFactory.getFactory(getContext()).getFaceFeatureProvider();
158 
159         if (mUserManager.getUserInfo(mUserId).isManagedProfile()) {
160             getActivity().setTitle(getActivity().getResources().getString(
161                     R.string.security_settings_face_profile_preference_title));
162         }
163 
164         mLockscreenController = Utils.isMultipleBiometricsSupported(context)
165                 ? use(BiometricLockscreenBypassPreferenceController.class)
166                 : use(FaceSettingsLockscreenBypassPreferenceController.class);
167         mLockscreenController.setUserId(mUserId);
168 
169         Preference keyguardPref = findPreference(FaceSettingsKeyguardPreferenceController.KEY);
170         Preference appPref = findPreference(FaceSettingsAppPreferenceController.KEY);
171         Preference attentionPref = findPreference(FaceSettingsAttentionPreferenceController.KEY);
172         Preference confirmPref = findPreference(FaceSettingsConfirmPreferenceController.KEY);
173         Preference bypassPref =
174                 findPreference(mLockscreenController.getPreferenceKey());
175         mTogglePreferences = new ArrayList<>(
176                 Arrays.asList(keyguardPref, appPref, attentionPref, confirmPref, bypassPref));
177 
178         mRemoveButton = findPreference(FaceSettingsRemoveButtonPreferenceController.KEY);
179         mEnrollButton = findPreference(FaceSettingsEnrollButtonPreferenceController.KEY);
180 
181         // There is no better way to do this :/
182         for (AbstractPreferenceController controller : mControllers) {
183             if (controller instanceof FaceSettingsPreferenceController) {
184                 ((FaceSettingsPreferenceController) controller).setUserId(mUserId);
185             } else if (controller instanceof FaceSettingsEnrollButtonPreferenceController) {
186                 ((FaceSettingsEnrollButtonPreferenceController) controller).setUserId(mUserId);
187             }
188         }
189         mRemoveController.setUserId(mUserId);
190 
191         // Don't show keyguard controller for work profile settings.
192         if (mUserManager.isManagedProfile(mUserId)) {
193             removePreference(FaceSettingsKeyguardPreferenceController.KEY);
194             removePreference(mLockscreenController.getPreferenceKey());
195         }
196 
197         if (savedInstanceState != null) {
198             mToken = savedInstanceState.getByteArray(KEY_TOKEN);
199         }
200     }
201 
202     @Override
onResume()203     public void onResume() {
204         super.onResume();
205 
206         if (mToken == null && !mConfirmingPassword) {
207             final ChooseLockSettingsHelper.Builder builder =
208                     new ChooseLockSettingsHelper.Builder(getActivity(), this);
209             final boolean launched = builder.setRequestCode(CONFIRM_REQUEST)
210                     .setTitle(getString(R.string.security_settings_face_preference_title))
211                     .setRequestGatekeeperPasswordHandle(true)
212                     .setUserId(mUserId)
213                     .setForegroundOnly(true)
214                     .setReturnCredentials(true)
215                     .show();
216 
217             mConfirmingPassword = true;
218             if (!launched) {
219                 Log.e(TAG, "Password not set");
220                 finish();
221             }
222         } else {
223             mAttentionController.setToken(mToken);
224             mEnrollController.setToken(mToken);
225         }
226 
227         final boolean hasEnrolled = mFaceManager.hasEnrolledTemplates(mUserId);
228         mEnrollButton.setVisible(!hasEnrolled);
229         mRemoveButton.setVisible(hasEnrolled);
230 
231         if (!mFaceFeatureProvider.isAttentionSupported(getContext())) {
232             removePreference(FaceSettingsAttentionPreferenceController.KEY);
233         }
234     }
235 
236     @Override
onActivityResult(int requestCode, int resultCode, Intent data)237     public void onActivityResult(int requestCode, int resultCode, Intent data) {
238         super.onActivityResult(requestCode, resultCode, data);
239 
240         if (mToken == null && !BiometricUtils.containsGatekeeperPasswordHandle(data)) {
241             Log.e(TAG, "No credential");
242             finish();
243         }
244 
245         if (requestCode == CONFIRM_REQUEST) {
246             if (resultCode == RESULT_FINISHED || resultCode == RESULT_OK) {
247                 // The pin/pattern/password was set.
248                 mFaceManager.generateChallenge(mUserId, (sensorId, userId, challenge) -> {
249                     mToken = BiometricUtils.requestGatekeeperHat(getPrefContext(), data, mUserId,
250                             challenge);
251                     mSensorId = sensorId;
252                     mChallenge = challenge;
253                     BiometricUtils.removeGatekeeperPasswordHandle(getPrefContext(), data);
254                     mAttentionController.setToken(mToken);
255                     mEnrollController.setToken(mToken);
256                     mConfirmingPassword = false;
257                 });
258             }
259         } else if (requestCode == ENROLL_REQUEST) {
260             if (resultCode == RESULT_TIMEOUT) {
261                 setResult(resultCode, data);
262                 finish();
263             }
264         }
265     }
266 
267     @Override
onStop()268     public void onStop() {
269         super.onStop();
270 
271         if (!mEnrollController.isClicked() && !getActivity().isChangingConfigurations()
272                 && !mConfirmingPassword) {
273             // Revoke challenge and finish
274             if (mToken != null) {
275                 mFaceManager.revokeChallenge(mSensorId, mUserId, mChallenge);
276                 mToken = null;
277             }
278             finish();
279         }
280     }
281 
282     @Override
getHelpResource()283     public int getHelpResource() {
284         return R.string.help_url_face;
285     }
286 
287     @Override
createPreferenceControllers(Context context)288     protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
289         if (!isFaceHardwareDetected(context)) {
290             return null;
291         }
292         mControllers = buildPreferenceControllers(context);
293         // There's no great way of doing this right now :/
294         for (AbstractPreferenceController controller : mControllers) {
295             if (controller instanceof FaceSettingsAttentionPreferenceController) {
296                 mAttentionController = (FaceSettingsAttentionPreferenceController) controller;
297             } else if (controller instanceof FaceSettingsRemoveButtonPreferenceController) {
298                 mRemoveController = (FaceSettingsRemoveButtonPreferenceController) controller;
299                 mRemoveController.setListener(mRemovalListener);
300                 mRemoveController.setActivity((SettingsActivity) getActivity());
301             } else if (controller instanceof FaceSettingsEnrollButtonPreferenceController) {
302                 mEnrollController = (FaceSettingsEnrollButtonPreferenceController) controller;
303                 mEnrollController.setListener(mEnrollListener);
304                 mEnrollController.setActivity((SettingsActivity) getActivity());
305             }
306         }
307 
308         return mControllers;
309     }
310 
buildPreferenceControllers(Context context)311     private static List<AbstractPreferenceController> buildPreferenceControllers(Context context) {
312         final List<AbstractPreferenceController> controllers = new ArrayList<>();
313         controllers.add(new FaceSettingsKeyguardPreferenceController(context));
314         controllers.add(new FaceSettingsAppPreferenceController(context));
315         controllers.add(new FaceSettingsAttentionPreferenceController(context));
316         controllers.add(new FaceSettingsRemoveButtonPreferenceController(context));
317         controllers.add(new FaceSettingsConfirmPreferenceController(context));
318         controllers.add(new FaceSettingsEnrollButtonPreferenceController(context));
319         return controllers;
320     }
321 
322     public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
323             new BaseSearchIndexProvider(R.xml.security_settings_face) {
324 
325                 @Override
326                 public List<AbstractPreferenceController> createPreferenceControllers(
327                         Context context) {
328                     if (isFaceHardwareDetected(context)) {
329                         return buildPreferenceControllers(context);
330                     } else {
331                         return null;
332                     }
333                 }
334 
335                 @Override
336                 protected boolean isPageSearchEnabled(Context context) {
337                     if (isFaceHardwareDetected(context)) {
338                         return hasEnrolledBiometrics(context);
339                     }
340 
341                     return false;
342                 }
343 
344                 @Override
345                 public List<String> getNonIndexableKeys(Context context) {
346                     final List<String> keys = super.getNonIndexableKeys(context);
347                     final boolean isFaceHardwareDetected = isFaceHardwareDetected(context);
348                     Log.d(TAG, "Get non indexable keys. isFaceHardwareDetected: "
349                             + isFaceHardwareDetected + ", size:" + keys.size());
350                     if (isFaceHardwareDetected) {
351                         final boolean hasEnrolled = hasEnrolledBiometrics(context);
352                         keys.add(hasEnrolled ? PREF_KEY_ENROLL_FACE_UNLOCK
353                                 : PREF_KEY_DELETE_FACE_DATA);
354                     }
355 
356                     if (!isAttentionSupported(context)) {
357                         keys.add(FaceSettingsAttentionPreferenceController.KEY);
358                     }
359 
360                     return keys;
361                 }
362 
363                 private boolean isAttentionSupported(Context context) {
364                     FaceFeatureProvider featureProvider = FeatureFactory.getFactory(
365                             context).getFaceFeatureProvider();
366                     boolean isAttentionSupported = false;
367                     if (featureProvider != null) {
368                         isAttentionSupported = featureProvider.isAttentionSupported(context);
369                     }
370                     return isAttentionSupported;
371                 }
372 
373                 private boolean hasEnrolledBiometrics(Context context) {
374                     final FaceManager faceManager = Utils.getFaceManagerOrNull(context);
375                     if (faceManager != null) {
376                         return faceManager.hasEnrolledTemplates(UserHandle.myUserId());
377                     }
378                     return false;
379                 }
380             };
381 }
382