make the camera preview fullscreen

2026-06-12 01:58:07 -04:00 · 2016-04-14 20:29:35 +02:00
parent 6150c51f57
commit 544694f6db
5 changed files with 186 additions and 60 deletions
--- a/app/src/main/java/com/simplemobiletools/camera/Preview.java
+++ b/app/src/main/java/com/simplemobiletools/camera/Preview.java
@@ -0,0 +1,159 @@
+package com.simplemobiletools.camera;
+
+import android.content.Context;
+import android.hardware.Camera;
+import android.util.Log;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.ViewGroup;
+
+import java.io.IOException;
+import java.util.List;
+
+public class Preview extends ViewGroup implements SurfaceHolder.Callback {
+    private static final String TAG = Preview.class.getSimpleName();
+
+    private SurfaceHolder surfaceHolder;
+    private Camera camera;
+    private List<Camera.Size> supportedPreviewSizes;
+    private SurfaceView surfaceView;
+    private Camera.Size previewSize;
+
+    public Preview(Context context) {
+        super(context);
+    }
+
+    public Preview(Context context, SurfaceView sv) {
+        super(context);
+
+        surfaceView = sv;
+        surfaceHolder = surfaceView.getHolder();
+        surfaceHolder.addCallback(this);
+        surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
+    }
+
+    public void setCamera(Camera newCamera) {
+        if (camera == newCamera) {
+            return;
+        }
+
+        releaseCamera();
+        camera = newCamera;
+
+        if (camera != null) {
+            supportedPreviewSizes = camera.getParameters().getSupportedPreviewSizes();
+            requestLayout();
+
+            final Camera.Parameters params = camera.getParameters();
+            params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
+            camera.setParameters(params);
+        }
+    }
+
+    public void releaseCamera() {
+        if (camera != null) {
+            camera.stopPreview();
+            camera.release();
+            camera = null;
+        }
+    }
+
+    @Override
+    public void surfaceCreated(SurfaceHolder holder) {
+        try {
+            if (camera != null) {
+                camera.setPreviewDisplay(holder);
+            }
+        } catch (IOException e) {
+            Log.e(TAG, "surfaceCreated IOException " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+        if (camera != null) {
+            final Camera.Parameters parameters = camera.getParameters();
+            parameters.setPreviewSize(previewSize.width, previewSize.height);
+            requestLayout();
+
+            camera.setParameters(parameters);
+            camera.startPreview();
+        }
+    }
+
+    @Override
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        if (camera != null) {
+            camera.stopPreview();
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        if (changed && getChildCount() > 0) {
+            final View child = getChildAt(0);
+
+            final int width = r - l;
+            final int height = b - t;
+
+            int previewWidth = width;
+            int previewHeight = height;
+            if (previewSize != null) {
+                previewWidth = previewSize.width;
+                previewHeight = previewSize.height;
+            }
+
+            if (width * previewHeight > height * previewWidth) {
+                final int scaledChildWidth = previewWidth * height / previewHeight;
+                child.layout((width - scaledChildWidth) / 2, 0, (width + scaledChildWidth) / 2, height);
+            } else {
+                final int scaledChildHeight = previewHeight * width / previewWidth;
+                child.layout(0, (height - scaledChildHeight) / 2, width, (height + scaledChildHeight) / 2);
+            }
+        }
+    }
+
+    private Camera.Size getOptimalPreviewSize(List<Camera.Size> sizes, int w, int h) {
+        final double ASPECT_TOLERANCE = 0.1;
+        double targetRatio = (double) h / w;
+
+        if (sizes == null)
+            return null;
+
+        Camera.Size optimalSize = null;
+        double minDiff = Double.MAX_VALUE;
+
+        for (Camera.Size size : sizes) {
+            double ratio = (double) size.width / size.height;
+            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)
+                continue;
+            if (Math.abs(size.height - h) < minDiff) {
+                optimalSize = size;
+                minDiff = Math.abs(size.height - h);
+            }
+        }
+
+        if (optimalSize == null) {
+            minDiff = Double.MAX_VALUE;
+            for (Camera.Size size : sizes) {
+                if (Math.abs(size.height - h) < minDiff) {
+                    optimalSize = size;
+                    minDiff = Math.abs(size.height - h);
+                }
+            }
+        }
+        return optimalSize;
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
+        final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
+        setMeasuredDimension(width, height);
+
+        if (supportedPreviewSizes != null) {
+            previewSize = getOptimalPreviewSize(supportedPreviewSizes, width, height);
+        }
+    }
+}