1/*
2 * Copyright (C) 2014 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
17package com.android.systemui.statusbar.phone;
18
19import android.content.Context;
20import android.content.Intent;
21import android.content.pm.PackageManager;
22import android.content.pm.ResolveInfo;
23import android.hardware.camera2.CameraManager;
24import android.os.AsyncTask;
25import android.os.Handler;
26import android.provider.MediaStore;
27import android.util.Log;
28
29import com.android.internal.widget.LockPatternUtils;
30
31import java.util.HashMap;
32import java.util.List;
33import java.util.Map;
34
35/**
36 * Handles launching the secure camera properly even when other applications may be using the camera
37 * hardware.
38 *
39 * When other applications (e.g., Face Unlock) are using the camera, they must close the camera to
40 * allow the secure camera to open it.  Since we want to minimize the delay when opening the secure
41 * camera, other apps should close the camera at the first possible opportunity (i.e., as soon as
42 * the user begins swiping to go to the secure camera).
43 *
44 * If the camera is unavailable when the user begins to swipe, the SecureCameraLaunchManager sends a
45 * broadcast to tell other apps to close the camera.  When and if the user completes their swipe to
46 * launch the secure camera, the SecureCameraLaunchManager delays launching the secure camera until
47 * a callback indicates that the camera has become available.  If it doesn't receive that callback
48 * within a specified timeout period, the secure camera is launched anyway.
49 *
50 * Ideally, the secure camera would handle waiting for the camera to become available.  This allows
51 * some of the time necessary to close the camera to happen in parallel with starting the secure
52 * camera app.  We can't rely on all third-party camera apps to handle this.  However, an app can
53 * put com.android.systemui.statusbar.phone.will_wait_for_camera_available in its meta-data to
54 * indicate that it will be responsible for waiting for the camera to become available.
55 *
56 * It is assumed that the functions in this class, including the constructor, will be called from
57 * the UI thread.
58 */
59public class SecureCameraLaunchManager {
60    private static final boolean DEBUG = false;
61    private static final String TAG = "SecureCameraLaunchManager";
62
63    // Action sent as a broadcast to tell other apps to stop using the camera.  Other apps that use
64    // the camera from keyguard (e.g., Face Unlock) should listen for this broadcast and close the
65    // camera as soon as possible after receiving it.
66    private static final String CLOSE_CAMERA_ACTION_NAME =
67            "com.android.systemui.statusbar.phone.CLOSE_CAMERA";
68
69    // Apps should put this field in their meta-data to indicate that they will take on the
70    // responsibility of waiting for the camera to become available.  If this field is present, the
71    // SecureCameraLaunchManager launches the secure camera even if the camera hardware has not
72    // become available.  Having the secure camera app do the waiting is the optimal approach, but
73    // without this field, the SecureCameraLaunchManager doesn't launch the secure camera until the
74    // camera hardware is available.
75    private static final String META_DATA_WILL_WAIT_FOR_CAMERA_AVAILABLE =
76            "com.android.systemui.statusbar.phone.will_wait_for_camera_available";
77
78    // If the camera hardware hasn't become available after this period of time, the
79    // SecureCameraLaunchManager launches the secure camera anyway.
80    private static final int CAMERA_AVAILABILITY_TIMEOUT_MS = 1000;
81
82    private Context mContext;
83    private Handler mHandler;
84    private LockPatternUtils mLockPatternUtils;
85    private KeyguardBottomAreaView mKeyguardBottomArea;
86
87    private CameraManager mCameraManager;
88    private CameraAvailabilityCallback mCameraAvailabilityCallback;
89    private Map<String, Boolean> mCameraAvailabilityMap;
90    private boolean mWaitingToLaunchSecureCamera;
91    private Runnable mLaunchCameraRunnable;
92
93    private class CameraAvailabilityCallback extends CameraManager.AvailabilityCallback {
94        @Override
95        public void onCameraUnavailable(String cameraId) {
96            if (DEBUG) Log.d(TAG, "onCameraUnavailble(" + cameraId + ")");
97            mCameraAvailabilityMap.put(cameraId, false);
98        }
99
100        @Override
101        public void onCameraAvailable(String cameraId) {
102            if (DEBUG) Log.d(TAG, "onCameraAvailable(" + cameraId + ")");
103            mCameraAvailabilityMap.put(cameraId, true);
104
105            // If we were waiting for the camera hardware to become available to launch the
106            // secure camera, we can launch it now if all cameras are available.  If one or more
107            // cameras are still not available, we will get this callback again for those
108            // cameras.
109            if (mWaitingToLaunchSecureCamera && areAllCamerasAvailable()) {
110                mKeyguardBottomArea.launchCamera();
111                mWaitingToLaunchSecureCamera = false;
112
113                // We no longer need to launch the camera after the timeout hits.
114                mHandler.removeCallbacks(mLaunchCameraRunnable);
115            }
116        }
117    }
118
119    public SecureCameraLaunchManager(Context context, KeyguardBottomAreaView keyguardBottomArea) {
120        mContext = context;
121        mHandler = new Handler();
122        mLockPatternUtils = new LockPatternUtils(context);
123        mKeyguardBottomArea = keyguardBottomArea;
124
125        mCameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
126        mCameraAvailabilityCallback = new CameraAvailabilityCallback();
127
128        // An onCameraAvailable() or onCameraUnavailable() callback will be received for each camera
129        // when the availability callback is registered, thus initializing the map.
130        //
131        // Keeping track of the state of all cameras using the onCameraAvailable() and
132        // onCameraUnavailable() callbacks can get messy when dealing with hot-pluggable cameras.
133        // However, we have a timeout in place such that we will never hang waiting for cameras.
134        mCameraAvailabilityMap = new HashMap<String, Boolean>();
135
136        mWaitingToLaunchSecureCamera = false;
137        mLaunchCameraRunnable = new Runnable() {
138                @Override
139                public void run() {
140                    if (mWaitingToLaunchSecureCamera) {
141                        Log.w(TAG, "Timeout waiting for camera availability");
142                        mKeyguardBottomArea.launchCamera();
143                        mWaitingToLaunchSecureCamera = false;
144                    }
145                }
146            };
147    }
148
149    /**
150     * Initializes the SecureCameraManager and starts listening for camera availability.
151     */
152    public void create() {
153        mCameraManager.registerAvailabilityCallback(mCameraAvailabilityCallback, mHandler);
154    }
155
156    /**
157     * Stops listening for camera availability and cleans up the SecureCameraManager.
158     */
159    public void destroy() {
160        mCameraManager.unregisterAvailabilityCallback(mCameraAvailabilityCallback);
161    }
162
163    /**
164     * Called when the user is starting to swipe horizontally, possibly to start the secure camera.
165     * Although this swipe ultimately may not result in the secure camera opening, we need to stop
166     * all other camera usage (e.g., Face Unlock) as soon as possible.  We send out a broadcast to
167     * notify other apps that they should close the camera immediately.  The broadcast is sent even
168     * if the camera appears to be available, because there could be an app that is about to open
169     * the camera.
170     */
171    public void onSwipingStarted() {
172        if (DEBUG) Log.d(TAG, "onSwipingStarted");
173        AsyncTask.execute(new Runnable() {
174                @Override
175                public void run() {
176                    Intent intent = new Intent();
177                    intent.setAction(CLOSE_CAMERA_ACTION_NAME);
178                    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
179                    mContext.sendBroadcast(intent);
180                }
181            });
182    }
183
184    /**
185     * Called when the secure camera should be started.  If the camera is available or the secure
186     * camera app has indicated that it will wait for camera availability, the secure camera app is
187     * launched immediately.  Otherwise, we wait for the camera to become available (or timeout)
188     * before launching the secure camera.
189     */
190    public void startSecureCameraLaunch() {
191        if (DEBUG) Log.d(TAG, "startSecureCameraLunch");
192        if (areAllCamerasAvailable() || targetWillWaitForCameraAvailable()) {
193            mKeyguardBottomArea.launchCamera();
194        } else {
195            mWaitingToLaunchSecureCamera = true;
196            mHandler.postDelayed(mLaunchCameraRunnable, CAMERA_AVAILABILITY_TIMEOUT_MS);
197        }
198    }
199
200    /**
201     * Returns true if all of the cameras we are tracking are currently available.
202     */
203    private boolean areAllCamerasAvailable() {
204        for (boolean cameraAvailable: mCameraAvailabilityMap.values()) {
205            if (!cameraAvailable) {
206                return false;
207            }
208        }
209        return true;
210    }
211
212    /**
213     * Determines if the secure camera app will wait for the camera hardware to become available
214     * before trying to open the camera.  If so, we can fire off an intent to start the secure
215     * camera app before the camera is available.  Otherwise, it is our responsibility to wait for
216     * the camera hardware to become available before firing off the intent to start the secure
217     * camera.
218     *
219     * Ideally we are able to fire off the secure camera intent as early as possibly so that, if the
220     * camera is closing, it can continue to close while the secure camera app is opening.  This
221     * improves secure camera startup time.
222     */
223    private boolean targetWillWaitForCameraAvailable() {
224        // Create intent that would launch the secure camera.
225        Intent intent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE)
226                .addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
227        PackageManager packageManager = mContext.getPackageManager();
228
229        // Get the list of applications that can handle the intent.
230        final List<ResolveInfo> appList = packageManager.queryIntentActivitiesAsUser(
231                intent, PackageManager.MATCH_DEFAULT_ONLY, mLockPatternUtils.getCurrentUser());
232        if (appList.size() == 0) {
233            if (DEBUG) Log.d(TAG, "No targets found for secure camera intent");
234            return false;
235        }
236
237        // Get the application that the intent resolves to.
238        ResolveInfo resolved = packageManager.resolveActivityAsUser(intent,
239                PackageManager.MATCH_DEFAULT_ONLY | PackageManager.GET_META_DATA,
240                mLockPatternUtils.getCurrentUser());
241
242        if (resolved == null || resolved.activityInfo == null) {
243            return false;
244        }
245
246        // If we would need to launch the resolver activity, then we can't assume that the target
247        // is one that would wait for the camera.
248        if (wouldLaunchResolverActivity(resolved, appList)) {
249            if (DEBUG) Log.d(TAG, "Secure camera intent would launch resolver");
250            return false;
251        }
252
253        // If the target doesn't have meta-data we must assume it won't wait for the camera.
254        if (resolved.activityInfo.metaData == null || resolved.activityInfo.metaData.isEmpty()) {
255            if (DEBUG) Log.d(TAG, "No meta-data found for secure camera application");
256            return false;
257        }
258
259        // Check the secure camera app meta-data to see if it indicates that it will wait for the
260        // camera to become available.
261        boolean willWaitForCameraAvailability =
262                resolved.activityInfo.metaData.getBoolean(META_DATA_WILL_WAIT_FOR_CAMERA_AVAILABLE);
263
264        if (DEBUG) Log.d(TAG, "Target will wait for camera: " + willWaitForCameraAvailability);
265
266        return willWaitForCameraAvailability;
267    }
268
269    /**
270     * Determines if the activity that would be launched by the intent is the ResolverActivity.
271     */
272    private boolean wouldLaunchResolverActivity(ResolveInfo resolved, List<ResolveInfo> appList) {
273        // If the list contains the resolved activity, then it can't be the ResolverActivity itself.
274        for (int i = 0; i < appList.size(); i++) {
275            ResolveInfo tmp = appList.get(i);
276            if (tmp.activityInfo.name.equals(resolved.activityInfo.name)
277                    && tmp.activityInfo.packageName.equals(resolved.activityInfo.packageName)) {
278                return false;
279            }
280        }
281        return true;
282    }
283}
284