Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2013 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 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 17 | package com.android.camera.app; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 18 | |
Angus Kong | b50b5cb | 2013-08-09 14:55:20 -0700 | [diff] [blame] | 19 | import static com.android.camera.util.CameraUtil.Assert; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 20 | |
Sascha Haeberling | 8e963a5 | 2013-08-06 11:43:02 -0700 | [diff] [blame] | 21 | import java.io.IOException; |
| 22 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 23 | import android.annotation.TargetApi; |
| 24 | import android.graphics.SurfaceTexture; |
| 25 | import android.hardware.Camera; |
| 26 | import android.hardware.Camera.AutoFocusCallback; |
| 27 | import android.hardware.Camera.AutoFocusMoveCallback; |
| 28 | import android.hardware.Camera.ErrorCallback; |
| 29 | import android.hardware.Camera.FaceDetectionListener; |
| 30 | import android.hardware.Camera.OnZoomChangeListener; |
| 31 | import android.hardware.Camera.Parameters; |
| 32 | import android.hardware.Camera.PictureCallback; |
| 33 | import android.hardware.Camera.PreviewCallback; |
| 34 | import android.hardware.Camera.ShutterCallback; |
Sascha Haeberling | 638e6f0 | 2013-09-18 14:28:51 -0700 | [diff] [blame] | 35 | import android.os.Build; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 36 | import android.os.Handler; |
| 37 | import android.os.HandlerThread; |
| 38 | import android.os.Looper; |
| 39 | import android.os.Message; |
| 40 | import android.util.Log; |
| 41 | import android.view.SurfaceHolder; |
| 42 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 43 | /** |
| 44 | * A class to implement {@link CameraManager} of the Android camera framework. |
| 45 | */ |
| 46 | class AndroidCameraManagerImpl implements CameraManager { |
| 47 | private static final String TAG = "CAM_" + |
| 48 | AndroidCameraManagerImpl.class.getSimpleName(); |
| 49 | |
| 50 | private Parameters mParameters; |
| 51 | private boolean mParametersIsDirty; |
| 52 | private IOException mReconnectIOException; |
| 53 | |
| 54 | /* Messages used in CameraHandler. */ |
| 55 | // Camera initialization/finalization |
| 56 | private static final int OPEN_CAMERA = 1; |
| 57 | private static final int RELEASE = 2; |
| 58 | private static final int RECONNECT = 3; |
| 59 | private static final int UNLOCK = 4; |
| 60 | private static final int LOCK = 5; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 61 | @Deprecated |
| 62 | private static final int OPEN_CAMERA_OLD = 6; // TODO: remove this. |
| 63 | @Deprecated |
| 64 | private static final int RECONNECT_OLD = 7; // TODO: remove this. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 65 | // Preview |
| 66 | private static final int SET_PREVIEW_TEXTURE_ASYNC = 101; |
| 67 | private static final int START_PREVIEW_ASYNC = 102; |
| 68 | private static final int STOP_PREVIEW = 103; |
| 69 | private static final int SET_PREVIEW_CALLBACK_WITH_BUFFER = 104; |
| 70 | private static final int ADD_CALLBACK_BUFFER = 105; |
| 71 | private static final int SET_PREVIEW_DISPLAY_ASYNC = 106; |
| 72 | private static final int SET_PREVIEW_CALLBACK = 107; |
| 73 | // Parameters |
| 74 | private static final int SET_PARAMETERS = 201; |
| 75 | private static final int GET_PARAMETERS = 202; |
| 76 | private static final int REFRESH_PARAMETERS = 203; |
| 77 | // Focus, Zoom |
| 78 | private static final int AUTO_FOCUS = 301; |
| 79 | private static final int CANCEL_AUTO_FOCUS = 302; |
| 80 | private static final int SET_AUTO_FOCUS_MOVE_CALLBACK = 303; |
| 81 | private static final int SET_ZOOM_CHANGE_LISTENER = 304; |
| 82 | // Face detection |
| 83 | private static final int SET_FACE_DETECTION_LISTENER = 461; |
| 84 | private static final int START_FACE_DETECTION = 462; |
| 85 | private static final int STOP_FACE_DETECTION = 463; |
| 86 | private static final int SET_ERROR_CALLBACK = 464; |
| 87 | // Presentation |
| 88 | private static final int ENABLE_SHUTTER_SOUND = 501; |
| 89 | private static final int SET_DISPLAY_ORIENTATION = 502; |
| 90 | |
| 91 | private CameraHandler mCameraHandler; |
| 92 | private android.hardware.Camera mCamera; |
| 93 | |
| 94 | // Used to retain a copy of Parameters for setting parameters. |
| 95 | private Parameters mParamsToSet; |
| 96 | |
| 97 | AndroidCameraManagerImpl() { |
| 98 | HandlerThread ht = new HandlerThread("Camera Handler Thread"); |
| 99 | ht.start(); |
| 100 | mCameraHandler = new CameraHandler(ht.getLooper()); |
| 101 | } |
| 102 | |
| 103 | private class CameraHandler extends Handler { |
| 104 | CameraHandler(Looper looper) { |
| 105 | super(looper); |
| 106 | } |
| 107 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 108 | private void startFaceDetection() { |
| 109 | mCamera.startFaceDetection(); |
| 110 | } |
| 111 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 112 | private void stopFaceDetection() { |
| 113 | mCamera.stopFaceDetection(); |
| 114 | } |
| 115 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 116 | private void setFaceDetectionListener(FaceDetectionListener listener) { |
| 117 | mCamera.setFaceDetectionListener(listener); |
| 118 | } |
| 119 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 120 | private void setPreviewTexture(Object surfaceTexture) { |
| 121 | try { |
| 122 | mCamera.setPreviewTexture((SurfaceTexture) surfaceTexture); |
| 123 | } catch (IOException e) { |
Sascha Haeberling | 464f220 | 2013-10-17 15:29:38 -0700 | [diff] [blame] | 124 | Log.e(TAG, "Could not set preview texture", e); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 125 | } |
| 126 | } |
| 127 | |
Sascha Haeberling | 638e6f0 | 2013-09-18 14:28:51 -0700 | [diff] [blame] | 128 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1) |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 129 | private void enableShutterSound(boolean enable) { |
| 130 | mCamera.enableShutterSound(enable); |
| 131 | } |
| 132 | |
Sascha Haeberling | 638e6f0 | 2013-09-18 14:28:51 -0700 | [diff] [blame] | 133 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN) |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 134 | private void setAutoFocusMoveCallback( |
| 135 | android.hardware.Camera camera, Object cb) { |
| 136 | camera.setAutoFocusMoveCallback((AutoFocusMoveCallback) cb); |
| 137 | } |
| 138 | |
| 139 | public void requestTakePicture( |
| 140 | final ShutterCallback shutter, |
| 141 | final PictureCallback raw, |
| 142 | final PictureCallback postView, |
| 143 | final PictureCallback jpeg) { |
| 144 | post(new Runnable() { |
| 145 | @Override |
| 146 | public void run() { |
| 147 | try { |
| 148 | mCamera.takePicture(shutter, raw, postView, jpeg); |
| 149 | } catch (RuntimeException e) { |
| 150 | // TODO: output camera state and focus state for debugging. |
| 151 | Log.e(TAG, "take picture failed."); |
| 152 | throw e; |
| 153 | } |
| 154 | } |
| 155 | }); |
| 156 | } |
| 157 | |
| 158 | /** |
| 159 | * Waits for all the {@code Message} and {@code Runnable} currently in the queue |
| 160 | * are processed. |
| 161 | * |
| 162 | * @return {@code false} if the wait was interrupted, {@code true} otherwise. |
| 163 | */ |
| 164 | public boolean waitDone() { |
| 165 | final Object waitDoneLock = new Object(); |
| 166 | final Runnable unlockRunnable = new Runnable() { |
| 167 | @Override |
| 168 | public void run() { |
| 169 | synchronized (waitDoneLock) { |
| 170 | waitDoneLock.notifyAll(); |
| 171 | } |
| 172 | } |
| 173 | }; |
| 174 | |
| 175 | synchronized (waitDoneLock) { |
| 176 | mCameraHandler.post(unlockRunnable); |
| 177 | try { |
| 178 | waitDoneLock.wait(); |
| 179 | } catch (InterruptedException ex) { |
| 180 | Log.v(TAG, "waitDone interrupted"); |
| 181 | return false; |
| 182 | } |
| 183 | } |
| 184 | return true; |
| 185 | } |
| 186 | |
| 187 | /** |
| 188 | * This method does not deal with the API level check. Everyone should |
| 189 | * check first for supported operations before sending message to this handler. |
| 190 | */ |
| 191 | @Override |
| 192 | public void handleMessage(final Message msg) { |
| 193 | try { |
| 194 | switch (msg.what) { |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 195 | case OPEN_CAMERA: { |
| 196 | final CameraOpenCallback openCallback = (CameraOpenCallback) msg.obj; |
| 197 | final int cameraId = msg.arg1; |
| 198 | mCamera = android.hardware.Camera.open(cameraId); |
| 199 | if (mCamera != null) { |
| 200 | mParametersIsDirty = true; |
| 201 | |
| 202 | // Get a instance of Camera.Parameters for later use. |
| 203 | if (mParamsToSet == null) { |
| 204 | mParamsToSet = mCamera.getParameters(); |
| 205 | } |
| 206 | |
| 207 | if (openCallback != null) { |
| 208 | openCallback.onCameraOpened(new AndroidCameraProxyImpl(cameraId)); |
| 209 | } |
| 210 | } else { |
| 211 | if (openCallback != null) { |
| 212 | openCallback.onDeviceOpenFailure(cameraId); |
| 213 | } |
| 214 | } |
| 215 | return; |
| 216 | } |
| 217 | |
| 218 | case OPEN_CAMERA_OLD: { |
Angus Kong | 6d29a64 | 2013-07-31 12:46:54 -0700 | [diff] [blame] | 219 | mCamera = android.hardware.Camera.open(msg.arg1); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 220 | if (mCamera != null) { |
| 221 | mParametersIsDirty = true; |
| 222 | |
| 223 | // Get a instance of Camera.Parameters for later use. |
| 224 | if (mParamsToSet == null) { |
| 225 | mParamsToSet = mCamera.getParameters(); |
| 226 | } |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 227 | } else { |
| 228 | if (msg.obj != null) { |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 229 | ((CameraOpenCallback) msg.obj).onDeviceOpenFailure(msg.arg1); |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 230 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 231 | } |
| 232 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 233 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 234 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 235 | case RELEASE: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 236 | mCamera.release(); |
| 237 | mCamera = null; |
| 238 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 239 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 240 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 241 | case RECONNECT: { |
| 242 | final CameraOpenCallbackForward cbForward = |
| 243 | (CameraOpenCallbackForward) msg.obj; |
| 244 | final int cameraId = msg.arg1; |
| 245 | try { |
| 246 | mCamera.reconnect(); |
| 247 | } catch (IOException ex) { |
| 248 | if (cbForward != null) { |
| 249 | cbForward.onReconnectionFailure(AndroidCameraManagerImpl.this); |
| 250 | } |
| 251 | return; |
| 252 | } |
| 253 | |
| 254 | if (cbForward != null) { |
| 255 | cbForward.onCameraOpened(new AndroidCameraProxyImpl(cameraId)); |
| 256 | } |
| 257 | return; |
| 258 | } |
| 259 | |
| 260 | case RECONNECT_OLD: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 261 | mReconnectIOException = null; |
| 262 | try { |
| 263 | mCamera.reconnect(); |
| 264 | } catch (IOException ex) { |
| 265 | mReconnectIOException = ex; |
| 266 | } |
| 267 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 268 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 269 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 270 | case UNLOCK: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 271 | mCamera.unlock(); |
| 272 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 273 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 274 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 275 | case LOCK: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 276 | mCamera.lock(); |
| 277 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 278 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 279 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 280 | case SET_PREVIEW_TEXTURE_ASYNC: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 281 | setPreviewTexture(msg.obj); |
| 282 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 283 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 284 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 285 | case SET_PREVIEW_DISPLAY_ASYNC: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 286 | try { |
| 287 | mCamera.setPreviewDisplay((SurfaceHolder) msg.obj); |
| 288 | } catch (IOException e) { |
| 289 | throw new RuntimeException(e); |
| 290 | } |
| 291 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 292 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 293 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 294 | case START_PREVIEW_ASYNC: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 295 | mCamera.startPreview(); |
| 296 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 297 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 298 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 299 | case STOP_PREVIEW: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 300 | mCamera.stopPreview(); |
| 301 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 302 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 303 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 304 | case SET_PREVIEW_CALLBACK_WITH_BUFFER: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 305 | mCamera.setPreviewCallbackWithBuffer( |
| 306 | (PreviewCallback) msg.obj); |
| 307 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 308 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 309 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 310 | case ADD_CALLBACK_BUFFER: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 311 | mCamera.addCallbackBuffer((byte[]) msg.obj); |
| 312 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 313 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 314 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 315 | case AUTO_FOCUS: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 316 | mCamera.autoFocus((AutoFocusCallback) msg.obj); |
| 317 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 318 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 319 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 320 | case CANCEL_AUTO_FOCUS: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 321 | mCamera.cancelAutoFocus(); |
| 322 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 323 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 324 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 325 | case SET_AUTO_FOCUS_MOVE_CALLBACK: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 326 | setAutoFocusMoveCallback(mCamera, msg.obj); |
| 327 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 328 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 329 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 330 | case SET_DISPLAY_ORIENTATION: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 331 | mCamera.setDisplayOrientation(msg.arg1); |
| 332 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 333 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 334 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 335 | case SET_ZOOM_CHANGE_LISTENER: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 336 | mCamera.setZoomChangeListener( |
| 337 | (OnZoomChangeListener) msg.obj); |
| 338 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 339 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 340 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 341 | case SET_FACE_DETECTION_LISTENER: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 342 | setFaceDetectionListener((FaceDetectionListener) msg.obj); |
| 343 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 344 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 345 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 346 | case START_FACE_DETECTION: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 347 | startFaceDetection(); |
| 348 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 349 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 350 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 351 | case STOP_FACE_DETECTION: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 352 | stopFaceDetection(); |
| 353 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 354 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 355 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 356 | case SET_ERROR_CALLBACK: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 357 | mCamera.setErrorCallback((ErrorCallback) msg.obj); |
| 358 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 359 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 360 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 361 | case SET_PARAMETERS: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 362 | mParametersIsDirty = true; |
| 363 | mParamsToSet.unflatten((String) msg.obj); |
| 364 | mCamera.setParameters(mParamsToSet); |
| 365 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 366 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 367 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 368 | case GET_PARAMETERS: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 369 | if (mParametersIsDirty) { |
| 370 | mParameters = mCamera.getParameters(); |
| 371 | mParametersIsDirty = false; |
| 372 | } |
| 373 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 374 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 375 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 376 | case SET_PREVIEW_CALLBACK: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 377 | mCamera.setPreviewCallback((PreviewCallback) msg.obj); |
| 378 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 379 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 380 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 381 | case ENABLE_SHUTTER_SOUND: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 382 | enableShutterSound((msg.arg1 == 1) ? true : false); |
| 383 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 384 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 385 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 386 | case REFRESH_PARAMETERS: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 387 | mParametersIsDirty = true; |
| 388 | return; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 389 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 390 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 391 | default: { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 392 | throw new RuntimeException("Invalid CameraProxy message=" + msg.what); |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 393 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 394 | } |
| 395 | } catch (RuntimeException e) { |
| 396 | if (msg.what != RELEASE && mCamera != null) { |
| 397 | try { |
| 398 | mCamera.release(); |
| 399 | } catch (Exception ex) { |
| 400 | Log.e(TAG, "Fail to release the camera."); |
| 401 | } |
| 402 | mCamera = null; |
Sascha Haeberling | 02db77f | 2013-09-17 15:36:13 -0700 | [diff] [blame] | 403 | } else if (mCamera == null) { |
ztenghui | cfc148d | 2013-10-28 15:27:02 -0700 | [diff] [blame] | 404 | if (msg.what == OPEN_CAMERA) { |
| 405 | if (msg.obj != null) { |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 406 | ((CameraOpenCallback) msg.obj).onDeviceOpenFailure(msg.arg1); |
ztenghui | cfc148d | 2013-10-28 15:27:02 -0700 | [diff] [blame] | 407 | } |
| 408 | } else { |
| 409 | Log.w(TAG, "Cannot handle message, mCamera is null."); |
| 410 | } |
| 411 | return; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 412 | } |
| 413 | throw e; |
| 414 | } |
| 415 | } |
| 416 | } |
| 417 | |
| 418 | @Override |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 419 | public void cameraOpen(Handler handler, int cameraId, CameraOpenCallback callback) { |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 420 | mCameraHandler.obtainMessage(OPEN_CAMERA, cameraId, 0, |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 421 | CameraOpenCallbackForward.getNewInstance(handler, callback)).sendToTarget(); |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 422 | } |
| 423 | |
| 424 | @Override |
| 425 | public CameraProxy cameraOpenOld(Handler handler, int cameraId, CameraOpenCallback callback) { |
| 426 | mCameraHandler.obtainMessage(OPEN_CAMERA_OLD, cameraId, 0, |
| 427 | CameraOpenCallbackForward.getNewInstance(handler, callback)).sendToTarget(); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 428 | mCameraHandler.waitDone(); |
| 429 | if (mCamera != null) { |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 430 | return new AndroidCameraProxyImpl(cameraId); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 431 | } else { |
| 432 | return null; |
| 433 | } |
| 434 | } |
| 435 | |
| 436 | /** |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 437 | * A class which implements {@link CameraManager.CameraProxy} and |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 438 | * camera handler thread. |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 439 | * TODO: Save the handler for the callback here to avoid passing the same |
| 440 | * handler multiple times. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 441 | */ |
| 442 | public class AndroidCameraProxyImpl implements CameraManager.CameraProxy { |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 443 | private final int mCameraId; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 444 | |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 445 | private AndroidCameraProxyImpl(int cameraId) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 446 | Assert(mCamera != null); |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 447 | mCameraId = cameraId; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 448 | } |
| 449 | |
| 450 | @Override |
| 451 | public android.hardware.Camera getCamera() { |
| 452 | return mCamera; |
| 453 | } |
| 454 | |
| 455 | @Override |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 456 | public int getCameraId() { |
| 457 | return mCameraId; |
| 458 | } |
| 459 | |
| 460 | // TODO: Make this package private. |
| 461 | @Override |
| 462 | public void release(boolean sync) { |
| 463 | Log.v("DEBUG", "camera manager release"); |
| 464 | mCameraHandler.removeCallbacksAndMessages(null); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 465 | mCameraHandler.sendEmptyMessage(RELEASE); |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 466 | if (sync) { |
| 467 | mCameraHandler.waitDone(); |
| 468 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 469 | } |
| 470 | |
| 471 | @Override |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 472 | public void reconnect(Handler handler, CameraOpenCallback cb) { |
| 473 | mCameraHandler.obtainMessage(RECONNECT, mCameraId, 0, |
| 474 | CameraOpenCallbackForward.getNewInstance(handler, cb)).sendToTarget(); |
| 475 | } |
| 476 | |
| 477 | @Override |
| 478 | public boolean reconnectOld(Handler handler, CameraOpenCallback cb) { |
| 479 | mCameraHandler.sendEmptyMessage(RECONNECT_OLD); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 480 | mCameraHandler.waitDone(); |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 481 | CameraOpenCallback cbforward = |
| 482 | CameraOpenCallbackForward.getNewInstance(handler, cb); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 483 | if (mReconnectIOException != null) { |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 484 | if (cbforward != null) { |
| 485 | cbforward.onReconnectionFailure(AndroidCameraManagerImpl.this); |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 486 | } |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 487 | return false; |
Angus Kong | 20fad24 | 2013-11-11 18:23:46 -0800 | [diff] [blame^] | 488 | } |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 489 | return true; |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 490 | } |
| 491 | |
| 492 | @Override |
| 493 | public void unlock() { |
| 494 | mCameraHandler.sendEmptyMessage(UNLOCK); |
| 495 | mCameraHandler.waitDone(); |
| 496 | } |
| 497 | |
| 498 | @Override |
| 499 | public void lock() { |
| 500 | mCameraHandler.sendEmptyMessage(LOCK); |
| 501 | } |
| 502 | |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 503 | @Override |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 504 | public void setPreviewTexture(SurfaceTexture surfaceTexture) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 505 | mCameraHandler.obtainMessage(SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture).sendToTarget(); |
| 506 | } |
| 507 | |
| 508 | @Override |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 509 | public void setPreviewDisplay(SurfaceHolder surfaceHolder) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 510 | mCameraHandler.obtainMessage(SET_PREVIEW_DISPLAY_ASYNC, surfaceHolder).sendToTarget(); |
| 511 | } |
| 512 | |
| 513 | @Override |
| 514 | public void startPreview() { |
| 515 | mCameraHandler.sendEmptyMessage(START_PREVIEW_ASYNC); |
| 516 | } |
| 517 | |
| 518 | @Override |
| 519 | public void stopPreview() { |
| 520 | mCameraHandler.sendEmptyMessage(STOP_PREVIEW); |
| 521 | mCameraHandler.waitDone(); |
| 522 | } |
| 523 | |
| 524 | @Override |
| 525 | public void setPreviewDataCallback( |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 526 | Handler handler, CameraPreviewDataCallback cb) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 527 | mCameraHandler.obtainMessage( |
| 528 | SET_PREVIEW_CALLBACK, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 529 | PreviewCallbackForward.getNewInstance(handler, this, cb)).sendToTarget(); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 530 | } |
| 531 | |
| 532 | @Override |
| 533 | public void setPreviewDataCallbackWithBuffer( |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 534 | Handler handler, CameraPreviewDataCallback cb) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 535 | mCameraHandler.obtainMessage( |
| 536 | SET_PREVIEW_CALLBACK_WITH_BUFFER, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 537 | PreviewCallbackForward.getNewInstance(handler, this, cb)).sendToTarget(); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 538 | } |
| 539 | |
| 540 | @Override |
| 541 | public void addCallbackBuffer(byte[] callbackBuffer) { |
| 542 | mCameraHandler.obtainMessage(ADD_CALLBACK_BUFFER, callbackBuffer).sendToTarget(); |
| 543 | } |
| 544 | |
| 545 | @Override |
| 546 | public void autoFocus(Handler handler, CameraAFCallback cb) { |
| 547 | mCameraHandler.obtainMessage( |
| 548 | AUTO_FOCUS, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 549 | AFCallbackForward.getNewInstance(handler, this, cb)).sendToTarget(); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 550 | } |
| 551 | |
| 552 | @Override |
| 553 | public void cancelAutoFocus() { |
| 554 | mCameraHandler.removeMessages(AUTO_FOCUS); |
| 555 | mCameraHandler.sendEmptyMessage(CANCEL_AUTO_FOCUS); |
| 556 | } |
| 557 | |
Sascha Haeberling | 638e6f0 | 2013-09-18 14:28:51 -0700 | [diff] [blame] | 558 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN) |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 559 | @Override |
| 560 | public void setAutoFocusMoveCallback( |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 561 | Handler handler, CameraAFMoveCallback cb) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 562 | mCameraHandler.obtainMessage( |
| 563 | SET_AUTO_FOCUS_MOVE_CALLBACK, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 564 | AFMoveCallbackForward.getNewInstance(handler, this, cb)).sendToTarget(); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 565 | } |
| 566 | |
| 567 | @Override |
| 568 | public void takePicture( |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 569 | Handler handler, |
| 570 | CameraShutterCallback shutter, |
| 571 | CameraPictureCallback raw, |
| 572 | CameraPictureCallback post, |
| 573 | CameraPictureCallback jpeg) { |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 574 | mCameraHandler.requestTakePicture( |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 575 | ShutterCallbackForward.getNewInstance(handler, this, shutter), |
| 576 | PictureCallbackForward.getNewInstance(handler, this, raw), |
| 577 | PictureCallbackForward.getNewInstance(handler, this, post), |
| 578 | PictureCallbackForward.getNewInstance(handler, this, jpeg)); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 579 | } |
| 580 | |
| 581 | @Override |
| 582 | public void setDisplayOrientation(int degrees) { |
| 583 | mCameraHandler.obtainMessage(SET_DISPLAY_ORIENTATION, degrees, 0) |
| 584 | .sendToTarget(); |
| 585 | } |
| 586 | |
| 587 | @Override |
| 588 | public void setZoomChangeListener(OnZoomChangeListener listener) { |
| 589 | mCameraHandler.obtainMessage(SET_ZOOM_CHANGE_LISTENER, listener).sendToTarget(); |
| 590 | } |
| 591 | |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 592 | public void setFaceDetectionCallback( |
| 593 | Handler handler, CameraFaceDetectionCallback cb) { |
| 594 | mCameraHandler.obtainMessage( |
| 595 | SET_FACE_DETECTION_LISTENER, |
| 596 | FaceDetectionCallbackForward.getNewInstance(handler, this, cb)).sendToTarget(); |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 597 | } |
| 598 | |
| 599 | @Override |
| 600 | public void startFaceDetection() { |
| 601 | mCameraHandler.sendEmptyMessage(START_FACE_DETECTION); |
| 602 | } |
| 603 | |
| 604 | @Override |
| 605 | public void stopFaceDetection() { |
| 606 | mCameraHandler.sendEmptyMessage(STOP_FACE_DETECTION); |
| 607 | } |
| 608 | |
| 609 | @Override |
| 610 | public void setErrorCallback(ErrorCallback cb) { |
| 611 | mCameraHandler.obtainMessage(SET_ERROR_CALLBACK, cb).sendToTarget(); |
| 612 | } |
| 613 | |
| 614 | @Override |
| 615 | public void setParameters(Parameters params) { |
| 616 | if (params == null) { |
| 617 | Log.v(TAG, "null parameters in setParameters()"); |
| 618 | return; |
| 619 | } |
| 620 | mCameraHandler.obtainMessage(SET_PARAMETERS, params.flatten()) |
| 621 | .sendToTarget(); |
| 622 | } |
| 623 | |
| 624 | @Override |
| 625 | public Parameters getParameters() { |
| 626 | mCameraHandler.sendEmptyMessage(GET_PARAMETERS); |
| 627 | mCameraHandler.waitDone(); |
| 628 | return mParameters; |
| 629 | } |
| 630 | |
| 631 | @Override |
| 632 | public void refreshParameters() { |
| 633 | mCameraHandler.sendEmptyMessage(REFRESH_PARAMETERS); |
| 634 | } |
| 635 | |
| 636 | @Override |
| 637 | public void enableShutterSound(boolean enable) { |
| 638 | mCameraHandler.obtainMessage( |
| 639 | ENABLE_SHUTTER_SOUND, (enable ? 1 : 0), 0).sendToTarget(); |
| 640 | } |
| 641 | } |
| 642 | |
| 643 | /** |
| 644 | * A helper class to forward AutoFocusCallback to another thread. |
| 645 | */ |
| 646 | private static class AFCallbackForward implements AutoFocusCallback { |
| 647 | private final Handler mHandler; |
| 648 | private final CameraProxy mCamera; |
| 649 | private final CameraAFCallback mCallback; |
| 650 | |
| 651 | /** |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 652 | * Returns a new instance of {@link AFCallbackForward}. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 653 | * |
| 654 | * @param handler The handler in which the callback will be invoked in. |
| 655 | * @param camera The {@link CameraProxy} which the callback is from. |
| 656 | * @param cb The callback to be invoked. |
| 657 | * @return The instance of the {@link AFCallbackForward}, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 658 | * or null if any parameter is null. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 659 | */ |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 660 | public static AFCallbackForward getNewInstance( |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 661 | Handler handler, CameraProxy camera, CameraAFCallback cb) { |
| 662 | if (handler == null || camera == null || cb == null) return null; |
| 663 | return new AFCallbackForward(handler, camera, cb); |
| 664 | } |
| 665 | |
| 666 | private AFCallbackForward( |
| 667 | Handler h, CameraProxy camera, CameraAFCallback cb) { |
| 668 | mHandler = h; |
| 669 | mCamera = camera; |
| 670 | mCallback = cb; |
| 671 | } |
| 672 | |
| 673 | @Override |
| 674 | public void onAutoFocus(final boolean b, Camera camera) { |
| 675 | mHandler.post(new Runnable() { |
| 676 | @Override |
| 677 | public void run() { |
| 678 | mCallback.onAutoFocus(b, mCamera); |
| 679 | } |
| 680 | }); |
| 681 | } |
| 682 | } |
| 683 | |
| 684 | /** A helper class to forward AutoFocusMoveCallback to another thread. */ |
Sascha Haeberling | 638e6f0 | 2013-09-18 14:28:51 -0700 | [diff] [blame] | 685 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN) |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 686 | private static class AFMoveCallbackForward implements AutoFocusMoveCallback { |
| 687 | private final Handler mHandler; |
| 688 | private final CameraAFMoveCallback mCallback; |
| 689 | private final CameraProxy mCamera; |
| 690 | |
| 691 | /** |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 692 | * Returns a new instance of {@link AFMoveCallbackForward}. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 693 | * |
| 694 | * @param handler The handler in which the callback will be invoked in. |
| 695 | * @param camera The {@link CameraProxy} which the callback is from. |
| 696 | * @param cb The callback to be invoked. |
| 697 | * @return The instance of the {@link AFMoveCallbackForward}, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 698 | * or null if any parameter is null. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 699 | */ |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 700 | public static AFMoveCallbackForward getNewInstance( |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 701 | Handler handler, CameraProxy camera, CameraAFMoveCallback cb) { |
| 702 | if (handler == null || camera == null || cb == null) return null; |
| 703 | return new AFMoveCallbackForward(handler, camera, cb); |
| 704 | } |
| 705 | |
| 706 | private AFMoveCallbackForward( |
| 707 | Handler h, CameraProxy camera, CameraAFMoveCallback cb) { |
| 708 | mHandler = h; |
| 709 | mCamera = camera; |
| 710 | mCallback = cb; |
| 711 | } |
| 712 | |
| 713 | @Override |
| 714 | public void onAutoFocusMoving( |
| 715 | final boolean moving, android.hardware.Camera camera) { |
| 716 | mHandler.post(new Runnable() { |
| 717 | @Override |
| 718 | public void run() { |
| 719 | mCallback.onAutoFocusMoving(moving, mCamera); |
| 720 | } |
| 721 | }); |
| 722 | } |
| 723 | } |
| 724 | |
| 725 | /** |
| 726 | * A helper class to forward ShutterCallback to to another thread. |
| 727 | */ |
| 728 | private static class ShutterCallbackForward implements ShutterCallback { |
| 729 | private final Handler mHandler; |
| 730 | private final CameraShutterCallback mCallback; |
| 731 | private final CameraProxy mCamera; |
| 732 | |
| 733 | /** |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 734 | * Returns a new instance of {@link ShutterCallbackForward}. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 735 | * |
| 736 | * @param handler The handler in which the callback will be invoked in. |
| 737 | * @param camera The {@link CameraProxy} which the callback is from. |
| 738 | * @param cb The callback to be invoked. |
| 739 | * @return The instance of the {@link ShutterCallbackForward}, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 740 | * or null if any parameter is null. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 741 | */ |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 742 | public static ShutterCallbackForward getNewInstance( |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 743 | Handler handler, CameraProxy camera, CameraShutterCallback cb) { |
| 744 | if (handler == null || camera == null || cb == null) return null; |
| 745 | return new ShutterCallbackForward(handler, camera, cb); |
| 746 | } |
| 747 | |
| 748 | private ShutterCallbackForward( |
| 749 | Handler h, CameraProxy camera, CameraShutterCallback cb) { |
| 750 | mHandler = h; |
| 751 | mCamera = camera; |
| 752 | mCallback = cb; |
| 753 | } |
| 754 | |
| 755 | @Override |
| 756 | public void onShutter() { |
| 757 | mHandler.post(new Runnable() { |
| 758 | @Override |
| 759 | public void run() { |
| 760 | mCallback.onShutter(mCamera); |
| 761 | } |
| 762 | }); |
| 763 | } |
| 764 | } |
| 765 | |
| 766 | /** |
| 767 | * A helper class to forward PictureCallback to another thread. |
| 768 | */ |
| 769 | private static class PictureCallbackForward implements PictureCallback { |
| 770 | private final Handler mHandler; |
| 771 | private final CameraPictureCallback mCallback; |
| 772 | private final CameraProxy mCamera; |
| 773 | |
| 774 | /** |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 775 | * Returns a new instance of {@link PictureCallbackForward}. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 776 | * |
| 777 | * @param handler The handler in which the callback will be invoked in. |
| 778 | * @param camera The {@link CameraProxy} which the callback is from. |
| 779 | * @param cb The callback to be invoked. |
| 780 | * @return The instance of the {@link PictureCallbackForward}, |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 781 | * or null if any parameters is null. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 782 | */ |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 783 | public static PictureCallbackForward getNewInstance( |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 784 | Handler handler, CameraProxy camera, CameraPictureCallback cb) { |
| 785 | if (handler == null || camera == null || cb == null) return null; |
| 786 | return new PictureCallbackForward(handler, camera, cb); |
| 787 | } |
| 788 | |
| 789 | private PictureCallbackForward( |
| 790 | Handler h, CameraProxy camera, CameraPictureCallback cb) { |
| 791 | mHandler = h; |
| 792 | mCamera = camera; |
| 793 | mCallback = cb; |
| 794 | } |
| 795 | |
| 796 | @Override |
| 797 | public void onPictureTaken( |
| 798 | final byte[] data, android.hardware.Camera camera) { |
| 799 | mHandler.post(new Runnable() { |
| 800 | @Override |
| 801 | public void run() { |
| 802 | mCallback.onPictureTaken(data, mCamera); |
| 803 | } |
| 804 | }); |
| 805 | } |
| 806 | } |
| 807 | |
| 808 | /** |
| 809 | * A helper class to forward PreviewCallback to another thread. |
| 810 | */ |
| 811 | private static class PreviewCallbackForward implements PreviewCallback { |
| 812 | private final Handler mHandler; |
| 813 | private final CameraPreviewDataCallback mCallback; |
| 814 | private final CameraProxy mCamera; |
| 815 | |
| 816 | /** |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 817 | * Returns a new instance of {@link PreviewCallbackForward}. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 818 | * |
| 819 | * @param handler The handler in which the callback will be invoked in. |
| 820 | * @param camera The {@link CameraProxy} which the callback is from. |
| 821 | * @param cb The callback to be invoked. |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 822 | * @return The instance of the {@link PreviewCallbackForward}, |
| 823 | * or null if any parameters is null. |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 824 | */ |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 825 | public static PreviewCallbackForward getNewInstance( |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 826 | Handler handler, CameraProxy camera, CameraPreviewDataCallback cb) { |
| 827 | if (handler == null || camera == null || cb == null) return null; |
| 828 | return new PreviewCallbackForward(handler, camera, cb); |
| 829 | } |
| 830 | |
| 831 | private PreviewCallbackForward( |
| 832 | Handler h, CameraProxy camera, CameraPreviewDataCallback cb) { |
| 833 | mHandler = h; |
| 834 | mCamera = camera; |
| 835 | mCallback = cb; |
| 836 | } |
| 837 | |
| 838 | @Override |
| 839 | public void onPreviewFrame( |
| 840 | final byte[] data, android.hardware.Camera camera) { |
| 841 | mHandler.post(new Runnable() { |
| 842 | @Override |
| 843 | public void run() { |
| 844 | mCallback.onPreviewFrame(data, mCamera); |
| 845 | } |
| 846 | }); |
| 847 | } |
| 848 | } |
Angus Kong | 9e76552 | 2013-07-31 14:05:20 -0700 | [diff] [blame] | 849 | |
| 850 | private static class FaceDetectionCallbackForward implements FaceDetectionListener { |
| 851 | private final Handler mHandler; |
| 852 | private final CameraFaceDetectionCallback mCallback; |
| 853 | private final CameraProxy mCamera; |
| 854 | |
| 855 | /** |
| 856 | * Returns a new instance of {@link FaceDetectionCallbackForward}. |
| 857 | * |
| 858 | * @param handler The handler in which the callback will be invoked in. |
| 859 | * @param camera The {@link CameraProxy} which the callback is from. |
| 860 | * @param cb The callback to be invoked. |
| 861 | * @return The instance of the {@link FaceDetectionCallbackForward}, |
| 862 | * or null if any parameter is null. |
| 863 | */ |
| 864 | public static FaceDetectionCallbackForward getNewInstance( |
| 865 | Handler handler, CameraProxy camera, CameraFaceDetectionCallback cb) { |
| 866 | if (handler == null || camera == null || cb == null) return null; |
| 867 | return new FaceDetectionCallbackForward(handler, camera, cb); |
| 868 | } |
| 869 | |
| 870 | private FaceDetectionCallbackForward( |
| 871 | Handler h, CameraProxy camera, CameraFaceDetectionCallback cb) { |
| 872 | mHandler = h; |
| 873 | mCamera = camera; |
| 874 | mCallback = cb; |
| 875 | } |
| 876 | |
| 877 | @Override |
| 878 | public void onFaceDetection( |
| 879 | final Camera.Face[] faces, Camera camera) { |
| 880 | mHandler.post(new Runnable() { |
| 881 | @Override |
| 882 | public void run() { |
| 883 | mCallback.onFaceDetection(faces, mCamera); |
| 884 | } |
| 885 | }); |
| 886 | } |
| 887 | } |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 888 | |
| 889 | /** |
| 890 | * A callback helps to invoke the original callback on another |
| 891 | * {@link android.os.Handler}. |
| 892 | */ |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 893 | private static class CameraOpenCallbackForward implements CameraOpenCallback { |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 894 | private final Handler mHandler; |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 895 | private final CameraOpenCallback mCallback; |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 896 | |
| 897 | /** |
| 898 | * Returns a new instance of {@link FaceDetectionCallbackForward}. |
| 899 | * |
| 900 | * @param handler The handler in which the callback will be invoked in. |
| 901 | * @param cb The callback to be invoked. |
| 902 | * @return The instance of the {@link FaceDetectionCallbackForward}, or |
| 903 | * null if any parameter is null. |
| 904 | */ |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 905 | public static CameraOpenCallbackForward getNewInstance( |
| 906 | Handler handler, CameraOpenCallback cb) { |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 907 | if (handler == null || cb == null) { |
| 908 | return null; |
| 909 | } |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 910 | return new CameraOpenCallbackForward(handler, cb); |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 911 | } |
| 912 | |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 913 | private CameraOpenCallbackForward(Handler h, CameraOpenCallback cb) { |
ztenghui | e1aa59b | 2013-10-25 14:56:32 -0700 | [diff] [blame] | 914 | // Given that we are using the main thread handler, we can create it |
| 915 | // here instead of holding onto the PhotoModule objects. In this |
| 916 | // way, we can avoid memory leak. |
| 917 | mHandler = new Handler(Looper.getMainLooper()); |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 918 | mCallback = cb; |
| 919 | } |
| 920 | |
| 921 | @Override |
Angus Kong | 6284815 | 2013-11-08 17:25:29 -0800 | [diff] [blame] | 922 | public void onCameraOpened(final CameraProxy camera) { |
| 923 | mHandler.post(new Runnable() { |
| 924 | @Override |
| 925 | public void run() { |
| 926 | mCallback.onCameraOpened(camera); |
| 927 | } |
| 928 | }); |
| 929 | } |
| 930 | |
| 931 | @Override |
Angus Kong | 4f795b8 | 2013-09-16 14:25:35 -0700 | [diff] [blame] | 932 | public void onCameraDisabled(final int cameraId) { |
| 933 | mHandler.post(new Runnable() { |
| 934 | @Override |
| 935 | public void run() { |
| 936 | mCallback.onCameraDisabled(cameraId); |
| 937 | } |
| 938 | }); |
| 939 | } |
| 940 | |
| 941 | @Override |
| 942 | public void onDeviceOpenFailure(final int cameraId) { |
| 943 | mHandler.post(new Runnable() { |
| 944 | @Override |
| 945 | public void run() { |
| 946 | mCallback.onDeviceOpenFailure(cameraId); |
| 947 | } |
| 948 | }); |
| 949 | } |
| 950 | |
| 951 | @Override |
| 952 | public void onReconnectionFailure(final CameraManager mgr) { |
| 953 | mHandler.post(new Runnable() { |
| 954 | @Override |
| 955 | public void run() { |
| 956 | mCallback.onReconnectionFailure(mgr); |
| 957 | } |
| 958 | }); |
| 959 | } |
| 960 | } |
Angus Kong | 9ef9925 | 2013-07-18 18:04:19 -0700 | [diff] [blame] | 961 | } |