Kameravorschau

Hinweis:Diese Seite bezieht sich auf das Camera2-Paket. Sofern für Ihre App keine spezifischen Low-Level-Funktionen von Camera2 erforderlich sind, empfehlen wir die Verwendung von CameraX. Sowohl CameraX als auch Camera2 unterstützen Android 5.0 (API-Level 21) und höher.

Kameras und Kameravorschauen sind auf Android-Geräten nicht immer gleich ausgerichtet. Geräte.

Eine Kamera befindet sich auf einem Gerät an einer festen Position, unabhängig davon, ob das Gerät ein Smartphone, Tablet oder Computer ist. Wenn sich die Ausrichtung des Geräts ändert, ändert sich die Kameraausrichtung.

Kamera-Apps gehen daher in der Regel von einer festen Beziehung zwischen den Ausrichtung des Geräts und das Seitenverhältnis der Kameravorschau. Wenn ein Smartphone im Hochformat angezeigt wird, wird für die Kameravorschau angenommen, dass sie größer ist. als breit ist. Wenn das Smartphone und die Kamera ins Querformat gedreht werden, Die Kameravorschau sollte breiter als hoch sein.

Allerdings werden diese Annahmen durch neue Formfaktoren wie faltbare Smartphones Geräte und Anzeigemodi zum Beispiel Mehrfenstermodus und Multi-Display Faltbare Geräte ändern die Displaygröße und das Seitenverhältnis unverändert Ausrichtung. Im Mehrfenstermodus sind Kamera-Apps auf einen Teil des Bildschirm und skaliert die Kameravorschau unabhängig von der Geräteausrichtung. Der Multi-Display-Modus ermöglicht die Verwendung sekundärer Bildschirme, die möglicherweise mit derselben Ausrichtung wie das primäre Display haben.

Kameraausrichtung

Die Android-Kompatibilitätsdefinition gibt an, dass ein Kamera-Bildsensor "MÜSSEN so ausgerichtet werden muss, dass der lange der Kamera mit der langen Bildschirmgröße übereinstimmt. Das heißt, wenn das Gerät im Querformat gehalten wird, MÜSSEN die Kameras die Bilder Querformat verwenden. Dies gilt unabhängig vom natürlichen Verhalten des Geräts Ausrichtung; d. h. sie gilt für primäre Geräte im Querformat sowie für primäre Geräte im Hochformat“.

Durch die Anordnung von Kamera zu Bildschirm wird der Anzeigebereich der Kamera maximiert. Sucher in einer Kamera-App. Außerdem geben Bildsensoren ihre Daten Querformat, wobei am häufigsten 4:3 verwendet wird.

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 1: Typische Beziehung zwischen Smartphone- und Kamerasensor Ausrichtung.

Die natürliche Ausrichtung des Kamerasensors ist das Querformat. In Abbildung 1 zeigt der Sensor der Frontkamera (die Kamera zeigt in die gleiche Richtung wie die Display) um 270 Grad relativ zum Telefon gedreht wird, um die Android-Kompatibilitätsdefinition

Um Apps die Sensorrotation zu ermöglichen, camera2-API enthält ein SENSOR_ORIENTATION konstant. Bei den meisten Smartphones und Tablets meldet das Gerät eine Sensorausrichtung. 270 Grad bei Frontkameras und 90 Grad (Perspektive vom Geräterückseite) für rückseitige Kameras verwenden, da dies an der langen Seite des an der langen Seite des Geräts an. Laptop-Kameras melden in der Regel Sensorausrichtung von 0 oder 180 Grad.

Hinweis :Die natürliche oder native Ausrichtung entspricht der typischen Ausrichtung eines Geräts. oder Sensor – Hochformat für Smartphones, Querformat für Tablets und Laptops, Querformat für Kamera-Bildsensoren.

Da die Bildsensoren von Kamera ihre Daten (einen Bildpuffer) in den auf die natürliche Ausrichtung des Sensors (Querformat) beschränkt ist, muss der Bildzwischenspeicher Gradzahl in „SENSOR_ORIENTATION“ angegeben, damit die Kameravorschau auf in der natürlichen Ausrichtung des Geräts aufrecht stehen. Bei Frontkameras: Die Drehung erfolgt gegen den Uhrzeigersinn. bei rückseitigen Kameras im Uhrzeigersinn.

Für die Frontkamera in Abbildung 1 ist beispielsweise der Bildpuffer die der Kamerasensor erzeugt, sieht so aus:

Das Bild muss um 270 Grad gegen den Uhrzeigersinn gedreht werden, damit die Vorschau Ausrichtung entspricht der Geräteausrichtung:

Eine Kamera auf der Rückseite erzeugt einen Bildpuffer mit der gleichen Ausrichtung. wie oben angegeben, aber SENSOR_ORIENTATION beträgt 90 Grad. Daher Der Puffer ist um 90 Grad im Uhrzeigersinn gedreht.

Bildschirm drehen

Die Gerätedrehung ist die Gradzahl, um die ein Gerät ausgehend von seinem natürlichen Wert Ausrichtung. Beispiel: Ein Smartphone im Querformat hat ein Gerät Drehung um 90 oder 270 Grad, je nach Drehrichtung.

Ein Kamerasensor-Bildpuffer muss um den gleichen Grad wie der Gerätedrehung (zusätzlich zu den Graden der Sensorausrichtung) für die Kameravorschau so, dass sie aufrecht angezeigt wird.

Ausrichtungsberechnung

Bei der richtigen Ausrichtung der Kameravorschau wird der Sensor Ausrichtung und Gerätedrehung.

Die gesamte Drehung des Sensorbildpuffers kann mithilfe der Funktion folgende Formel:

rotation = (sensorOrientationDegrees - deviceOrientationDegrees * sign + 360) % 360

Dabei ist sign 1 für Frontkameras und -1 für rückseitige Kameras.

Bei Frontkameras wird der Bildzwischenspeicher gegen den Uhrzeigersinn von der natürlichen Ausrichtung des Sensors). Bei Kameras auf der Rückseite kann der Sensor Bildzwischenspeicher wird im Uhrzeigersinn gedreht.

Der Ausdruck deviceOrientationDegrees * sign + 360 konvertiert die Gerätedrehung. bei rückseitigen Kameras (z. B. Umrechnung von 270 Grad gegen den Uhrzeigersinn in 90 Grad im Uhrzeigersinn). Modulo wird das Ergebnis auf weniger als 360 Grad skaliert (z. B. 540 Grad). Drehung auf 180 Grad).

Unterschiedliche APIs melden die Geräterotation unterschiedlich:

• Display#getRotation() ermöglicht die Drehung des Geräts gegen den Uhrzeigersinn (aus dem Punkt des Nutzers) der Ansicht). Dieser Wert lässt sich unverändert in die obige Formel einfügen.
• OrientationEventListener#onOrientationChanged() gibt die Drehung des Geräts im Uhrzeigersinn zurück (aus Sicht des Nutzers). Wert zur Verwendung in der obigen Formel negieren.

Frontkameras

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 2: Kameravorschau und Sensor beim Drehen des Smartphones um 90 Grad auf Querformat.

Hier ist der vom Kamerasensor in Abbildung 2 erzeugte Bildpuffer:

Der Zwischenspeicher muss für die Anpassung an den Sensor um 270 Grad gegen den Uhrzeigersinn gedreht werden. (siehe Kameraausrichtung oben):

Dann wird der Puffer um weitere 90 Grad gegen den Uhrzeigersinn gedreht, Gerätedrehung berücksichtigen, sodass das Display korrekt ausgerichtet ist Kameravorschau in Abbildung 2:

Die Kamera ist von rechts zum Querformat gedreht:

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 3: Kameravorschau und Sensor bei um 270 Grad gedrehtem Smartphone (oder -90 Grad) ins Querformat.

So sieht der Bildpuffer aus:

Der Zwischenspeicher muss für die Anpassung an den Sensor um 270 Grad gegen den Uhrzeigersinn gedreht werden. Ausrichtung:

Dann wird der Puffer um weitere 270 Grad gegen den Uhrzeigersinn gedreht, um Gerätedrehung:

Kameras auf der Rückseite

Rückkameras haben in der Regel eine Sensorausrichtung von 90 Grad von der Rückseite des Geräts gesehen werden. Wenn Sie die Kameravorschau ausrichten, Der Sensorbildzwischenspeicher wird um die Sensordrehung im Uhrzeigersinn gedreht (und nicht gegen den Uhrzeigersinn wie bei Frontkameras) und dann das Bild Der Zwischenspeicher wird um den Grad der Gerätedrehung gegen den Uhrzeigersinn gedreht.

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 4: Smartphone mit Rückkamera im Querformat (270 oder -90 Grad gedreht).

Hier ist der Bildpuffer des Kamerasensors in Abbildung 4:

Der Zwischenspeicher muss für die Anpassung an den Sensor um 90 Grad im Uhrzeigersinn gedreht werden. Ausrichtung:

Dann wird der Zwischenspeicher um 270 Grad gegen den Uhrzeigersinn gedreht, um das Gerät zu berücksichtigen. Rotation:

Seitenverhältnis

Das Seitenverhältnis der Anzeige ändert sich, wenn sich die Geräteausrichtung ändert, oder wenn faltbare Geräte auf- und zuklappen, wenn die Größe der Fenster im Mehrfenstermodus angepasst wird Umgebungen und wenn Apps auf sekundären Bildschirmen geöffnet werden.

Der Kamerasensor-Bildpuffer muss so ausgerichtet und skaliert werden, dass er Ausrichtung und Seitenverhältnis des UI-Elements für den Sucher als Benutzeroberfläche die Ausrichtung dynamisch ändert – mit oder ohne Änderung des Geräts. Ausrichtung.

Bei neuen Formfaktoren oder im Mehrfenstermodus oder Multidisplay-Umgebungen, wenn Ihr In der App wird davon ausgegangen, dass die Kameravorschau genauso ausgerichtet ist wie das Gerät (Hoch- oder Querformat) ist die Vorschau möglicherweise falsch ausgerichtet oder skaliert. falsch sind oder beides.

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 5: Faltbares Gerät wechselt vom Hoch- ins Querformat Seitenverhältnis, aber der Kamerasensor bleibt im Hochformat.

In Abbildung 5 wurde fälschlicherweise angenommen, dass das Gerät um 90 % gedreht wurde. Grad gegen den Uhrzeigersinn; sodass die App die Vorschau um denselben Wert drehte.

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 6: Faltbares Gerät wechselt vom Hoch- ins Querformat Seitenverhältnis, aber der Kamerasensor bleibt im Hochformat.

In Abbildung 6 hat die App das Seitenverhältnis des Bildzwischenspeichers nicht auf Ermöglicht eine korrekte Skalierung an die neuen Abmessungen der Benutzeroberfläche der Kameravorschau -Elements.

Bei Kamera-Apps mit fester Ausrichtung treten auf faltbaren Geräten andere Geräte mit großem Bildschirm, wie z. B. Laptops:

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 7: App im Hochformat auf einem Laptop mit fester Ausrichtung

In Abbildung 7 ist die Benutzeroberfläche der Kamera-App seitlich gedreht, da die Ausrichtung der App auf das Hochformat beschränkt. Das Bild im Sucher ist richtig ausgerichtet. relativ zum Kamerasensor.

Eingesetzter Porträtmodus

Kamera-Apps, die den Mehrfenstermodus nicht unterstützen (resizeableActivity="false") und ihre Ausrichtung einschränken, (screenOrientation="portrait" oder screenOrientation="landscape") kann auf Geräten mit großen Bildschirmen im Porträtmodus platziert werden, die Kameravorschau aufzurufen.

Eingefügte Apps im Hochformat (Einsätze) im Hochformat auch wenn das Seitenverhältnis des Displays im Querformat ist. Apps, die nur im Querformat verfügbar sind, werden im Letterbox-Format dargestellt, obwohl ist das Seitenverhältnis des Bildschirms Hochformat. Das Kamerabild wird zur Ausrichtung gedreht. auf der Benutzeroberfläche der App an das Seitenverhältnis der Kameravorschau angepasst und skaliert, damit die Vorschau ausgefüllt wird.

Porträtmodus wird ausgelöst, wenn das Seitenverhältnis des Kamerabilds Sensor und das Seitenverhältnis der primären Aktivität der App stimmen nicht überein.

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 8: App mit fester Ausrichtung im Porträtmodus aktiviert Laptop.

In Abbildung 8 wurde die Kamera-App im Hochformat so gedreht, dass die Benutzeroberfläche angezeigt wird. auf dem Laptop-Display aufrecht. Aufgrund des Unterschieds wird die App mit Letterbox-Balken versehen. im Seitenverhältnis zwischen der App im Hochformat und einem Display im Querformat. Kamera Das Vorschaubild wurde gedreht, um die Drehung der Benutzeroberfläche der App zu kompensieren (aufgrund im Hochformat) und das Bild wurde so zugeschnitten und skaliert, dass es Hochformat, wodurch das Sichtfeld verringert wird.

Drehen, zuschneiden, skalieren

Eingefügter Porträtmodus wird für eine Kamera-App, die nur im Hochformat auf einem Display angezeigt wird, aufgerufen im Querformat:

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 9: App im Hochformat auf einem Laptop mit fester Ausrichtung

Die App wird im Letterbox-Format dargestellt und im Hochformat angezeigt:

Das Kamerabild wird um 90 Grad gedreht, um es an die Neuausrichtung des App:

Das Bild wird auf das Seitenverhältnis der Kameravorschau zugeschnitten und dann auf Vorschau ausfüllen (Sichtfeld ist verkleinert):

Auf faltbaren Geräten kann der Kamerasensor im Hochformat angezeigt werden während das Seitenverhältnis des Bildschirms im Querformat ist:

<ph type="x-smartling-placeholder">

</ph> <ph type="x-smartling-placeholder">

</ph> Abbildung 10: Aufgeklapptes Gerät mit Kamera-App im Hochformat und Seitenverhältnisse von Kamerasensor und Display verbessern.

Da die Kameravorschau gedreht wird, um sie an die Sensorausrichtung anzupassen, das Bild im Sucher korrekt ausgerichtet ist, aber die App nur im Hochformat seitwärts.

Im Hochformat muss die App nur im Hochformat angezeigt werden. So richten Sie die App- und Kameravorschau richtig aus:

API

Ab Android 12 (API-Level 31) können Apps auch das Hochformat manuell steuern mit der Funktion SCALER_ROTATE_AND_CROP Eigenschaft von CaptureRequest .

Der Standardwert ist SCALER_ROTATE_AND_CROP_AUTO, sodass das System den eingefügten Porträtmodus aufrufen kann. SCALER_ROTATE_AND_CROP_90 ist das oben beschriebene Verhalten des eingefügten Hochformatmodus.

Nicht alle Geräte unterstützen alle SCALER_ROTATE_AND_CROP-Werte. So rufen Sie eine Liste ab: der unterstützten Werte, Verweis CameraCharacteristics#SCALER_AVAILABLE_ROTATE_AND_CROP_MODES

Hinweis: Nur Geräte mit einer Kamerahardware-Abstraktionsebene (HAL) unterstützt, das den SCALER_ROTATE_AND_CROP Mit der API kann der integrierte Porträtmodus aktiviert werden.

KameraX

Hinweis :Jetpack CameraX ist abwärtskompatibel zu Android 5.0 (API). Level 21)

Jetpack CameraX-Bibliothek einen Kamerasucher entwickeln, der die Ausrichtung des Sensors und eine einfache Aufgabe.

Layoutelement PreviewView erstellt eine Kameravorschau, die sich automatisch an die Ausrichtung des Sensors anpasst, Geräterotation und -skalierung. PreviewView behält das Seitenverhältnis des Kamerabild ein, indem Sie die FILL_CENTER Skalierungstyp, mit dem das Bild zentriert wird, es aber möglicherweise auf die Abmessungen zugeschnitten wird der PreviewView. Um das Kamerabild mit einem Letterbox-Bild zu versehen, stellen Sie den Skalierungstyp auf FIT_CENTER

Grundlegende Informationen zum Erstellen einer Kameravorschau mit PreviewView findest du unter Implementieren Sie eine Vorschau.

Ein vollständiges Implementierungsbeispiel finden Sie in der CameraXBasic auf GitHub.

Kamerasucher

Hinweis :Die CameraViewfinder-Bibliothek ist abwärtskompatibel mit Android 5.0 (API-Level 21).

Ähnlich wie beim Anwendungsfall Preview (Vorschau) den Kamerasucher enthält eine Reihe von Tools, mit denen sich eine Kameravorschau einfacher erstellen lässt. Es ist nicht von CameraX Core abhängig – es lässt sich also nahtlos in Ihr vorhandene Camera2-Codebasis.

Anstatt die Methode Surface können Sie die Methode CameraViewfinder um den Kamerafeed für Camera2 anzuzeigen.

CameraViewfinder verwendet intern entweder TextureView oder SurfaceView um den Kamerafeed anzuzeigen, und wendet die erforderlichen Transformationen darauf an. um den Sucher korrekt anzuzeigen. Dazu gehört die Korrektur des Seitenverhältnisses, der Größe und der Drehung.

Um die Oberfläche vom CameraViewfinder-Objekt anzufordern, müssen Sie Erstellen Sie ein ViewfinderSurfaceRequest.

Diese Anfrage enthält Anforderungen an die Oberflächenauflösung und das Kameragerät Informationen aus CameraCharacteristics.

requestSurfaceAsync() wird angerufen sendet die Anfrage an den Oberflächenanbieter. Dies ist entweder ein TextureView- oder SurfaceView und erhält ein ListenableFuture von Surface.

markSurfaceSafeToRelease() wird angerufen informiert den Anbieter der Plattform darüber, dass die Plattform nicht benötigt wird, Ressourcen freigegeben werden können.

Kotlin

fun startCamera(){
    val previewResolution = Size(width, height)
    val viewfinderSurfaceRequest =
        ViewfinderSurfaceRequest(previewResolution, characteristics)
    val surfaceListenableFuture =
        cameraViewfinder.requestSurfaceAsync(viewfinderSurfaceRequest)

    Futures.addCallback(surfaceListenableFuture, object : FutureCallback<Surface> {
        override fun onSuccess(surface: Surface) {
            /* create a CaptureSession using this surface as usual */
        }
        override fun onFailure(t: Throwable) { /* something went wrong */}
    }, ContextCompat.getMainExecutor(context))
}

Java

    void startCamera(){
        Size previewResolution = new Size(width, height);
        ViewfinderSurfaceRequest viewfinderSurfaceRequest =
                new ViewfinderSurfaceRequest(previewResolution, characteristics);
        ListenableFuture<Surface> surfaceListenableFuture =
                cameraViewfinder.requestSurfaceAsync(viewfinderSurfaceRequest);

        Futures.addCallback(surfaceListenableFuture, new FutureCallback<Surface>() {
            @Override
            public void onSuccess(Surface result) {
                /* create a CaptureSession using this surface as usual */
            }
            @Override public void onFailure(Throwable t) { /* something went wrong */}
        },  ContextCompat.getMainExecutor(context));
    }

Oberflächenansicht

SurfaceView ist ein eine einfache Möglichkeit, eine Kameravorschau zu erstellen, wenn die Vorschau nicht müssen verarbeitet werden und sind nicht animiert.

SurfaceView dreht den Kamerasensor-Bildzwischenspeicher automatisch Displayausrichtung und berücksichtigt dabei sowohl die Sensorausrichtung als auch das Gerät Rotation. Der Bildzwischenspeicher wird jedoch so skaliert, dass er in den SurfaceView passt. ohne das Seitenverhältnis zu berücksichtigen.

Achten Sie darauf, dass das Seitenverhältnis des Bildzwischenspeichers Verhältnis von SurfaceView. Dies können Sie erreichen, indem Sie den Inhalt skalieren. der SurfaceView im Feld onMeasure() :

Der Quellcode von computeRelativeRotation() befindet sich in Relative Drehung unten.)

Kotlin

override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
    val width = MeasureSpec.getSize(widthMeasureSpec)
    val height = MeasureSpec.getSize(heightMeasureSpec)

    val relativeRotation = computeRelativeRotation(characteristics, surfaceRotationDegrees)

    if (previewWidth > 0f && previewHeight > 0f) {
        /* Scale factor required to scale the preview to its original size on the x-axis. */
        val scaleX =
            if (relativeRotation % 180 == 0) {
                width.toFloat() / previewWidth
            } else {
                width.toFloat() / previewHeight
            }
        /* Scale factor required to scale the preview to its original size on the y-axis. */
        val scaleY =
            if (relativeRotation % 180 == 0) {
                height.toFloat() / previewHeight
            } else {
                height.toFloat() / previewWidth
            }

        /* Scale factor required to fit the preview to the SurfaceView size. */
        val finalScale = min(scaleX, scaleY)

        setScaleX(1 / scaleX * finalScale)
        setScaleY(1 / scaleY * finalScale)
    }
    setMeasuredDimension(width, height)
}

Java

@Override
void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    int width = MeasureSpec.getSize(widthMeasureSpec);
    int height = MeasureSpec.getSize(heightMeasureSpec);

    int relativeRotation = computeRelativeRotation(characteristics, surfaceRotationDegrees);

    if (previewWidth > 0f && previewHeight > 0f) {

        /* Scale factor required to scale the preview to its original size on the x-axis. */
        float scaleX = (relativeRotation % 180 == 0)
                       ? (float) width / previewWidth
                       : (float) width / previewHeight;

        /* Scale factor required to scale the preview to its original size on the y-axis. */
        float scaleY = (relativeRotation % 180 == 0)
                       ? (float) height / previewHeight
                       : (float) height / previewWidth;

        /* Scale factor required to fit the preview to the SurfaceView size. */
        float finalScale = Math.min(scaleX, scaleY);

        setScaleX(1 / scaleX * finalScale);
        setScaleY(1 / scaleY * finalScale);
    }
    setMeasuredDimension(width, height);
}

Weitere Informationen zur Implementierung von SurfaceView als Kameravorschau findest du unter Kameraausrichtung.

Texturansicht

TextureView ist weniger leistungsstark als SurfaceView – und mehr Arbeit – aber mit TextureView können Sie Ihr Maximum an die Steuerung der Kameravorschau.

TextureView dreht den Sensorbildzwischenspeicher entsprechend der Sensorausrichtung, aber übernimmt keine Geräterotation oder Skalierung der Vorschau.

Skalierung und Rotation können in einem Matrixtransformation. Wenn Sie mehr darüber erfahren möchten, wie Sie TextureView richtig skalieren und drehen, siehe Oberflächen mit anpassbarer Größe in deiner Kamera-App unterstützen

Relative Drehung

Die relative Drehung des Kamerasensors ist die erforderliche Drehung Richten Sie die Kamerasensorausgabe auf die Geräteausrichtung aus.

Die relative Rotation wird von Komponenten wie SurfaceView und TextureView verwendet um x- und y-Skalierungsfaktoren für das Vorschaubild zu bestimmen. Sie wird auch verwendet, um gibt die Drehung des Sensorbildpuffers an.

Die CameraCharacteristics und Surface-Klassen ermöglichen die Berechnung der relative Drehung des Kamerasensors:

Kotlin

/**
 * Computes rotation required to transform the camera sensor output orientation to the
 * device's current orientation in degrees.
 *
 * @param characteristics The CameraCharacteristics to query for the sensor orientation.
 * @param surfaceRotationDegrees The current device orientation as a Surface constant.
 * @return Relative rotation of the camera sensor output.
 */
public fun computeRelativeRotation(
    characteristics: CameraCharacteristics,
    surfaceRotationDegrees: Int
): Int {
    val sensorOrientationDegrees =
        characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    // Reverse device orientation for back-facing cameras.
    val sign = if (characteristics.get(CameraCharacteristics.LENS_FACING) ==
        CameraCharacteristics.LENS_FACING_FRONT
    ) 1 else -1

    // Calculate desired orientation relative to camera orientation to make
    // the image upright relative to the device orientation.
    return (sensorOrientationDegrees - surfaceRotationDegrees * sign + 360) % 360
}

Java

/**
 * Computes rotation required to transform the camera sensor output orientation to the
 * device's current orientation in degrees.
 *
 * @param characteristics The CameraCharacteristics to query for the sensor orientation.
 * @param surfaceRotationDegrees The current device orientation as a Surface constant.
 * @return Relative rotation of the camera sensor output.
 */
public int computeRelativeRotation(
    CameraCharacteristics characteristics,
    int surfaceRotationDegrees
){
    Integer sensorOrientationDegrees =
        characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);

    // Reverse device orientation for back-facing cameras.
    int sign = characteristics.get(CameraCharacteristics.LENS_FACING) ==
        CameraCharacteristics.LENS_FACING_FRONT ? 1 : -1;

    // Calculate desired orientation relative to camera orientation to make
    // the image upright relative to the device orientation.
    return (sensorOrientationDegrees - surfaceRotationDegrees * sign + 360) % 360;
}

Fenstermesswerte

Die Bildschirmgröße sollte nicht zur Bestimmung der Abmessungen der Kamera verwendet werden. Sucher wird die Kamera-App möglicherweise in einem Teil des Bildschirms ausgeführt, im Mehrfenstermodus auf Mobilgeräten oder im Kostenlos-Modus unter ChromeOS.

WindowManager#getCurrentWindowMetrics() (in API-Ebene 30 hinzugefügt) gibt die Größe des Anwendungsfensters und nicht die Größe des Bildschirms anpassen. Die Methoden der Jetpack WindowManager-Bibliothek WindowMetricsCalculator#computeCurrentWindowMetrics() und WindowInfoTracker#currentWindowMetrics() bieten einen ähnlichen Support mit Abwärtskompatibilität wie API-Level 14.

Hinweis: Display-Methoden getRealSize() und getRealMetrics(). werden ab API-Level 31 eingestellt. Die Methoden unterstützen den Mehrfenstermodus nicht oder Freiformmodus. Den Kompaktheitsgrad ermitteln Sie mit Configuration#densityDpi statt getRealMetrics().

Drehung um 180 Grad

Eine Drehung eines Geräts um 180 Grad (zum Beispiel von der natürlichen Ausrichtung auf natürliche Ausrichtung verkehrt herum) löst das onConfigurationChanged() Callback des Nutzers an. Daher kann es passieren, dass die Kameravorschau auf dem Kopf steht.

Um eine Drehung um 180 Grad zu erkennen, implementieren Sie eine DisplayListener und überprüfen Sie die Gerätedrehung mit einem Aufruf an Display#getRotation() in der onDisplayChanged() Callback des Nutzers an.

Exklusive Ressourcen

Vor Android 10 war nur die am stärksten sichtbare Aktivität im Mehrfenstermodus Umgebung hatte den Status RESUMED. Das war verwirrend für die Nutzer, Das System gab keine Hinweise darauf, welche Aktivität wieder aufgenommen wurde.

Mit Android 10 (API-Level 29) wurden mehrere Fortsetzungen eingeführt, bei denen alle sichtbaren Aktivitäten enthalten sind haben den Status RESUMED. Sichtbare Aktivitäten können weiterhin in PAUSED eingegeben werden z. B. ob eine transparente Aktivität über der Aktivität liegt oder die Aktivität nicht fokussierbar ist, wie z. B. im Bild-im-Bild-Modus (siehe Unterstützung von Bild im Bild).

Eine Anwendung, die die Kamera, das Mikrofon oder eine exklusive oder Singleton-Ressource auf API-Level 29 oder höher muss mehrere Fortsetzungen unterstützen. Für Wenn Sie z. B. bei drei fortgesetzten Aktivitäten die Kamera verwenden möchten, kann nur eine um auf diese exklusive Ressource zuzugreifen. Für jede Aktivität muss ein onDisconnected() Callback, um über den präventiven Zugriff auf die Kamera mit höherer Priorität informiert zu werden Aktivitäten.

Hinweis: Einstellung resizeableActivity="false" garantiert keinen Zugriff auf exklusive Ressourcen, da eine andere Aktivität oder ein App, die auf einem sekundären Display ausgeführt wird, eine höhere Priorität haben. Außerdem Seit Android 12 (API-Level 31) verhindert resizeableActivity="false" nicht, aus dem Mehrfenstermodus entfernt wird, in dem andere Aktivitäten Vorrang bei exklusiven Ressourcen.

Weitere Informationen finden Sie unter Multi-Resume:

Weitere Informationen

• Ein Camera2-Beispiel finden Sie in der Camera2Basic-App. auf GitHub.
• Weitere Informationen zum Anwendungsfall der CameraX-Vorschau finden Sie unter CameraX Implementieren Sie eine Vorschau.
• Eine Beispielimplementierung für eine CameraX-Kameravorschau finden Sie in der KameraXBasic auf GitHub.
• Informationen zur Kameravorschau unter ChromeOS finden Sie unter Kameraausrichtung:
• Informationen zum Entwickeln für faltbare Geräte findest du unter Informationen zu faltbaren Geräten