Cancel onResumeTask when the app is paused.

Also change the camera closing conditions to force close all camera before
killing the handler thread.

bug:14190951
bug:14441425

Change-Id: Ic752b0678530b34eb3710bd7796cb17d15452013

2 files changed, 67 insertions, 59 deletions

diff --git a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraManagerImpl.java b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraManagerImpl.java
index 5dc6270..a46d37a 100644
--- a/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraManagerImpl.java
+++ b/camera2/portability/src/com/android/ex/camera2/portability/AndroidCameraManagerImpl.java
@@ -135,11 +135,9 @@ class AndroidCameraManagerImpl implements CameraManager {
         }
     }
 
-    /**
-     * Recycles the resources used by this instance. CameraManager will be in
-     * an unusable state after calling this.
-     */
+    @Override
     public void recycle() {
+        closeCamera(null, true);
         mDispatchThread.end();
     }
 
@@ -240,6 +238,7 @@ class AndroidCameraManagerImpl implements CameraManager {
     private class CameraHandler extends Handler {
 
         private Camera mCamera;
+        private int mCameraId;
 
         private LinkedList<Integer> mMsgHistory;
 
@@ -346,12 +345,13 @@ class AndroidCameraManagerImpl implements CameraManager {
                         final CameraOpenCallback openCallback = (CameraOpenCallback) msg.obj;
                         final int cameraId = msg.arg1;
                         if (mCameraState.getState() != CAMERA_UNOPENED) {
-                            openCallback.onDeviceOpenedAlready(cameraId);
+                            openCallback.onDeviceOpenedAlready(cameraId, generateHistoryString(cameraId));
                             break;
                         }
 
                         mCamera = android.hardware.Camera.open(cameraId);
                         if (mCamera != null) {
+                            mCameraId = cameraId;
                             mParametersIsDirty = true;
 
                             // Get a instance of Camera.Parameters for later use.
@@ -373,9 +373,13 @@ class AndroidCameraManagerImpl implements CameraManager {
                     }
 
                     case RELEASE: {
-                        mCamera.release();
-                        mCameraState.setState(CAMERA_UNOPENED);
-                        mCamera = null;
+                        if (mCamera != null) {
+                            mCamera.release();
+                            mCameraState.setState(CAMERA_UNOPENED);
+                            mCamera = null;
+                        } else {
+                            Log.w(TAG, "Releasing camera without any camera opened.");
+                        }
                         break;
                     }
 
@@ -387,7 +391,8 @@ class AndroidCameraManagerImpl implements CameraManager {
                             mCamera.reconnect();
                         } catch (IOException ex) {
                             if (cbForward != null) {
-                                cbForward.onReconnectionFailure(AndroidCameraManagerImpl.this);
+                                cbForward.onReconnectionFailure(AndroidCameraManagerImpl.this,
+                                        generateHistoryString(mCameraId));
                             }
                             break;
                         }
@@ -623,7 +628,7 @@ class AndroidCameraManagerImpl implements CameraManager {
                     runJob(job);
                     waitLock.wait();
                 } catch (InterruptedException ex) {
-                    Log.v(TAG, "Job interrupted");
+                    Log.w(TAG, "Job interrupted");
                     if (SystemClock.uptimeMillis() > timeoutBound) {
                         // Timeout.
                         Log.w(TAG, "Timeout waiting camera operation:" + jobMsg);
@@ -661,7 +666,7 @@ class AndroidCameraManagerImpl implements CameraManager {
                         try {
                             mJobQueue.wait();
                         } catch (InterruptedException ex) {
-                            Log.v(TAG, "Dispatcher thread wait() interrupted, exiting");
+                            Log.w(TAG, "Dispatcher thread wait() interrupted, exiting");
                             break;
                         }
                     }
@@ -701,8 +706,8 @@ class AndroidCameraManagerImpl implements CameraManager {
     }
 
     @Override
-    public void cameraOpen(final Handler handler, final int cameraId,
-            final CameraOpenCallback callback) {
+    public void openCamera(final Handler handler, final int cameraId,
+                           final CameraOpenCallback callback) {
         mDispatchThread.runJob(new Runnable() {
             @Override
             public void run() {
@@ -712,6 +717,29 @@ class AndroidCameraManagerImpl implements CameraManager {
         });
     }
 
+    @Override
+    public void closeCamera(CameraProxy camera, boolean synced) {
+        if (synced) {
+            final WaitDoneBundle bundle = new WaitDoneBundle();
+
+            mDispatchThread.runJobSync(new Runnable() {
+                @Override
+                public void run() {
+                    mCameraHandler.obtainMessage(RELEASE).sendToTarget();
+                    mCameraHandler.post(bundle.mUnlockRunnable);
+                }
+            }, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera release");
+        } else {
+            mDispatchThread.runJob(new Runnable() {
+                @Override
+                public void run() {
+                    mCameraHandler.removeCallbacksAndMessages(null);
+                    mCameraHandler.obtainMessage(RELEASE).sendToTarget();
+                }
+            });
+        }
+    }
+
     /**
      * A class which implements {@link CameraManager.CameraProxy} and
      * camera handler thread.
@@ -736,31 +764,6 @@ class AndroidCameraManagerImpl implements CameraManager {
             return mCameraId;
         }
 
-        // TODO: Make this package private.
-        @Override
-        public void release(boolean sync) {
-            Log.v(TAG, "camera manager release");
-            if (sync) {
-                final WaitDoneBundle bundle = new WaitDoneBundle();
-
-                mDispatchThread.runJobSync(new Runnable() {
-                    @Override
-                    public void run() {
-                        mCameraHandler.sendEmptyMessage(RELEASE);
-                        mCameraHandler.post(bundle.mUnlockRunnable);
-                    }
-                }, bundle.mWaitLock, CAMERA_OPERATION_TIMEOUT_MS, "camera release");
-            } else {
-                mDispatchThread.runJob(new Runnable() {
-                    @Override
-                    public void run() {
-                        mCameraHandler.removeCallbacksAndMessages(null);
-                        mCameraHandler.sendEmptyMessage(RELEASE);
-                    }
-                });
-            }
-        }
-
         @Override
         public void reconnect(final Handler handler, final CameraOpenCallback cb) {
             mDispatchThread.runJob(new Runnable() {
@@ -975,7 +978,7 @@ class AndroidCameraManagerImpl implements CameraManager {
                 @Override
                 public void onPictureTaken(final byte[] data, Camera camera) {
                     if (mCameraState.getState() != CAMERA_CAPTURING) {
-                        Log.v(TAG, "picture callback returning when not capturing");
+                        Log.w(TAG, "picture callback returning when not capturing");
                     } else {
                         mCameraState.setState(CAMERA_IDLE);
                     }
@@ -1503,21 +1506,21 @@ class AndroidCameraManagerImpl implements CameraManager {
         }
 
         @Override
-        public void onDeviceOpenedAlready(final int cameraId) {
+        public void onDeviceOpenedAlready(final int cameraId, final String info) {
             mHandler.post(new Runnable() {
                 @Override
                 public void run() {
-                    mCallback.onDeviceOpenedAlready(cameraId);
+                    mCallback.onDeviceOpenedAlready(cameraId, info);
                 }
             });
         }
 
         @Override
-        public void onReconnectionFailure(final CameraManager mgr) {
+        public void onReconnectionFailure(final CameraManager mgr, final String info) {
             mHandler.post(new Runnable() {
                 @Override
                 public void run() {
-                    mCallback.onReconnectionFailure(mgr);
+                    mCallback.onReconnectionFailure(mgr, info);
                 }
             });
         }
diff --git a/camera2/portability/src/com/android/ex/camera2/portability/CameraManager.java b/camera2/portability/src/com/android/ex/camera2/portability/CameraManager.java
index 6c80766..a7bddcb 100644
--- a/camera2/portability/src/com/android/ex/camera2/portability/CameraManager.java
+++ b/camera2/portability/src/com/android/ex/camera2/portability/CameraManager.java
@@ -28,7 +28,7 @@ import android.view.SurfaceHolder;
 /**
  * An interface which provides possible camera device operations.
  *
- * The client should call {@code CameraManager.cameraOpen} to get an instance
+ * The client should call {@code CameraManager.openCamera} to get an instance
  * of {@link CameraManager.CameraProxy} to control the camera. Classes
  * implementing this interface should have its own one unique {@code Thread}
  * other than the main thread for camera operations. Camera device callbacks
@@ -113,7 +113,7 @@ public interface CameraManager {
     }
 
     /**
-     * An interface to be called for any exception caught when opening the
+     * An interface to be called for any events when opening or closing the
      * camera device. This error callback is different from the one defined
      * in the framework, {@link android.hardware.Camera.ErrorCallback}, which
      * is used after the camera is opened.
@@ -146,7 +146,7 @@ public interface CameraManager {
          *
          * @param cameraId The camera which is causing the open error.
          */
-        public void onDeviceOpenedAlready(int cameraId);
+        public void onDeviceOpenedAlready(int cameraId, String info);
 
         /**
          * Callback when {@link java.io.IOException} is caught during
@@ -155,7 +155,7 @@ public interface CameraManager {
          * @param mgr The {@link CameraManager}
          *            with the reconnect failure.
          */
-        public void onReconnectionFailure(CameraManager mgr);
+        public void onReconnectionFailure(CameraManager mgr, String info);
     }
 
     /**
@@ -166,10 +166,19 @@ public interface CameraManager {
      *
      * @param handler The {@link android.os.Handler} in which the callback
      *                was handled.
-     * @param callback The callback when any error happens.
+     * @param callback The callback for the result.
      * @param cameraId The camera ID to open.
      */
-    public void cameraOpen(Handler handler, int cameraId, CameraOpenCallback callback);
+    public void openCamera(Handler handler, int cameraId, CameraOpenCallback callback);
+
+
+    /**
+     * Closes the camera device.
+     *
+     * @param camera The camera to close. {@code null} means all.
+     * @param synced Whether this call should be synchronous.
+     */
+    public void closeCamera(CameraProxy camera, boolean synced);
 
     /**
      * An interface that takes camera operation requests and post messages to the
@@ -195,16 +204,6 @@ public interface CameraManager {
         public int getCameraId();
 
         /**
-         * Releases the camera device synchronously.
-         * This function must be synchronous so the caller knows exactly when the camera
-         * is released and can continue on.
-         * TODO: make this package-private after this interface is refactored under app.
-         *
-         * @param synchronous Whether this call should be synchronous.
-         */
-        public void release(boolean synchronous);
-
-        /**
          * Reconnects to the camera device. On success, the camera device will
          * be returned through {@link CameraManager
          * .CameraOpenCallback#onCameraOpened(com.android.camera.cameradevice.CameraManager
@@ -434,4 +433,10 @@ public interface CameraManager {
      */
     public void setCameraDefaultExceptionCallback(CameraExceptionCallback callback,
             Handler handler);
+
+    /**
+     * Recycles the resources used by this instance. CameraManager will be in
+     * an unusable state after calling this.
+     */
+    public void recycle();
 }