Overhaul error handling in AndroidCameraAgentImpl.

DispatchThread could throw RTE when timeout (2500 ms). This CL extends
it to 3500 ms and also re-route the exception to the proper exception
callback instead of surfacing that up to the app. Since a lot of try-catch
block is added, CameraExceptionHandler class is added to keep
CameraAgent.java clean.

The portability layer should ensure the proper use of Camera API 1. With
this assumption, any run time exception thrown by the framework should be
considered fatal. Once it happened, CameraAgent/CameraProxy should be
invalidated. Any subsequent camera commands should be gated as no-ops to
prevent HAL hanging symptom. Users should be guided to exit the app and
recover from the camera error.

Design Doc:
https://docs.google.com/a/google.com/document/d/1t0sEPwGgc387XcoCVC7kT9Y_RSZPxcayla03M4bdn0U/edit

Corresponding CL for the app layer: ag/562383

Bug: 16189216
Change-Id: I33e69aeff0c8e4211e82e0e83133915700c4eb8f

5 files changed, 653 insertions, 336 deletions

diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java
index a746634..ae4c208 100644
--- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java
+++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCamera2AgentImpl.java
@@ -65,6 +65,7 @@ class AndroidCamera2AgentImpl extends CameraAgent {
     private final DispatchThread mDispatchThread;
     private final CameraManager mCameraManager;
     private final MediaActionSound mNoisemaker;
+    private CameraExceptionHandler mExceptionHandler;
 
     /**
      * Number of camera devices.  The length of {@code mCameraDevices} does not reveal this
@@ -86,6 +87,7 @@ class AndroidCamera2AgentImpl extends CameraAgent {
         mCameraHandlerThread = new HandlerThread("Camera2 Handler Thread");
         mCameraHandlerThread.start();
         mCameraHandler = new Camera2Handler(mCameraHandlerThread.getLooper());
+        mExceptionHandler = new CameraExceptionHandler(mCameraHandler);
         mCameraState = new AndroidCamera2StateHolder();
         mDispatchThread = new DispatchThread(mCameraHandler, mCameraHandlerThread);
         mDispatchThread.start();
@@ -134,11 +136,6 @@ class AndroidCamera2AgentImpl extends CameraAgent {
 
     // TODO: Implement
     @Override
-    public void setCameraDefaultExceptionCallback(CameraExceptionCallback callback,
-            Handler handler) {}
-
-    // TODO: Implement
-    @Override
     public void recycle() {}
 
     // TODO: Some indices may now be invalid; ensure everyone can handle that and update the docs
@@ -159,6 +156,21 @@ class AndroidCamera2AgentImpl extends CameraAgent {
         return mDispatchThread;
     }
 
+    @Override
+    protected CameraStateHolder getCameraState() {
+        return mCameraState;
+    }
+
+    @Override
+    protected CameraExceptionHandler getCameraExceptionHandler() {
+        return mExceptionHandler;
+    }
+
+    @Override
+    public void setCameraExceptionHandler(CameraExceptionHandler exceptionHandler) {
+        mExceptionHandler = exceptionHandler;
+    }
+
     private static abstract class CaptureAvailableListener
             extends CameraCaptureSession.CaptureCallback
             implements ImageReader.OnImageAvailableListener {};
@@ -645,11 +657,7 @@ class AndroidCamera2AgentImpl extends CameraAgent {
                 }
 
                 if (ex instanceof RuntimeException) {
-                    post(new Runnable() {
-                        @Override
-                        public void run() {
-                            sCameraExceptionCallback.onCameraException((RuntimeException) ex);
-                        }});
+                    mExceptionHandler.onCameraException((RuntimeException) ex);
                 }
             } finally {
                 WaitDoneBundle.unblockSyncWaiters(msg);
@@ -771,8 +779,10 @@ class AndroidCamera2AgentImpl extends CameraAgent {
                     try {
                         CameraCharacteristics props =
                                 mCameraManager.getCameraCharacteristics(mCameraId);
-                        mCameraProxy = new AndroidCamera2ProxyImpl(mCameraIndex, mCamera,
-                                    getCameraDeviceInfo().getCharacteristics(mCameraIndex), props);
+                        CameraDeviceInfo.Characteristics characteristics =
+                                getCameraDeviceInfo().getCharacteristics(mCameraIndex);
+                        mCameraProxy = new AndroidCamera2ProxyImpl(AndroidCamera2AgentImpl.this,
+                                mCameraIndex, mCamera, characteristics, props);
                         mPersistentSettings = new Camera2RequestSettingsSet();
                         mActiveArray =
                                 props.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
@@ -960,6 +970,7 @@ class AndroidCamera2AgentImpl extends CameraAgent {
     }
 
     private class AndroidCamera2ProxyImpl extends CameraAgent.CameraProxy {
+        private final AndroidCamera2AgentImpl mCameraAgent;
         private final int mCameraIndex;
         private final CameraDevice mCamera;
         private final CameraDeviceInfo.Characteristics mCharacteristics;
@@ -967,9 +978,13 @@ class AndroidCamera2AgentImpl extends CameraAgent {
         private CameraSettings mLastSettings;
         private boolean mShutterSoundEnabled;
 
-        public AndroidCamera2ProxyImpl(int cameraIndex, CameraDevice camera,
+        public AndroidCamera2ProxyImpl(
+                AndroidCamera2AgentImpl agent,
+                int cameraIndex,
+                CameraDevice camera,
                 CameraDeviceInfo.Characteristics characteristics,
                 CameraCharacteristics properties) {
+            mCameraAgent = agent;
             mCameraIndex = cameraIndex;
             mCamera = camera;
             mCharacteristics = characteristics;
@@ -997,6 +1012,10 @@ class AndroidCamera2AgentImpl extends CameraAgent {
             return mCapabilities;
         }
 
+        public CameraAgent getAgent() {
+            return mCameraAgent;
+        }
+
         private AndroidCamera2Capabilities getSpecializedCapabilities() {
             return mCapabilities;
         }
@@ -1039,53 +1058,67 @@ class AndroidCamera2AgentImpl extends CameraAgent {
 
         @Override
         public void autoFocus(final Handler handler, final CameraAFCallback cb) {
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    CameraAFCallback cbForward = null;
-                    if (cb != null) {
-                        cbForward = new CameraAFCallback() {
-                            @Override
-                            public void onAutoFocus(final boolean focused,
-                                                    final CameraProxy camera) {
-                                handler.post(new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        cb.onAutoFocus(focused, camera);
-                                    }});
-                            }};
-                    }
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        CameraAFCallback cbForward = null;
+                        if (cb != null) {
+                            cbForward = new CameraAFCallback() {
+                                @Override
+                                public void onAutoFocus(final boolean focused,
+                                                        final CameraProxy camera) {
+                                    handler.post(new Runnable() {
+                                        @Override
+                                        public void run() {
+                                            cb.onAutoFocus(focused, camera);
+                                        }
+                                    });
+                                }
+                            };
+                        }
 
-                    mCameraState.waitForStates(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE |
-                            AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED);
-                    mCameraHandler.obtainMessage(CameraActions.AUTO_FOCUS, cbForward)
-                            .sendToTarget();
-                }});
+                        mCameraState.waitForStates(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE |
+                                AndroidCamera2StateHolder.CAMERA_FOCUS_LOCKED);
+                        mCameraHandler.obtainMessage(CameraActions.AUTO_FOCUS, cbForward)
+                                .sendToTarget();
+                    }
+                });
+            } catch (RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
         @Override
         public void setAutoFocusMoveCallback(final Handler handler, final CameraAFMoveCallback cb) {
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    CameraAFMoveCallback cbForward = null;
-                    if (cb != null) {
-                        cbForward = new CameraAFMoveCallback() {
-                            @Override
-                            public void onAutoFocusMoving(final boolean moving,
-                                                          final CameraProxy camera) {
-                                handler.post(new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        cb.onAutoFocusMoving(moving, camera);
-                                    }});
-                                }};
-                    }
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        CameraAFMoveCallback cbForward = null;
+                        if (cb != null) {
+                            cbForward = new CameraAFMoveCallback() {
+                                @Override
+                                public void onAutoFocusMoving(final boolean moving,
+                                                              final CameraProxy camera) {
+                                    handler.post(new Runnable() {
+                                        @Override
+                                        public void run() {
+                                            cb.onAutoFocusMoving(moving, camera);
+                                        }
+                                    });
+                                }
+                            };
+                        }
 
-                    mCameraHandler.obtainMessage(CameraActions.SET_AUTO_FOCUS_MOVE_CALLBACK,
-                            cbForward).sendToTarget();
-                }});
+                        mCameraHandler.obtainMessage(CameraActions.SET_AUTO_FOCUS_MOVE_CALLBACK,
+                                cbForward).sendToTarget();
+                    }
+                });
+            } catch (RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Override
@@ -1127,15 +1160,20 @@ class AndroidCamera2AgentImpl extends CameraAgent {
                         }
                     }
                 }};
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    // Wait until PREVIEW_ACTIVE or better
-                    mCameraState.waitForStates(
-                            ~(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE - 1));
-                    mCameraHandler.obtainMessage(CameraActions.CAPTURE_PHOTO, picListener)
-                            .sendToTarget();
-                }});
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        // Wait until PREVIEW_ACTIVE or better
+                        mCameraState.waitForStates(
+                                ~(AndroidCamera2StateHolder.CAMERA_PREVIEW_ACTIVE - 1));
+                        mCameraHandler.obtainMessage(CameraActions.CAPTURE_PHOTO, picListener)
+                                .sendToTarget();
+                    }
+                });
+            } catch (RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         // TODO: Implement
@@ -1380,12 +1418,4 @@ class AndroidCamera2AgentImpl extends CameraAgent {
             }
         }
     }
-
-    private static final CameraExceptionCallback sCameraExceptionCallback =
-            new CameraExceptionCallback() {
-                @Override
-                public synchronized void onCameraException(RuntimeException e) {
-                    throw e;
-                }
-            };
 }
diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java
index 6a764f3..8e17276 100644
--- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java
+++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraAgentImpl.java
@@ -55,39 +55,23 @@ class AndroidCameraAgentImpl extends CameraAgent {
     private final HandlerThread mCameraHandlerThread;
     private final CameraStateHolder mCameraState;
     private final DispatchThread mDispatchThread;
-
-    private Handler mCameraExceptionCallbackHandler;
-    private CameraExceptionCallback mCameraExceptionCallback =
-        new CameraExceptionCallback() {
-            @Override
-            public void onCameraException(RuntimeException e) {
-                throw e;
-            }
-        };
+    private CameraExceptionHandler mExceptionHandler;
 
     AndroidCameraAgentImpl() {
         mCameraHandlerThread = new HandlerThread("Camera Handler Thread");
         mCameraHandlerThread.start();
-        mCameraHandler = new CameraHandler(mCameraHandlerThread.getLooper());
-        mCameraExceptionCallbackHandler = mCameraHandler;
+        mCameraHandler = new CameraHandler(this, mCameraHandlerThread.getLooper());
+        mExceptionHandler = new CameraExceptionHandler(mCameraHandler);
         mCameraState = new AndroidCameraStateHolder();
         mDispatchThread = new DispatchThread(mCameraHandler, mCameraHandlerThread);
         mDispatchThread.start();
     }
 
     @Override
-    public void setCameraDefaultExceptionCallback(CameraExceptionCallback callback,
-            Handler handler) {
-        synchronized (mCameraExceptionCallback) {
-            mCameraExceptionCallback = callback;
-            mCameraExceptionCallbackHandler = handler;
-        }
-    }
-
-    @Override
     public void recycle() {
         closeCamera(null, true);
         mDispatchThread.end();
+        mCameraState.invalidate();
     }
 
     @Override
@@ -105,6 +89,21 @@ class AndroidCameraAgentImpl extends CameraAgent {
         return mDispatchThread;
     }
 
+    @Override
+    protected CameraStateHolder getCameraState() {
+        return mCameraState;
+    }
+
+    @Override
+    protected CameraExceptionHandler getCameraExceptionHandler() {
+        return mExceptionHandler;
+    }
+
+    @Override
+    public void setCameraExceptionHandler(CameraExceptionHandler exceptionHandler) {
+        mExceptionHandler = exceptionHandler;
+    }
+
     private static class AndroidCameraDeviceInfo implements CameraDeviceInfo {
         private final Camera.CameraInfo[] mCameraInfos;
         private final int mNumberOfCameras;
@@ -238,7 +237,7 @@ class AndroidCameraAgentImpl extends CameraAgent {
      * The handler on which the actual camera operations happen.
      */
     private class CameraHandler extends HistoryHandler {
-
+        private CameraAgent mAgent;
         private Camera mCamera;
         private int mCameraId;
         private ParametersCache mParameterCache;
@@ -259,8 +258,9 @@ class AndroidCameraAgentImpl extends CameraAgent {
             }
         }
 
-        CameraHandler(Looper looper) {
+        CameraHandler(CameraAgent agent, Looper looper) {
             super(looper);
+            mAgent = agent;
         }
 
         private void startFaceDetection() {
@@ -298,16 +298,6 @@ class AndroidCameraAgentImpl extends CameraAgent {
             }
         }
 
-        private void capture(final CaptureCallbacks cb) {
-            try {
-                mCamera.takePicture(cb.mShutter, cb.mRaw, cb.mPostView, cb.mJpeg);
-            } catch (RuntimeException e) {
-                // TODO: output camera state and focus state for debugging.
-                Log.e(TAG, "take picture failed.");
-                throw e;
-            }
-        }
-
         public void requestTakePicture(
                 final ShutterCallback shutter,
                 final PictureCallback raw,
@@ -324,7 +314,13 @@ class AndroidCameraAgentImpl extends CameraAgent {
         @Override
         public void handleMessage(final Message msg) {
             super.handleMessage(msg);
+
+            if (getCameraState().isInvalid()) {
+                Log.v(TAG, "Skip handleMessage - action = '" + CameraActions.stringify(msg.what) + "'");
+                return;
+            }
             Log.v(TAG, "handleMessage - action = '" + CameraActions.stringify(msg.what) + "'");
+
             try {
                 switch (msg.what) {
                     case CameraActions.OPEN_CAMERA: {
@@ -348,9 +344,9 @@ class AndroidCameraAgentImpl extends CameraAgent {
 
                             mCameraState.setState(AndroidCameraStateHolder.CAMERA_IDLE);
                             if (openCallback != null) {
-                                openCallback.onCameraOpened(
-                                        new AndroidCameraProxyImpl(cameraId, mCamera,
-                                                mCharacteristics, mCapabilities));
+                                CameraProxy cameraProxy = new AndroidCameraProxyImpl(
+                                        mAgent, cameraId, mCamera, mCharacteristics, mCapabilities);
+                                openCallback.onCameraOpened(cameraProxy);
                             }
                         } else {
                             if (openCallback != null) {
@@ -379,8 +375,7 @@ class AndroidCameraAgentImpl extends CameraAgent {
                             mCamera.reconnect();
                         } catch (IOException ex) {
                             if (cbForward != null) {
-                                cbForward.onReconnectionFailure(AndroidCameraAgentImpl.this,
-                                        generateHistoryString(mCameraId));
+                                cbForward.onReconnectionFailure(mAgent, generateHistoryString(mCameraId));
                             }
                             break;
                         }
@@ -388,8 +383,8 @@ class AndroidCameraAgentImpl extends CameraAgent {
                         mCameraState.setState(AndroidCameraStateHolder.CAMERA_IDLE);
                         if (cbForward != null) {
                             cbForward.onCameraOpened(
-                                    new AndroidCameraProxyImpl(cameraId, mCamera, mCharacteristics,
-                                            mCapabilities));
+                                    new AndroidCameraProxyImpl(AndroidCameraAgentImpl.this,
+                                            cameraId, mCamera, mCharacteristics, mCapabilities));
                         }
                         break;
                     }
@@ -573,45 +568,49 @@ class AndroidCameraAgentImpl extends CameraAgent {
 
                     case CameraActions.CAPTURE_PHOTO: {
                         mCameraState.setState(AndroidCameraStateHolder.CAMERA_CAPTURING);
-                        capture((CaptureCallbacks) msg.obj);
+                        CaptureCallbacks captureCallbacks = (CaptureCallbacks) msg.obj;
+                        mCamera.takePicture(
+                                captureCallbacks.mShutter,
+                                captureCallbacks.mRaw,
+                                captureCallbacks.mPostView,
+                                captureCallbacks.mJpeg);
                         break;
                     }
 
                     default: {
-                        throw new RuntimeException("Invalid CameraProxy message=" + msg.what);
+                        Log.e(TAG, "Invalid CameraProxy message=" + msg.what);
                     }
                 }
-            } catch (final RuntimeException e) {
-                Log.e(TAG, "Exception during camera operation " + msg.what, e);
-                if (msg.what != CameraActions.RELEASE && mCamera != null) {
+            } catch (final RuntimeException ex) {
+                String cameraAction = CameraActions.stringify(msg.what);
+                int cameraState = mCameraState.getState();
+                String errorContext =
+                        "CameraAction[" + cameraAction + "] at CameraState[" + cameraState + "]";
+                Log.e(TAG, "RuntimeException during " + errorContext, ex);
+
+                // Be conservative by invalidating both CameraAgent and CameraProxy objects.
+                mCameraState.invalidate();
+
+                if (mCamera != null) {
+                    Log.i(TAG, "Release camera since mCamera is not null.");
                     try {
                         mCamera.release();
-                        mCameraState.setState(AndroidCameraStateHolder.CAMERA_UNOPENED);
-                    } catch (Exception ex) {
-                        Log.e(TAG, "Fail to release the camera.");
-                    }
-                    mCamera = null;
-                } else {
-                    if (mCamera == null) {
-                        if (msg.what == CameraActions.OPEN_CAMERA) {
-                            final int cameraId = msg.arg1;
-                            if (msg.obj != null) {
-                                ((CameraOpenCallback) msg.obj).onDeviceOpenFailure(
-                                        msg.arg1, generateHistoryString(cameraId));
-                            }
-                        } else {
-                            Log.w(TAG, "Cannot handle message " + msg.what + ", mCamera is null.");
-                        }
-                        return;
+                    } catch (Exception e) {
+                        Log.e(TAG, "Fail when calling Camera.release().", e);
+                    } finally {
+                        mCamera = null;
                     }
                 }
-                synchronized (mCameraExceptionCallback) {
-                    mCameraExceptionCallbackHandler.post(new Runnable() {
-                        @Override
-                        public void run() {
-                                mCameraExceptionCallback.onCameraException(e);
-                            }
-                        });
+
+                // Invoke error callback.
+                if (msg.what == CameraActions.OPEN_CAMERA && mCamera == null) {
+                    final int cameraId = msg.arg1;
+                    if (msg.obj != null) {
+                        ((CameraOpenCallback) msg.obj).onDeviceOpenFailure(
+                                msg.arg1, generateHistoryString(cameraId));
+                    }
+                } else {
+                    mAgent.getCameraExceptionHandler().onCameraException(ex);
                 }
             } finally {
                 WaitDoneBundle.unblockSyncWaiters(msg);
@@ -722,15 +721,20 @@ class AndroidCameraAgentImpl extends CameraAgent {
      * camera handler thread.
      */
     private class AndroidCameraProxyImpl extends CameraAgent.CameraProxy {
+        private final CameraAgent mCameraAgent;
         private final int mCameraId;
         /* TODO: remove this Camera instance. */
         private final Camera mCamera;
         private final CameraDeviceInfo.Characteristics mCharacteristics;
         private final AndroidCameraCapabilities mCapabilities;
 
-        private AndroidCameraProxyImpl(int cameraId, Camera camera,
+        private AndroidCameraProxyImpl(
+                CameraAgent cameraAgent,
+                int cameraId,
+                Camera camera,
                 CameraDeviceInfo.Characteristics characteristics,
                 AndroidCameraCapabilities capabilities) {
+            mCameraAgent = cameraAgent;
             mCamera = camera;
             mCameraId = cameraId;
             mCharacteristics = characteristics;
@@ -740,6 +744,9 @@ class AndroidCameraAgentImpl extends CameraAgent {
         @Deprecated
         @Override
         public android.hardware.Camera getCamera() {
+            if (getCameraState().isInvalid()) {
+                return null;
+            }
             return mCamera;
         }
 
@@ -759,6 +766,11 @@ class AndroidCameraAgentImpl extends CameraAgent {
         }
 
         @Override
+        public CameraAgent getAgent() {
+            return mCameraAgent;
+        }
+
+        @Override
         public void setPreviewDataCallback(
                 final Handler handler, final CameraPreviewDataCallback cb) {
             mDispatchThread.runJob(new Runnable() {
@@ -821,6 +833,10 @@ class AndroidCameraAgentImpl extends CameraAgent {
             mDispatchThread.runJob(new Runnable() {
                 @Override
                 public void run() {
+                    // Don't bother to wait since camera is in bad state.
+                    if (getCameraState().isInvalid()) {
+                        return;
+                    }
                     mCameraState.waitForStates(AndroidCameraStateHolder.CAMERA_IDLE);
                     mCameraHandler.obtainMessage(CameraActions.AUTO_FOCUS, afCallback)
                             .sendToTarget();
@@ -832,15 +848,19 @@ class AndroidCameraAgentImpl extends CameraAgent {
         @Override
         public void setAutoFocusMoveCallback(
                 final Handler handler, final CameraAFMoveCallback cb) {
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraHandler.obtainMessage(CameraActions.SET_AUTO_FOCUS_MOVE_CALLBACK,
-                            AFMoveCallbackForward.getNewInstance(
-                                    handler, AndroidCameraProxyImpl.this, cb))
-                            .sendToTarget();
-                }
-            });
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        mCameraHandler.obtainMessage(CameraActions.SET_AUTO_FOCUS_MOVE_CALLBACK,
+                                AFMoveCallbackForward.getNewInstance(
+                                        handler, AndroidCameraProxyImpl.this, cb))
+                                .sendToTarget();
+                    }
+                });
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Override
@@ -865,59 +885,79 @@ class AndroidCameraAgentImpl extends CameraAgent {
                 }
             };
 
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraState.waitForStates(AndroidCameraStateHolder.CAMERA_IDLE |
-                            AndroidCameraStateHolder.CAMERA_UNLOCKED);
-                    mCameraHandler.requestTakePicture(ShutterCallbackForward
-                                    .getNewInstance(handler, AndroidCameraProxyImpl.this, shutter),
-                            PictureCallbackForward
-                                    .getNewInstance(handler, AndroidCameraProxyImpl.this, raw),
-                            PictureCallbackForward
-                                    .getNewInstance(handler, AndroidCameraProxyImpl.this, post),
-                            jpegCallback
-                    );
-                }
-            });
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        // Don't bother to wait since camera is in bad state.
+                        if (getCameraState().isInvalid()) {
+                            return;
+                        }
+                        mCameraState.waitForStates(AndroidCameraStateHolder.CAMERA_IDLE |
+                                AndroidCameraStateHolder.CAMERA_UNLOCKED);
+                        mCameraHandler.requestTakePicture(ShutterCallbackForward
+                                        .getNewInstance(handler, AndroidCameraProxyImpl.this, shutter),
+                                PictureCallbackForward
+                                        .getNewInstance(handler, AndroidCameraProxyImpl.this, raw),
+                                PictureCallbackForward
+                                        .getNewInstance(handler, AndroidCameraProxyImpl.this, post),
+                                jpegCallback
+                        );
+                    }
+                });
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Override
         public void setZoomChangeListener(final OnZoomChangeListener listener) {
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraHandler.obtainMessage(CameraActions.SET_ZOOM_CHANGE_LISTENER, listener)
-                            .sendToTarget();
-                }
-            });
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        mCameraHandler.obtainMessage(CameraActions.SET_ZOOM_CHANGE_LISTENER, listener)
+                                .sendToTarget();
+                    }
+                });
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Override
         public void setFaceDetectionCallback(final Handler handler,
                 final CameraFaceDetectionCallback cb) {
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraHandler.obtainMessage(CameraActions.SET_FACE_DETECTION_LISTENER,
-                            FaceDetectionCallbackForward
-                                    .getNewInstance(handler, AndroidCameraProxyImpl.this, cb))
-                            .sendToTarget();
-                }
-            });
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        mCameraHandler.obtainMessage(CameraActions.SET_FACE_DETECTION_LISTENER,
+                                FaceDetectionCallbackForward
+                                        .getNewInstance(handler, AndroidCameraProxyImpl.this, cb))
+                                .sendToTarget();
+                    }
+                });
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Override
         public void setErrorCallback(final Handler handler, final CameraErrorCallback cb) {
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraHandler.obtainMessage(CameraActions.SET_ERROR_CALLBACK,
-                            ErrorCallbackForward.getNewInstance(
-                                    handler, AndroidCameraProxyImpl.this, cb))
-                            .sendToTarget();
-                }
-            });
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        mCameraHandler.obtainMessage(CameraActions.SET_ERROR_CALLBACK,
+                                ErrorCallbackForward.getNewInstance(
+                                        handler, AndroidCameraProxyImpl.this, cb))
+                                .sendToTarget();
+                    }
+                });
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Deprecated
@@ -928,15 +968,19 @@ class AndroidCameraAgentImpl extends CameraAgent {
                 return;
             }
             final String flattenedParameters = params.flatten();
-            mDispatchThread.runJob(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraState.waitForStates(AndroidCameraStateHolder.CAMERA_IDLE |
-                            AndroidCameraStateHolder.CAMERA_UNLOCKED);
-                    mCameraHandler.obtainMessage(CameraActions.SET_PARAMETERS, flattenedParameters)
-                            .sendToTarget();
-                }
-            });
+            try {
+                mDispatchThread.runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        mCameraState.waitForStates(AndroidCameraStateHolder.CAMERA_IDLE |
+                                AndroidCameraStateHolder.CAMERA_UNLOCKED);
+                        mCameraHandler.obtainMessage(CameraActions.SET_PARAMETERS, flattenedParameters)
+                                .sendToTarget();
+                    }
+                });
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         @Deprecated
@@ -944,14 +988,18 @@ class AndroidCameraAgentImpl extends CameraAgent {
         public Parameters getParameters() {
             final WaitDoneBundle bundle = new WaitDoneBundle();
             final Parameters[] parametersHolder = new Parameters[1];
-            mDispatchThread.runJobSync(new Runnable() {
-                @Override
-                public void run() {
-                    mCameraHandler.obtainMessage(
-                            CameraActions.GET_PARAMETERS, parametersHolder).sendToTarget();
-                    mCameraHandler.post(bundle.mUnlockRunnable);
-                }
-            }, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "get parameters");
+            try {
+                mDispatchThread.runJobSync(new Runnable() {
+                    @Override
+                    public void run() {
+                        mCameraHandler.obtainMessage(
+                                CameraActions.GET_PARAMETERS, parametersHolder).sendToTarget();
+                        mCameraHandler.post(bundle.mUnlockRunnable);
+                    }
+                }, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "get parameters");
+            } catch (final RuntimeException ex) {
+                mCameraAgent.getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
             return parametersHolder[0];
         }
 
diff --git a/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java b/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java
index 17cbc02..d44cacd 100644
--- a/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java
+++ b/camera2/portability/src/com/android/ex/camera2/portability/CameraAgent.java
@@ -43,7 +43,7 @@ import com.android.ex.camera2.portability.debug.Log;
  * {@code android.hardware.Camera.OnZoomChangeListener}, and
  */
 public abstract class CameraAgent {
-    public static final long CAMERA_OPERATION_TIMEOUT_MS = 2500;
+    public static final long CAMERA_OPERATION_TIMEOUT_MS = 3500;
 
     private static final Log.Tag TAG = new Log.Tag("CamAgnt");
 
@@ -155,14 +155,6 @@ public abstract class CameraAgent {
     }
 
     /**
-     * A handler for all camera api runtime exceptions.
-     * The default behavior is to throw the runtime exception.
-     */
-    public static interface CameraExceptionCallback {
-        public void onCameraException(RuntimeException e);
-    }
-
-    /**
      * An interface which wraps
      * {@link android.hardware.Camera.ErrorCallback}
      */
@@ -293,12 +285,17 @@ public abstract class CameraAgent {
      */
     public void openCamera(final Handler handler, final int cameraId,
                            final CameraOpenCallback callback) {
-        getDispatchThread().runJob(new Runnable() {
-            @Override
-            public void run() {
-                getCameraHandler().obtainMessage(CameraActions.OPEN_CAMERA, cameraId, 0,
-                        CameraOpenCallbackForward.getNewInstance(handler, callback)).sendToTarget();
-            }});
+        try {
+            getDispatchThread().runJob(new Runnable() {
+                @Override
+                public void run() {
+                    getCameraHandler().obtainMessage(CameraActions.OPEN_CAMERA, cameraId, 0,
+                            CameraOpenCallbackForward.getNewInstance(handler, callback)).sendToTarget();
+                }
+            });
+        } catch (final RuntimeException ex) {
+            getCameraExceptionHandler().onDispatchThreadException(ex);
+        }
     }
 
     /**
@@ -308,22 +305,30 @@ public abstract class CameraAgent {
      * @param synced Whether this call should be synchronous.
      */
     public void closeCamera(CameraProxy camera, boolean synced) {
-        if (synced) {
-            final WaitDoneBundle bundle = new WaitDoneBundle();
-
-            getDispatchThread().runJobSync(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().obtainMessage(CameraActions.RELEASE).sendToTarget();
-                    getCameraHandler().post(bundle.mUnlockRunnable);
-                }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera release");
-        } else {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().removeCallbacksAndMessages(null);
-                    getCameraHandler().obtainMessage(CameraActions.RELEASE).sendToTarget();
-                }});
+        try {
+            if (synced) {
+                // Don't bother to wait since camera is in bad state.
+                if (getCameraState().isInvalid()) {
+                    return;
+                }
+                final WaitDoneBundle bundle = new WaitDoneBundle();
+
+                getDispatchThread().runJobSync(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().obtainMessage(CameraActions.RELEASE).sendToTarget();
+                        getCameraHandler().post(bundle.mUnlockRunnable);
+                    }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera release");
+            } else {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().removeCallbacksAndMessages(null);
+                        getCameraHandler().obtainMessage(CameraActions.RELEASE).sendToTarget();
+                    }});
+            }
+        } catch (final RuntimeException ex) {
+            getCameraExceptionHandler().onDispatchThreadException(ex);
         }
     }
 
@@ -331,8 +336,7 @@ public abstract class CameraAgent {
      * Sets a callback for handling camera api runtime exceptions on
      * a handler.
      */
-    public abstract void setCameraDefaultExceptionCallback(CameraExceptionCallback callback,
-            Handler handler);
+    public abstract void setCameraExceptionHandler(CameraExceptionHandler exceptionHandler);
 
     /**
      * Recycles the resources used by this instance. CameraAgent will be in
@@ -356,11 +360,21 @@ public abstract class CameraAgent {
     protected abstract DispatchThread getDispatchThread();
 
     /**
+     * @return The state machine tracking the camera API's current status.
+     */
+    protected abstract CameraStateHolder getCameraState();
+
+    /**
+     * @return The exception handler.
+     */
+    protected abstract CameraExceptionHandler getCameraExceptionHandler();
+
+    /**
      * An interface that takes camera operation requests and post messages to the
      * camera handler thread. All camera operations made through this interface is
      * asynchronous by default except those mentioned specifically.
      */
-    public static abstract class CameraProxy {
+    public abstract static class CameraProxy {
 
         /**
          * Returns the underlying {@link android.hardware.Camera} object used
@@ -388,6 +402,11 @@ public abstract class CameraAgent {
         public abstract CameraCapabilities getCapabilities();
 
         /**
+         * @return The camera agent which creates this proxy.
+         */
+        public abstract CameraAgent getAgent();
+
+        /**
          * Reconnects to the camera device. On success, the camera device will
          * be returned through {@link CameraAgent
          * .CameraOpenCallback#onCameraOpened(com.android.camera.cameradevice.CameraAgent
@@ -399,12 +418,16 @@ public abstract class CameraAgent {
          * @param cb The callback when any error happens.
          */
         public void reconnect(final Handler handler, final CameraOpenCallback cb) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().obtainMessage(CameraActions.RECONNECT, getCameraId(), 0,
-                            CameraOpenCallbackForward.getNewInstance(handler, cb)).sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().obtainMessage(CameraActions.RECONNECT, getCameraId(), 0,
+                                CameraOpenCallbackForward.getNewInstance(handler, cb)).sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -413,13 +436,22 @@ public abstract class CameraAgent {
          * @see android.hardware.Camera#unlock()
          */
         public void unlock() {
+            // Don't bother to wait since camera is in bad state.
+            if (getCameraState().isInvalid()) {
+                return;
+            }
             final WaitDoneBundle bundle = new WaitDoneBundle();
-            getDispatchThread().runJobSync(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().sendEmptyMessage(CameraActions.UNLOCK);
-                    getCameraHandler().post(bundle.mUnlockRunnable);
-                }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera unlock");
+            try {
+                getDispatchThread().runJobSync(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().sendEmptyMessage(CameraActions.UNLOCK);
+                        getCameraHandler().post(bundle.mUnlockRunnable);
+                    }
+                }, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera unlock");
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -427,11 +459,15 @@ public abstract class CameraAgent {
          * @see android.hardware.Camera#lock()
          */
         public void lock() {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().sendEmptyMessage(CameraActions.LOCK);
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().sendEmptyMessage(CameraActions.LOCK);
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -456,13 +492,17 @@ public abstract class CameraAgent {
         // the STOP_PREVIEW case in its handler; in the meantime, changing API 2
         // sizes would require closing and reopening the camera.
         public void setPreviewTexture(final SurfaceTexture surfaceTexture) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture)
-                            .sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture)
+                                .sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -480,15 +520,23 @@ public abstract class CameraAgent {
          * @see CameraSettings#setPreviewSize
          */
         public void setPreviewTextureSync(final SurfaceTexture surfaceTexture) {
+            // Don't bother to wait since camera is in bad state.
+            if (getCameraState().isInvalid()) {
+                return;
+            }
             final WaitDoneBundle bundle = new WaitDoneBundle();
-            getDispatchThread().runJobSync(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture)
-                            .sendToTarget();
-                    getCameraHandler().post(bundle.mUnlockRunnable);
-                }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "set preview texture");
+            try {
+                getDispatchThread().runJobSync(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.SET_PREVIEW_TEXTURE_ASYNC, surfaceTexture)
+                                .sendToTarget();
+                        getCameraHandler().post(bundle.mUnlockRunnable);
+                    }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "set preview texture");
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -497,25 +545,33 @@ public abstract class CameraAgent {
          * @param surfaceHolder The {@link SurfaceHolder} for preview.
          */
         public void setPreviewDisplay(final SurfaceHolder surfaceHolder) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.SET_PREVIEW_DISPLAY_ASYNC, surfaceHolder)
-                            .sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.SET_PREVIEW_DISPLAY_ASYNC, surfaceHolder)
+                                .sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
          * Starts the camera preview.
          */
         public void startPreview() {
+            try {
             getDispatchThread().runJob(new Runnable() {
                 @Override
                 public void run() {
                     getCameraHandler()
                             .obtainMessage(CameraActions.START_PREVIEW_ASYNC, null).sendToTarget();
                 }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -523,6 +579,7 @@ public abstract class CameraAgent {
          * the preview starts.
          */
         public void startPreviewWithCallback(final Handler h, final CameraStartPreviewCallback cb) {
+            try {
             getDispatchThread().runJob(new Runnable() {
                 @Override
                 public void run() {
@@ -530,6 +587,9 @@ public abstract class CameraAgent {
                             CameraStartPreviewCallbackForward.getNewInstance(h, cb))
                                     .sendToTarget();
                 }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -538,13 +598,21 @@ public abstract class CameraAgent {
          * continues to release resources related to camera preview.
          */
         public void stopPreview() {
+            // Don't bother to wait since camera is in bad state.
+            if (getCameraState().isInvalid()) {
+                return;
+            }
             final WaitDoneBundle bundle = new WaitDoneBundle();
-            getDispatchThread().runJobSync(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().obtainMessage(CameraActions.STOP_PREVIEW, bundle)
-                            .sendToTarget();
-                }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "stop preview");
+            try {
+                getDispatchThread().runJobSync(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().obtainMessage(CameraActions.STOP_PREVIEW, bundle)
+                                .sendToTarget();
+                    }}, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "stop preview");
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -583,14 +651,18 @@ public abstract class CameraAgent {
          * @param callbackBuffer The buffer allocated for the preview data.
          */
         public void addCallbackBuffer(final byte[] callbackBuffer) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.ADD_CALLBACK_BUFFER, callbackBuffer)
-                            .sendToTarget();
-                }
-            });
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.ADD_CALLBACK_BUFFER, callbackBuffer)
+                                .sendToTarget();
+                        }
+                    });
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -667,24 +739,32 @@ public abstract class CameraAgent {
          * @param capture Whether to adjust the JPEG capture orientation as well as the preview one.
          */
         public void setDisplayOrientation(final int degrees, final boolean capture) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.SET_DISPLAY_ORIENTATION, degrees,
-                                    capture ? 1 : 0)
-                            .sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.SET_DISPLAY_ORIENTATION, degrees,
+                                        capture ? 1 : 0)
+                                .sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         public void setJpegOrientation(final int degrees) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.SET_JPEG_ORIENTATION, degrees, 0)
-                            .sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.SET_JPEG_ORIENTATION, degrees, 0)
+                                .sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -707,22 +787,30 @@ public abstract class CameraAgent {
          * Starts the face detection.
          */
         public void startFaceDetection() {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().sendEmptyMessage(CameraActions.START_FACE_DETECTION);
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().sendEmptyMessage(CameraActions.START_FACE_DETECTION);
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
          * Stops the face detection.
          */
         public void stopFaceDetection() {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().sendEmptyMessage(CameraActions.STOP_FACE_DETECTION);
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().sendEmptyMessage(CameraActions.STOP_FACE_DETECTION);
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -780,13 +868,22 @@ public abstract class CameraAgent {
             }
 
             final CameraSettings copyOfSettings = settings.copy();
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraState().waitForStates(statesToAwait);
-                    getCameraHandler().obtainMessage(CameraActions.APPLY_SETTINGS, copyOfSettings)
-                            .sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        CameraStateHolder cameraState = getCameraState();
+                        // Don't bother to wait since camera is in bad state.
+                        if (cameraState.isInvalid()) {
+                            return;
+                        }
+                        cameraState.waitForStates(statesToAwait);
+                        getCameraHandler().obtainMessage(CameraActions.APPLY_SETTINGS, copyOfSettings)
+                                .sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
             return true;
         }
 
@@ -806,11 +903,15 @@ public abstract class CameraAgent {
          * settings regardless of the dirty bit.
          */
         public void refreshSettings() {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler().sendEmptyMessage(CameraActions.REFRESH_PARAMETERS);
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler().sendEmptyMessage(CameraActions.REFRESH_PARAMETERS);
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
@@ -820,13 +921,17 @@ public abstract class CameraAgent {
          *                 {@code false} to disable it.
          */
         public void enableShutterSound(final boolean enable) {
-            getDispatchThread().runJob(new Runnable() {
-                @Override
-                public void run() {
-                    getCameraHandler()
-                            .obtainMessage(CameraActions.ENABLE_SHUTTER_SOUND, (enable ? 1 : 0), 0)
-                            .sendToTarget();
-                }});
+            try {
+                getDispatchThread().runJob(new Runnable() {
+                    @Override
+                    public void run() {
+                        getCameraHandler()
+                                .obtainMessage(CameraActions.ENABLE_SHUTTER_SOUND, (enable ? 1 : 0), 0)
+                                .sendToTarget();
+                    }});
+            } catch (final RuntimeException ex) {
+                getAgent().getCameraExceptionHandler().onDispatchThreadException(ex);
+            }
         }
 
         /**
diff --git a/camera2/portability/src/com/android/ex/camera2/portability/CameraExceptionHandler.java b/camera2/portability/src/com/android/ex/camera2/portability/CameraExceptionHandler.java
new file mode 100644
index 0000000..7270b22
--- /dev/null
+++ b/camera2/portability/src/com/android/ex/camera2/portability/CameraExceptionHandler.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.ex.camera2.portability;
+
+import android.os.Handler;
+
+/**
+ * A handler for all camera api runtime exceptions.
+ * The default behavior is to throw the runtime exception.
+ */
+public class CameraExceptionHandler {
+    private Handler mHandler;
+
+    private CameraExceptionCallback mCallback =
+            new CameraExceptionCallback() {
+                @Override
+                public void onCameraException(RuntimeException e) {
+                    throw e;
+                }
+
+                @Override
+                public void onDispatchThreadException(RuntimeException e) {
+                    throw e;
+                }
+            };
+
+    /**
+     * A callback helps to handle RuntimeException thrown by camera framework.
+     */
+    public static interface CameraExceptionCallback {
+        public void onCameraException(RuntimeException e);
+        public void onDispatchThreadException(RuntimeException e);
+    }
+
+    /**
+     * Construct a new instance of {@link CameraExceptionHandler} with a custom callback which will
+     * be executed on a specific {@link Handler}.
+     *
+     * @param callback The callback which will be invoked.
+     * @param handler The handler in which the callback will be invoked in.
+     */
+    public CameraExceptionHandler(CameraExceptionCallback callback, Handler handler) {
+        mHandler = handler;
+        mCallback = callback;
+    }
+
+    /**
+     * Construct a new instance of {@link CameraExceptionHandler} with a default callback which will
+     * be executed on a specific {@link Handler}.
+     *
+     * @param handler The handler in which the default callback will be invoked in.
+     */
+    public CameraExceptionHandler(Handler handler) {
+        mHandler = handler;
+    }
+
+    /**
+     * Invoke @{link CameraExceptionCallback} when a runtime exception is thrown by Android camera
+     * framework.
+     *
+     * @param ex The runtime exception object.
+     */
+    public void onCameraException(final RuntimeException ex) {
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                mCallback.onCameraException(ex);
+            }
+        });
+    }
+
+    /**
+     * Invoke @{link CameraExceptionCallback} when a runtime exception is thrown by
+     * @{link DispatchThread}.
+     *
+     * @param ex The runtime exception object.
+     */
+    public void onDispatchThreadException(final RuntimeException ex) {
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                mCallback.onDispatchThreadException(ex);
+            }
+        });
+    }
+}
+
diff --git a/camera2/portability/src/com/android/ex/camera2/portability/CameraStateHolder.java b/camera2/portability/src/com/android/ex/camera2/portability/CameraStateHolder.java
index c8d82b6..b758af2 100644
--- a/camera2/portability/src/com/android/ex/camera2/portability/CameraStateHolder.java
+++ b/camera2/portability/src/com/android/ex/camera2/portability/CameraStateHolder.java
@@ -24,11 +24,23 @@ public abstract class CameraStateHolder {
     private static final Log.Tag TAG = new Log.Tag("CamStateHolder");
 
     private int mState;
+    private boolean mInvalid;
 
+    /**
+     * Construct a new instance of @{link CameraStateHolder} with an initial state.
+     *
+     * @param state The initial state.
+     */
     public CameraStateHolder(int state) {
         setState(state);
+        mInvalid = false;
     }
 
+    /**
+     * Change to a new state.
+     *
+     * @param state The new state.
+     */
     public synchronized void setState(int state) {
         if (mState != state) {
             Log.v(TAG, "setState - state = " + Integer.toBinaryString(state));
@@ -37,10 +49,31 @@ public abstract class CameraStateHolder {
         this.notifyAll();
     }
 
+    /**
+     * Obtain the current state.
+     *
+     * @return The current state.
+     */
     public synchronized int getState() {
         return mState;
     }
 
+    /**
+     * Change the state to be invalid. Once invalidated, the state will be invalid forever.
+     */
+    public synchronized void invalidate() {
+        mInvalid = true;
+    }
+
+    /**
+     * Whether the state is invalid.
+     *
+     * @return True if the state is invalid.
+     */
+    public synchronized boolean isInvalid() {
+        return mInvalid;
+    }
+
     private static interface ConditionChecker {
         /**
          * @return Whether the condition holds.