Android Kamera Vorschau gestreckt

F1Sher die Lösung ist schön, aber manchmal nicht funktioniert. Besonders, wenn Ihr surfaceView deckt nicht den ganzen Bildschirm. In diesem Fall müssen Sie zum überschreiben onMeasure () - Methode.
Ich habe kopiert mein code hier für Ihre Referenz.

Da ich gemessen surfaceView, basierend auf Breite, dann habe ich etwas weiße Lücke am Ende von meinem Bildschirm, dass ich es ausgefüllt per design. Sie sind in der Lage das Problem zu beheben, wenn Sie halten die Höhe und Zunahme der Breite multiplizieren es zu Verhältnis. Jedoch, es wird Plitsch surfaceView leicht.

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {

    private static final String TAG = "CameraPreview";

    private Context mContext;
    private SurfaceHolder mHolder;
    private Camera mCamera;
    private List<Camera.Size> mSupportedPreviewSizes;
    private Camera.Size mPreviewSize;

    public CameraPreview(Context context, Camera camera) {
        super(context);
        mContext = context;
        mCamera = camera;

        //supported preview sizes
        mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
        for(Camera.Size str: mSupportedPreviewSizes)
                Log.e(TAG, str.width + "/" + str.height);

        //Install a SurfaceHolder.Callback so we get notified when the
        //underlying surface is created and destroyed.
        mHolder = getHolder();
        mHolder.addCallback(this);
        //deprecated setting, but required on Android versions prior to 3.0
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    public void surfaceCreated(SurfaceHolder holder) {
        //empty. surfaceChanged will take care of stuff
    }

    public void surfaceDestroyed(SurfaceHolder holder) {
        //empty. Take care of releasing the Camera preview in your activity.
    }

    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        Log.e(TAG, "surfaceChanged => w=" + w + ", h=" + h);
        //If your preview can change or rotate, take care of those events here.
        //Make sure to stop the preview before resizing or reformatting it.
        if (mHolder.getSurface() == null){
            //preview surface does not exist
            return;
        }

        //stop preview before making changes
        try {
            mCamera.stopPreview();
        } catch (Exception e){
            //ignore: tried to stop a non-existent preview
        }

        //set preview size and make any resize, rotate or reformatting changes here
        //start preview with new settings
        try {
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
            mCamera.setParameters(parameters);
            mCamera.setDisplayOrientation(90);
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();

        } catch (Exception e){
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
        final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);

        if (mSupportedPreviewSizes != null) {
            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
        }

        if (mPreviewSize!=null) {
            float ratio;
            if(mPreviewSize.height >= mPreviewSize.width)
                ratio = (float) mPreviewSize.height / (float) mPreviewSize.width;
            else
                ratio = (float) mPreviewSize.width / (float) mPreviewSize.height;

            //One of these methods should be used, second method squishes preview slightly
            setMeasuredDimension(width, (int) (width * ratio));
  //       setMeasuredDimension((int) (width * ratio), height);
        }
    }

    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;

        int targetHeight = h;

        for (Camera.Size size : sizes) {
            double ratio = (double) size.height / size.width;
            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE)
                continue;

            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
            }
        }

        if (optimalSize == null) {
            minDiff = Double.MAX_VALUE;
            for (Camera.Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }
        }

        return optimalSize;
    }
}

InformationsquelleAutor der Antwort Hesam

OK, also ich denke, es keine ausreichende Antwort für Allgemeine Kamera-Vorschau-stretching-problem. Oder zumindest ich nicht fündig. Meine app hatte auch das dehnen-Syndrom, und es dauerte eine Weile, um Rätsel gemeinsam eine Lösung, von der alle Nutzer, die Antworten auf diesem portal und internet.

Habe ich versucht @Hesam ist Lösung aber es hat nicht funktioniert und verließ meine Kamera Vorschau majorly verzerrt.

Zuerst zeige ich den code von meiner Lösung (die wichtigen Teile des Codes) und dann erkläre ich, warum ich nahm diese Schritte. Es gibt Raum für performance Modifikationen.

Haupttätigkeit xml-layout:

<RelativeLayout 
    android:id="@+id/main_layout"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal" >

    <FrameLayout
        android:id="@+id/camera_preview"
        android:layout_centerInParent="true"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
    />
</RelativeLayout>

Kamera-Vorschau:

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {

private SurfaceHolder prHolder;
private Camera prCamera;
public List<Camera.Size> prSupportedPreviewSizes;
private Camera.Size prPreviewSize;

@SuppressWarnings("deprecation")
public YoCameraPreview(Context context, Camera camera) {
    super(context);
    prCamera = camera;

    prSupportedPreviewSizes = prCamera.getParameters().getSupportedPreviewSizes();

    prHolder = getHolder();
    prHolder.addCallback(this);
    prHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
}

public void surfaceCreated(SurfaceHolder holder) {
    try {
        prCamera.setPreviewDisplay(holder);
        prCamera.startPreview();
    } catch (IOException e) {
        Log.d("Yologram", "Error setting camera preview: " + e.getMessage());
    }
}

public void surfaceDestroyed(SurfaceHolder holder) {
}

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
    if (prHolder.getSurface() == null){
      return;
    }

    try {
        prCamera.stopPreview();
    } catch (Exception e){
    }

    try {
        Camera.Parameters parameters = prCamera.getParameters();
        List<String> focusModes = parameters.getSupportedFocusModes();
        if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
        }
        parameters.setPreviewSize(prPreviewSize.width, prPreviewSize.height);

        prCamera.setParameters(parameters);
        prCamera.setPreviewDisplay(prHolder);
        prCamera.startPreview();

    } catch (Exception e){
        Log.d("Yologram", "Error starting camera preview: " + e.getMessage());
    }
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

    final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
    final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);

    setMeasuredDimension(width, height);

    if (prSupportedPreviewSizes != null) {
        prPreviewSize = 
            getOptimalPreviewSize(prSupportedPreviewSizes, width, height);
    }    
}

public 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;

    int targetHeight = h;

    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 - targetHeight) < minDiff) {
            optimalSize = size;
            minDiff = Math.abs(size.height - targetHeight);
        }
    }

    if (optimalSize == null) {
        minDiff = Double.MAX_VALUE;
        for (Camera.Size size : sizes) {
            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
            }
        }
    }

    return optimalSize;
}
}

Haupttätigkeit:

public class MainActivity extends Activity {

...

@SuppressLint("NewApi")
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);     
    setContentView(R.layout.activity_main);

        maCamera = getCameraInstance();

        maLayoutPreview = (FrameLayout) findViewById(R.id.camera_preview);

        maPreview = new CameraPreview(this, maCamera);

        Point displayDim = getDisplayWH();
        Point layoutPreviewDim = calcCamPrevDimensions(displayDim, 
                maPreview.getOptimalPreviewSize(maPreview.prSupportedPreviewSizes, 
                    displayDim.x, displayDim.y));
        if (layoutPreviewDim != null) {
            RelativeLayout.LayoutParams layoutPreviewParams = 
                (RelativeLayout.LayoutParams) maLayoutPreview.getLayoutParams();
            layoutPreviewParams.width = layoutPreviewDim.x;
            layoutPreviewParams.height = layoutPreviewDim.y;
            layoutPreviewParams.addRule(RelativeLayout.CENTER_IN_PARENT);
            maLayoutPreview.setLayoutParams(layoutPreviewParams);
        }
        maLayoutPreview.addView(maPreview);
}

@SuppressLint("NewApi")
@SuppressWarnings("deprecation")
private Point getDisplayWH() {

    Display display = this.getWindowManager().getDefaultDisplay();
    Point displayWH = new Point();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) {
        display.getSize(displayWH);
        return displayWH;
    }
    displayWH.set(display.getWidth(), display.getHeight());
    return displayWH;
}

private Point calcCamPrevDimensions(Point disDim, Camera.Size camDim) {

    Point displayDim = disDim;
    Camera.Size cameraDim = camDim;

    double widthRatio = (double) displayDim.x / cameraDim.width;
    double heightRatio = (double) displayDim.y / cameraDim.height;

    //use ">" to zoom preview full screen
    if (widthRatio < heightRatio) {
        Point calcDimensions = new Point();
        calcDimensions.x = displayDim.x;
        calcDimensions.y = (displayDim.x * cameraDim.height) / cameraDim.width;
        return calcDimensions;
    }
    //use "<" to zoom preview full screen
    if (widthRatio > heightRatio) { 
        Point calcDimensions = new Point();
        calcDimensions.x = (displayDim.y * cameraDim.width) / cameraDim.height;
        calcDimensions.y = displayDim.y;
        return calcDimensions;
    }
    return null;
}   
}

Mein Kommentar:

Dem Punkt, der all dies ist, dass, obwohl Sie die Berechnung der optimale Kamera-Größe in getOptimalPreviewSize() Sie Holen nur die nächstgelegene Verhältnisum Ihren Bildschirm passen. Es sei denn, das Verhältnis ist genau die gleichen die Vorschau wird Strecken.

Warum wird es zu dehnen? Weil Ihr FrameLayout Kamera-Vorschau in layout.xml zu match_parent in Breite und Höhe. So, dass ist der Grund, warum die Vorschau wird gestreckt auf Vollbild.

Was getan werden muss, ist zu set-Kamera-Vorschau-layout Breite und Höhe entsprechend der gewählten - Kamera-Größe-Verhältnisso die Vorschau hält, Seitenverhältnis und nicht verzerren.

Ich habe versucht, die CameraPreview Klasse, der alle Berechnungen und layout-änderungen, aber ich konnte nicht es herausfinden. Ich habe versucht, zu gelten diese Lösungaber SurfaceView nicht erkennen getChildCount () oder getChildAt (int index). Ich denke, ich habe es arbeiten schließlich mit einem Verweis auf maLayoutPreviewaber es war schlecht benommen und angewendet, das Verhältnis zu meiner ganzen app-und es hat so nach dem ersten Bild aufgenommen wurde. Also ließ ich ihn gehen und zog die änderungen am layout der MainActivity.

In CameraPreview ich geändert prSupportedPreviewSizes und getOptimalPreviewSize() zu öffentlichen damit ich Sie in MainActivity. Dann brauchte ich die display Abmessungen (abzüglich der navigation/status-bar, wenn es einer ist) und der gewählten optimalen Kamera Größe. Ich habe versucht, um das RelativeLayout (oder FrameLayout) Größe statt der display-Größe, aber es wurde wieder den Wert null. Diese Lösung hat bei mir nicht funktioniert. Das layout bekam es Wert ist, nach onWindowFocusChanged (überprüft in der log).

So, ich habe meine Methoden für die Berechnung der layout-Abmessungen zu entsprechen, die das Seitenverhältnis des gewählten Kamera-Größe. Jetzt müssen Sie nur festlegen LayoutParams Ihrer Kamera-Vorschau-layout. Ändern Sie die Breite, Höhe und zentrieren Sie es im übergeordneten.

Gibt es zwei Möglichkeiten wie die Berechnung der Vorschau die Abmessungen. Entweder man will es, um den Bildschirm passen mit schwarzen Balken (wenn windowBackground auf null gesetzt ist) an den Seiten oder oben/unten. Oder möchten Sie die Vorschau gezoomt auf Vollbild. Ich verließ Kommentar mit mehr Informationen in calcCamPrevDimensions().

InformationsquelleAutor der Antwort Will Neithan

Nur zu diesem thread mehr komplett ich füge meine version der Antwort:

Was ich erreichen wollte:
Die Oberfläche Ansicht sollte nicht gedehnt werden, und es sollte sich auf den ganzen Bildschirm, Außerdem gab es nur ein Querformat-Modus in meinem app.

Lösung:

Die Lösung ist eine extrem kleine Erweiterung F1sher Lösung:

=> ein Erster Schritt ist die Integration F1sher Lösung.

=> Nun, es könnte ein Szenario entstehen, in F1sher Lösung, wenn die Oberfläche Ansicht nicht den gesamten Bildschirm erstreckt, ist Die Lösung, um die Oberfläche anzeigen, die größer als der Bildschirm Abmessungen, so dass es den gesamten Bildschirm erstreckt, für:

    size = getOptimalPreviewSize(mCamera.getParameters().getSupportedPreviewSizes(), screenWidth, screenHeight);

    Camera.Parameters parameters = mCamera.getParameters();
    parameters.setPreviewSize(size.width, size.height);


    mCamera.setParameters(parameters);      

    double screenRatio = (double) screenHeight / screenWidth;
    double previewRatio = (double) size.height / size.width;

    if (previewRatio > screenRatio)     /*if preview ratio is greater than screen ratio then we will have to recalculate the surface height while keeping the surface width equal to the screen width*/
    {
        RelativeLayout.LayoutParams params1 = new RelativeLayout.LayoutParams(screenWidth, (int) (screenWidth * previewRatio));
        params1.addRule(RelativeLayout.CENTER_IN_PARENT);
        flPreview.setLayoutParams(params1);

        flPreview.setClipChildren(false);

        LayoutParams surfaceParams = new LayoutParams(screenWidth, (int) (screenWidth * previewRatio));
        surfaceParams.gravity = Gravity.CENTER;
        mPreview.setLayoutParams(surfaceParams);        
    }
    else     /*if preview ratio is smaller than screen ratio then we will have to recalculate the surface width while keeping the surface height equal to the screen height*/
    {
        RelativeLayout.LayoutParams params1 = new RelativeLayout.LayoutParams((int) ((double) screenHeight / previewRatio), screenHeight);
        params1.addRule(RelativeLayout.CENTER_IN_PARENT);
        flPreview.setLayoutParams(params1);
        flPreview.setClipChildren(false);

        LayoutParams surfaceParams = new LayoutParams((int) ((double) screenHeight / previewRatio), screenHeight);
        surfaceParams.gravity = Gravity.CENTER;
        mPreview.setLayoutParams(surfaceParams);

    }       

    flPreview.addView(mPreview); 

  /*  The TopMost layout used is the RelativeLayout, flPreview is the FrameLayout in which Surface View is added, mPreview is an instance of a class which extends SurfaceView  */

InformationsquelleAutor der Antwort Sarthak Mittal

Dachte ich, was ist das problem - es ist mit Orientierung änderungen. Wenn Sie ändern der Kamera-Ausrichtung um 90 oder 270 Grad, als Sie brauchen, um swap Breite und Höhe der unterstützten Größen und alles wird ok sein.

Auch Oberfläche anzeigen sollen, liegen in einem frame-layout und Zentrum der Schwerkraft.

Hier ist ein Beispiel in C# (Xamarin):

public void SurfaceChanged(ISurfaceHolder holder, Android.Graphics.Format format, int width, int height)
{
    _camera.StopPreview();

    //find best supported preview size

    var parameters = _camera.GetParameters();
    var supportedSizes = parameters.SupportedPreviewSizes;
    var bestPreviewSize = supportedSizes
        .Select(x => new { Width = x.Height, Height = x.Width, Original = x }) //HACK swap height and width because of changed orientation to 90 degrees
        .OrderBy(x => Math.Pow(Math.Abs(x.Width - width), 3) + Math.Pow(Math.Abs(x.Height - height), 2))
        .First();

    if (height == bestPreviewSize.Height && width == bestPreviewSize.Width)
    {
        //start preview if best supported preview size equals current surface view size

        parameters.SetPreviewSize(bestPreviewSize.Original.Width, bestPreviewSize.Original.Height);
        _camera.SetParameters(parameters);
        _camera.StartPreview();
    }
    else
    {
        //if not than change surface view size to best supported (SurfaceChanged will be called once again)

        var layoutParameters = _surfaceView.LayoutParameters;
        layoutParameters.Width = bestPreviewSize.Width;
        layoutParameters.Height = bestPreviewSize.Height;
        _surfaceView.LayoutParameters = layoutParameters;
    }
}

Achten, dass die Kamera-Parameter sollte so eingestellt werden, original Größe (nicht getauscht), und surface view Größe sollte getauscht werden.

InformationsquelleAutor der Antwort Alexander Danilov

Meine Anforderungen sind die Kamera-Vorschau werden müssen fullscreen und behalten das Seitenverhältnis bei.
Hesam und Yoosuf die Lösung war toll, aber ich sehe eine high-zoom-problem aus irgendeinem Grund.

Die Idee ist die gleiche, haben die Vorschau-container-center im übergeordneten und erhöhen Sie die Breite oder Höhe hängt von der Seitenverhältnisse, bis es den ganzen Bildschirm bedecken.

Eine Sache zu beachten ist die Größe der Vorschau ist in der Landschaft, da setzen wir die display-Ausrichtung.

Kamera.setDisplayOrientation(90);

Den container, fügen wir die SurfaceView anzeigen:

<RelativeLayout
    android:id="@+id/camera_preview_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:layout_centerInParent="true"/>

Fügen Sie die Vorschau, um es in den container, der mittig in der Eltern in Ihrer Aktivität.

this.cameraPreview = new CameraPreview(this, camera);
cameraPreviewContainer.removeAllViews();
RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(
    ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
params.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);
cameraPreviewContainer.addView(cameraPreview, 0, params);

Innerhalb der CameraPreview Klasse:

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
    //If your preview can change or rotate, take care of those events here.
    //Make sure to stop the preview before resizing or reformatting it.

    if (holder.getSurface() == null) {
        //preview surface does not exist
        return;
    }

    stopPreview();

    //set preview size and make any resize, rotate or
    //reformatting changes here
    try {
        Camera.Size nativePictureSize = CameraUtils.getNativeCameraPictureSize(camera);
        Camera.Parameters parameters = camera.getParameters();
        parameters.setPreviewSize(optimalSize.width, optimalSize.height);
        parameters.setPictureSize(nativePictureSize.width, nativePictureSize.height);
        camera.setParameters(parameters);
        camera.setDisplayOrientation(90);
        camera.setPreviewDisplay(holder);
        camera.startPreview();

    } catch (Exception e){
        Log.d(TAG, "Error starting camera preview: " + e.getMessage());
    }
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
    final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);

    if (supportedPreviewSizes != null && optimalSize == null) {
        optimalSize = CameraUtils.getOptimalSize(supportedPreviewSizes, width, height);
        Log.i(TAG, "optimal size: " + optimalSize.width + "w, " + optimalSize.height + "h");
    }

    float previewRatio =  (float) optimalSize.height / (float) optimalSize.width;
    //previewRatio is height/width because camera preview size are in landscape.
    float measuredSizeRatio = (float) width / (float) height;

    if (previewRatio >= measuredSizeRatio) {
        measuredHeight = height;
        measuredWidth = (int) ((float)height * previewRatio);
    } else {
        measuredWidth = width;
        measuredHeight = (int) ((float)width / previewRatio);
    }
    Log.i(TAG, "Preview size: " + width + "w, " + height + "h");
    Log.i(TAG, "Preview size calculated: " + measuredWidth + "w, " + measuredHeight + "h");

    setMeasuredDimension(measuredWidth, measuredHeight);
}

InformationsquelleAutor der Antwort Howard Lin