Merge branch 'master' into master

build.gradle

@@ -15,6 +15,7 @@ buildscript {
 allprojects {
     repositories {
         jcenter()
+        maven { url 'https://maven.google.com' }
     }
 }
 

camerakit/build.gradle

@@ -33,6 +33,11 @@ android {
 
 dependencies {
     compile 'com.android.support:appcompat-v7:25.2.0'
+
+
+    compile "android.arch.lifecycle:runtime:1.0.0-alpha1"
+    compile "android.arch.lifecycle:extensions:1.0.0-alpha1"
+    annotationProcessor "android.arch.lifecycle:compiler:1.0.0-alpha1"
 }
 
 apply from: 'https://raw.githubusercontent.com/blundell/release-android-library/master/android-release-aar.gradle'

camerakit/src/main/api16/com/flurgle/camerakit/Camera1.java

@@ -6,6 +6,7 @@ import android.hardware.Camera;
 import android.media.CamcorderProfile;
 import android.media.MediaRecorder;
 import android.os.Handler;
+import android.support.annotation.Nullable;
 import android.view.MotionEvent;
 import android.view.SurfaceHolder;
 import android.view.View;
@@ -36,6 +37,7 @@ public class Camera1 extends CameraImpl {
     private int mCameraId;
     private Camera mCamera;
     private Camera.Parameters mCameraParameters;
+    private CameraProperties mCameraProperties;
     private Camera.CameraInfo mCameraInfo;
     private Size mPreviewSize;
     private Size mCaptureSize;
@@ -212,7 +214,9 @@ public class Camera1 extends CameraImpl {
                     @Override
                     public void onPictureTaken(byte[] data, Camera camera) {
                         mCameraListener.onPictureTaken(data);
-                        camera.startPreview();
+                        if (mCamera != null) {
+                            mCamera.startPreview();
+                        }
                     }
                 });
                 break;
@@ -309,6 +313,12 @@ public class Camera1 extends CameraImpl {
         return mCamera != null;
     }
 
+    @Nullable
+    @Override
+    CameraProperties getCameraProperties() {
+        return mCameraProperties;
+    }
+
     // Internal:
 
     private void openCamera() {
@@ -319,6 +329,7 @@ public class Camera1 extends CameraImpl {
         mCamera = Camera.open(mCameraId);
         mCameraParameters = mCamera.getParameters();
 
+        collectCameraProperties();
         adjustCameraParameters();
         mCamera.setDisplayOrientation(calculatePreviewRotation());
 
@@ -391,6 +402,11 @@ public class Camera1 extends CameraImpl {
         mCamera.setParameters(mCameraParameters);
     }
 
+    private void collectCameraProperties() {
+        mCameraProperties = new CameraProperties(mCameraParameters.getVerticalViewAngle(),
+                mCameraParameters.getHorizontalViewAngle());
+    }
+
     private TreeSet<AspectRatio> findCommonAspectRatios(List<Camera.Size> previewSizes, List<Camera.Size> captureSizes) {
         Set<AspectRatio> previewAspectRatios = new HashSet<>();
         for (Camera.Size size : previewSizes) {

camerakit/src/main/api21/com/flurgle/camerakit/Camera2.java

@@ -3,14 +3,18 @@ package com.flurgle.camerakit;
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.ImageFormat;
+import android.graphics.PointF;
 import android.hardware.camera2.CameraAccessException;
 import android.hardware.camera2.CameraCharacteristics;
 import android.hardware.camera2.CameraDevice;
 import android.hardware.camera2.CameraManager;
 import android.hardware.camera2.params.StreamConfigurationMap;
+import android.support.annotation.Nullable;
 import android.util.Log;
+import android.util.SizeF;
 
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.TreeSet;
@@ -28,6 +32,8 @@ class Camera2 extends CameraImpl {
     private Size mCaptureSize;
     private Size mPreviewSize;
 
+    private final HashMap<String, CameraProperties> mCameraPropertyMap = new HashMap<>();
+
     Camera2(CameraListener callback, PreviewImpl preview, Context context) {
         super(callback, preview);
         preview.setCallback(new PreviewImpl.Callback() {
@@ -38,6 +44,36 @@ class Camera2 extends CameraImpl {
         });
 
         mCameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
+
+        // Get all view angles
+        try {
+            for (final String cameraId : mCameraManager.getCameraIdList()) {
+                CameraCharacteristics characteristics =
+                        mCameraManager.getCameraCharacteristics(cameraId);
+                @SuppressWarnings("ConstantConditions")
+                int orientation = characteristics.get(CameraCharacteristics.LENS_FACING);
+                if (orientation == CameraCharacteristics.LENS_FACING_BACK) {
+                    float[] maxFocus = characteristics.get(
+                            CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS);
+                    if (maxFocus == null) {
+                        continue;
+                    }
+                    SizeF size = characteristics.get(
+                            CameraCharacteristics.SENSOR_INFO_PHYSICAL_SIZE);
+                    if (size == null) {
+                        continue;
+                    }
+                    float w = size.getWidth();
+                    float h = size.getHeight();
+                    mCameraPropertyMap.put(cameraId, new CameraProperties(
+                            (float) Math.toDegrees(2*Math.atan(size.getWidth()/(maxFocus[0]*2))),
+                            (float) Math.toDegrees(2*Math.atan(size.getHeight()/(maxFocus[0]*2)))
+                    ));
+                }
+            }
+        } catch (CameraAccessException e) {
+            throw new RuntimeException("Failed to get camera view angles", e);
+        }
     }
 
     // CameraImpl:
@@ -196,6 +232,14 @@ class Camera2 extends CameraImpl {
         return mCamera != null;
     }
 
+    @Nullable
+    @Override
+    CameraProperties getCameraProperties() {
+        if (mCamera == null) {
+            return null;
+        }
+        return mCameraPropertyMap.get(mCamera.getId());
+    }
     // Internal
 
     private List<Size> getAvailableCaptureResolutions() {

camerakit/src/main/base/com/flurgle/camerakit/CameraImpl.java

@@ -1,5 +1,7 @@
 package com.flurgle.camerakit;
 
+import android.support.annotation.Nullable;
+
 abstract class CameraImpl {
 
     protected final CameraListener mCameraListener;
@@ -30,4 +32,7 @@ abstract class CameraImpl {
     abstract Size getPreviewResolution();
     abstract boolean isCameraOpened();
 
+    @Nullable
+    abstract CameraProperties getCameraProperties();
+
 }

camerakit/src/main/base/com/flurgle/camerakit/CameraProperties.java

@@ -0,0 +1,14 @@
+package com.flurgle.camerakit;
+
+/**
+ * Simple pojo containing various camera properties.
+ */
+public class CameraProperties {
+    public final float verticalViewingAngle;
+    public final float horizontalViewingAngle;
+
+    public CameraProperties(float verticalViewingAngle, float horizontalViewingAngle) {
+        this.verticalViewingAngle = verticalViewingAngle;
+        this.horizontalViewingAngle = horizontalViewingAngle;
+    }
+}

camerakit/src/main/java/com/flurgle/camerakit/CameraView.java

@@ -2,12 +2,18 @@ package com.flurgle.camerakit;
 
 import android.Manifest;
 import android.app.Activity;
+import android.arch.lifecycle.Lifecycle;
+import android.arch.lifecycle.LifecycleObserver;
+import android.arch.lifecycle.LifecycleOwner;
+import android.arch.lifecycle.OnLifecycleEvent;
 import android.content.Context;
 import android.content.ContextWrapper;
 import android.content.pm.PackageManager;
 import android.content.res.TypedArray;
 import android.graphics.Rect;
 import android.graphics.YuvImage;
+import android.os.Handler;
+import android.os.HandlerThread;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v4.app.ActivityCompat;
@@ -35,7 +41,32 @@ import static com.flurgle.camerakit.CameraKit.Constants.PERMISSIONS_LAZY;
 import static com.flurgle.camerakit.CameraKit.Constants.PERMISSIONS_PICTURE;
 import static com.flurgle.camerakit.CameraKit.Constants.PERMISSIONS_STRICT;
 
-public class CameraView extends FrameLayout {
+/**
+ * The CameraView implements the LifecycleObserver interface for ease of use. To take advantage of
+ * this, simply call the following from any LifecycleOwner:
+ * <pre>
+ * {@code
+ * protected void onCreate(@Nullable Bundle savedInstanceState) {
+ *     super.onCreate(savedInstanceState);
+ *     setContentView(R.layout.my_view);
+ *     ...
+ *     getLifecycle().addObserver(mCameraView);
+ * }
+ * }
+ * </pre>
+ */
+public class CameraView extends FrameLayout implements LifecycleObserver {
+
+    private static Handler sWorkerHandler;
+
+    static {
+        // Initialize a single worker thread. This can be static since only a single camera
+        // reference can exist at a time.
+        HandlerThread workerThread = new HandlerThread("CameraViewWorker");
+        workerThread.setDaemon(true);
+        workerThread.start();
+        sWorkerHandler = new Handler(workerThread.getLooper());
+    }
 
     @Facing
     private int mFacing;
@@ -57,24 +88,33 @@ public class CameraView extends FrameLayout {
 
     @VideoQuality
     private int mVideoQuality;
-
     private int mJpegQuality;
     private boolean mCropOutput;
-    private boolean mAdjustViewBounds;
 
+    private boolean mAdjustViewBounds;
     private CameraListenerMiddleWare mCameraListener;
-    private DisplayOrientationDetector mDisplayOrientationDetector;
 
+    private DisplayOrientationDetector mDisplayOrientationDetector;
     private CameraImpl mCameraImpl;
+
     private PreviewImpl mPreviewImpl;
 
+    private Lifecycle mLifecycle;
+    private boolean mIsStarted;
+
     public CameraView(@NonNull Context context) {
         super(context, null);
+        init(context, null);
     }
 
     @SuppressWarnings("all")
     public CameraView(@NonNull Context context, @Nullable AttributeSet attrs) {
         super(context, attrs);
+        init(context, attrs);
+    }
+
+    @SuppressWarnings("WrongConstant")
+    private void init(@NonNull Context context, @Nullable AttributeSet attrs) {
         if (attrs != null) {
             TypedArray a = context.getTheme().obtainStyledAttributes(
                     attrs,
@@ -102,6 +142,7 @@ public class CameraView extends FrameLayout {
         mPreviewImpl = new TextureViewPreview(context, this);
         mCameraImpl = new Camera1(mCameraListener, mPreviewImpl);
 
+        mIsStarted = false;
         setFacing(mFacing);
         setFlash(mFlash);
         setFocus(mFocus);
@@ -134,6 +175,7 @@ public class CameraView extends FrameLayout {
                 }
             });
         }
+        mLifecycle = null;
     }
 
     @Override
@@ -189,7 +231,42 @@ public class CameraView extends FrameLayout {
         super.onMeasure(widthMeasureSpec, heightMeasureSpec);
     }
 
+    public boolean isStarted() {
+        return mIsStarted;
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        super.setEnabled(enabled);
+        if (mLifecycle != null && mLifecycle.getCurrentState().isAtLeast(Lifecycle.State.RESUMED)) {
+            // Potentially update the UI
+            if (enabled) {
+                start();
+            } else {
+                stop();
+            }
+        }
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
+    public void onResume(LifecycleOwner owner) {
+        mLifecycle = owner.getLifecycle();
+        start();
+    }
+
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+    public void onPause(LifecycleOwner owner) {
+        mLifecycle = owner.getLifecycle();
+        stop();
+    }
+
     public void start() {
+        if (mIsStarted || !isEnabled()) {
+            // Already started, do nothing.
+            return;
+        }
+        mIsStarted = true;
         int cameraCheck = ContextCompat.checkSelfPermission(getContext(), Manifest.permission.CAMERA);
         int audioCheck = ContextCompat.checkSelfPermission(getContext(), Manifest.permission.RECORD_AUDIO);
 
@@ -216,28 +293,42 @@ public class CameraView extends FrameLayout {
                 break;
         }
 
-        new Thread(new Runnable() {
+        sWorkerHandler.post(new Runnable() {
             @Override
             public void run() {
                 mCameraImpl.start();
             }
-        }).start();
+        });
     }
 
     public void stop() {
+        if (!mIsStarted) {
+            // Already stopped, do nothing.
+            return;
+        }
+        mIsStarted = false;
         mCameraImpl.stop();
     }
 
-    public void setFacing(@Facing
-                          final int facing) {
+    @Nullable
+    public CameraProperties getCameraProperties() {
+        return mCameraImpl.getCameraProperties();
+    }
+
+    @Facing
+    public int getFacing() {
+        return mFacing;
+    }
+
+    public void setFacing(@Facing final int facing) {
         this.mFacing = facing;
 
-        new Thread(new Runnable() {
+        sWorkerHandler.post(new Runnable() {
             @Override
             public void run() {
                 mCameraImpl.setFacing(facing);
             }
-        }).start();
+        });
     }
 
     public void setFlash(@Flash int flash) {
@@ -245,6 +336,11 @@ public class CameraView extends FrameLayout {
         mCameraImpl.setFlash(flash);
     }
 
+    @Flash
+    public int getFlash() {
+        return mFlash;
+    }
+
     public void setFocus(@Focus int focus) {
         this.mFocus = focus;
         if (this.mFocus == CameraKit.Constants.FOCUS_TAP_WITH_MARKER) {