Camera API

Das Android-Framework unterstützt verschiedene Kameras und Kamerafunktionen, die auf Geräte, mit denen Sie in Ihren Anwendungen Bilder und Videos aufnehmen können. In diesem Dokument wird eine eine schnelle, einfache Methode für die Bild- und Videoaufnahme und beschreibt einen erweiterten Ansatz für die Erstellung von maßgeschneiderte Kamerafunktionen für deine Nutzer.

Hinweis: Auf dieser Seite wird die Camera -Klasse, die eingestellt wurde. Wir empfehlen die Verwendung des CameraX Jetpack-Bibliothek oder für bestimmte Anwendungsfälle camera2, . Sowohl CameraX als auch Camera2 funktionieren unter Android 5.0 (API-Level 21) und höher liegen.

Weitere Informationen finden Sie in den folgenden verwandten Ressourcen:

• MediaPlayer – Übersicht
• Daten- und Dateispeicher – Übersicht

Wissenswertes

Bevor Sie Ihre Anwendung für die Verwendung von Kameras auf Android-Geräten aktivieren, sollten Sie einige Fragen dazu, wie deine App diese Hardwarefunktion nutzen möchte.

• Kameraanforderungen: Ist die Verwendung einer Kamera so wichtig für Ihre App, für die Sie nicht möchten, dass sie auf einem Gerät ohne Kamera? Falls ja, sollten Sie die Kameraanforderung in Ihrem Manifestdatei.
• Schnellbild oder benutzerdefinierte Kamera: Wie nutzt Ihre App die Kamera? Möchten Sie nur schnell ein Foto oder einen Videoclip aufnehmen oder ist Ihre Bewerbung eine neue Möglichkeit bieten, Kameras zu verwenden? Für einen schnellen Schnappschuss oder Clip Bestehende Kamera-Apps verwenden: Informationen zur Entwicklung einer benutzerdefinierten Kamerafunktion finden Sie finden Sie im Abschnitt Kamera-App erstellen.
• Anforderungen an Dienste im Vordergrund: Wann interagiert Ihre App mit in die Kamera? Unter Android 9 (API-Level 28) und höher werden Hintergrund kann nicht auf die Kamera zugreifen. Deshalb sollten Sie die Kamera wenn Ihre App im Vordergrund ausgeführt wird Dienst im Vordergrund.
• Speicher: Sind die von Ihrer App generierten Bilder oder Videos nur für Ihre App sichtbar oder freigegeben, damit andere Apps wie Gallery oder andere und Social Apps nutzen können? Möchten Sie, dass die Bilder und Videos auch dann verfügbar sind, wenn Ihr App deinstalliert? Weitere Informationen findest du im Abschnitt Mediendateien speichern. erfahren Sie, wie Sie diese Optionen implementieren.

Grundlagen

Das Android-Framework unterstützt die Erfassung von Bildern und Videos über die android.hardware.camera2 API oder Kamera-Intent. Hier sind die relevanten Klassen:

android.hardware.camera2

Dieses Paket ist die primäre API zum Steuern der Gerätekameras. Damit lassen sich wenn Sie eine Kamera-App erstellen.

Camera

Diese Klasse ist die ältere eingestellte API zur Steuerung von Gerätekameras.

SurfaceView

Mit dieser Klasse wird Nutzern eine Live-Kameravorschau präsentiert.

MediaRecorder

Mit dieser Klasse werden Videos von der Kamera aufgezeichnet.

Intent

Der Aktionstyp MediaStore.ACTION_IMAGE_CAPTURE oder MediaStore.ACTION_VIDEO_CAPTURE für Intent-Aktionen kann verwendet werden, um Bilder oder Videos zu erfassen, ohne direkt Camera verwenden.

Manifestdeklarationen

Bevor Sie mit der Entwicklung Ihrer Anwendung mit der Camera API beginnen, sollten Sie sicherstellen, Ihr Manifest enthält die entsprechenden Deklarationen, um die Verwendung von Kamerahardware und anderen verwandten Funktionen.

• Kameraberechtigung: Ihre App muss die Berechtigung zur Verwendung eines Geräts anfordern. Kamera.

  <uses-permission android:name="android.permission.CAMERA" />
  

  Hinweis:Wenn Sie die Kamera eine vorhandene Kamera-App aufrufen, muss Ihre Anwendung diese Berechtigung nicht anfordern.

• Kamerafunktionen: In Ihrer App muss auch die Verwendung von Kamerafunktionen, Beispiel:

  <uses-feature android:name="android.hardware.camera" />
  

  Eine Liste der Kamerafunktionen findest du im Manifest Funktionen Referenz.

  Wenn Sie Ihrem Manifest Kamerafunktionen hinzufügen, verhindert Google Play, dass Ihre App auf Geräten installiert werden, die keine Kamera haben oder die Kamerafunktionen, die Sie angeben. Weitere Informationen zum funktionsbasierten Filtern bei Google Play finden Sie unter Google Spiel- und funktionsbasierte Filter

  Wenn Ihre App eine Kamera oder Kamerafunktion für ordnungsgemäßen Betrieb verwenden kann, nicht erforderlich ist, sollten Sie dies im Manifest angeben, indem Sie das Attribut android:required einfügen und auf false festlegen:

  <uses-feature android:name="android.hardware.camera" android:required="false" />
  

• Speicherberechtigung: Ihre App kann Bilder oder Videos im den externen Speicher (SD-Karte) des Geräts, wenn er für Android 10 (API-Level 29) oder und gibt Folgendes im Manifest an:

  <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  

• Berechtigung für Audioaufnahme: Für die Audioaufnahme mit Videoaufnahme müssen deine App die Berechtigung für die Audioaufnahme anfordern muss.

  <uses-permission android:name="android.permission.RECORD_AUDIO" />
  

• Standortberechtigung: wenn Bilder in Ihrer Anwendung getaggt werden mit GPS-Standortinformationen muss ACCESS_FINE_LOCATION angefordert werden, Berechtigung. Wenn deine App auf Android 5.0 (API-Level 21) oder höher ist, musst du auch erklären, dass deine App das GPS des Geräts verwendet:

  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  ...
  <!-- Needed only if your app targets Android 5.0 (API level 21) or higher. -->
  <uses-feature android:name="android.hardware.location.gps" />
  

  Weitere Informationen zum Abrufen des Nutzerstandorts finden Sie unter Standortstrategien:

Vorhandene Kamera-Apps verwenden

Eine schnelle Möglichkeit zum Aufnehmen von Fotos oder Videos in Ihrer Anwendung ohne großen zusätzlichen Code mit einer Intent eine vorhandene Android-Kamera-App aufrufen. Ausführliche Informationen hierzu finden Sie in den entsprechenden Lektionen. Fotos einfach aufnehmen und Einfach Videos aufnehmen.

Kamera-App erstellen

Einige Entwickler benötigen möglicherweise eine Kamera-Benutzeroberfläche, die an das Erscheinungsbild oder spezielle Funktionen bietet. Eigenen Code für die Aufnahme von Bildern schreiben können Sie die Nutzererfahrung verbessern.

Hinweis: Die folgende Anleitung bezieht sich auf die ältere, veraltete Camera. der API erstellen. Für neue oder erweiterte Kamera-Apps ist die neuere android.hardware.camera2 API wird empfohlen.

Die allgemeinen Schritte zum Erstellen einer benutzerdefinierten Kameraoberfläche für Ihre Anwendung sind die folgenden:

• Kamera erkennen und darauf zugreifen: Erstellen Sie Code, um zu prüfen, ob folgende Elemente vorhanden sind: und fordern Sie Zugriff an.
• Vorschauklasse erstellen – Erstellt eine Kameravorschauklasse, die SurfaceView erweitert und die SurfaceHolder-Schnittstelle implementiert. Dieses zeigt die Live-Bilder der Kamera in der Vorschau an.
• Vorschaulayout erstellen: Sobald Sie die Klasse „Camera Preview“ haben, erstellen Sie Ansichtslayout, das die Vorschau und die gewünschten Steuerelemente der Benutzeroberfläche enthält.
• Listener für Capture einrichten – Verbinden Sie Listener für Ihre Schnittstelle. zum Starten der Bild- oder Videoaufnahme als Reaktion auf Nutzeraktionen wie das Drücken einer Schaltfläche.
• Dateien erfassen und speichern: Richten Sie den Code für die Aufnahme von Bildern oder und die Ausgabe speichern.
• Kamera freigeben: Nach Verwendung der Kamera muss Ihre App zur Nutzung durch andere Anwendungen freigeben.

Die Kamerahardware ist eine gemeinsam genutzte Ressource, die sorgfältig verwaltet werden muss, damit Ihre Anwendung nicht mit anderen Anwendungen kollidieren, die es ebenfalls nutzen möchten. In den folgenden Abschnitten Kamerahardware erkennen, Zugriff auf eine Kamera anfordern, Bilder oder Videos aufnehmen und wie Sie die Kamera wieder freigeben, wenn Ihre Anwendung sie nicht mehr verwendet.

Achtung: Vergessen Sie nicht, die Camera durch Aufrufen von Camera.release(), wenn die Anwendung abgeschlossen ist. Löst Ihre Anwendung die Kamera nicht ordnungsgemäß, werden alle nachfolgende Versuche, auf die Kamera zuzugreifen, schlagen fehl und können führen dazu, dass Ihre oder andere Anwendungen heruntergefahren werden.

Kamerahardware wird erkannt

Falls für Ihre App keine Kamera mithilfe der Manifest-Deklaration erforderlich ist, können Sie sollte überprüfen, ob zur Laufzeit eine Kamera verfügbar ist. Verwenden Sie für diese Prüfung die Methode PackageManager.hasSystemFeature(), wie im folgenden Beispielcode gezeigt:

Kotlin

/** Check if this device has a camera */
private fun checkCameraHardware(context: Context): Boolean {
    if (context.packageManager.hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
        // this device has a camera
        return true
    } else {
        // no camera on this device
        return false
    }
}

Java

/** Check if this device has a camera */
private boolean checkCameraHardware(Context context) {
    if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)){
        // this device has a camera
        return true;
    } else {
        // no camera on this device
        return false;
    }
}

Android-Geräte können mehrere Kameras haben, z. B. eine Kamera auf der Rückseite zum Fotografieren und eine Frontkamera für Videoanrufe. Unter Android 2.3 (API-Level 9) und höher können Sie Anzahl der Kameras, die auf einem Gerät mit der Methode Camera.getNumberOfCameras() verfügbar sind.

Auf Kameras zugreifen

Wenn Sie festgestellt haben, dass das Gerät, auf dem Ihre Anwendung ausgeführt wird, über eine Kamera verfügt, können Sie muss über eine Instanz von Camera Zugriff darauf anfordern (es sei denn, Sie die einen Intent verwenden, um auf die Kamera zuzugreifen).

Verwende die Methode Camera.open(), um auf die primäre Kamera zuzugreifen und achten Sie darauf, alle Ausnahmen zu erfassen, wie im folgenden Code gezeigt:

Kotlin

/** A safe way to get an instance of the Camera object. */
fun getCameraInstance(): Camera? {
    return try {
        Camera.open() // attempt to get a Camera instance
    } catch (e: Exception) {
        // Camera is not available (in use or does not exist)
        null // returns null if camera is unavailable
    }
}

Java

/** A safe way to get an instance of the Camera object. */
public static Camera getCameraInstance(){
    Camera c = null;
    try {
        c = Camera.open(); // attempt to get a Camera instance
    }
    catch (Exception e){
        // Camera is not available (in use or does not exist)
    }
    return c; // returns null if camera is unavailable
}

Achtung:Achten Sie bei der Verwendung von Camera.open() immer auf Ausnahmen. Fehler bei der Prüfung auf Ausnahmen, wenn sich die Kamera im verwenden oder nicht vorhanden sind, wird Ihre Anwendung vom System heruntergefahren.

Auf Geräten mit Android 2.3 (API-Level 9) oder höher können Sie über Camera.open(int) Mit dem Beispielcode oben wird auf die erste Kamera auf der Rückseite eines Geräts mit mehr als einer Kamera.

Kamerafunktionen werden geprüft

Sobald du Zugriff auf eine Kamera hast, kannst du weitere Informationen zu ihren Funktionen über die Methode Camera.getParameters() und prüfen Sie, hat ein Camera.Parameters-Objekt für unterstützte Funktionen zurückgegeben. Bei Verwendung API-Level 9 oder höher – verwende Camera.getCameraInfo(), um festzustellen, ob sich eine Kamera auf der Vorderseite befindet des Geräts und die Ausrichtung des Bildes.

Vorschauklasse erstellen

Damit Nutzer effektiv Bilder oder Videos aufnehmen können, müssen sie in der Lage sein, zu sehen, was die Gerätekamera sehen. Eine Kameravorschauklasse ist ein SurfaceView, mit dem das Live-Bild angezeigt werden kann Daten, die von einer Kamera stammen, sodass Nutzende ein Bild oder Video aufnehmen können.

Der folgende Beispielcode zeigt, wie Sie eine einfache Kameravorschauklasse erstellen, die in einem View-Layout enthalten. Diese Klasse implementiert SurfaceHolder.Callback, um die Callback-Ereignisse zu erfassen zum Erstellen und Zerstören der Ansicht, die für die Zuweisung der Kameravorschaueingabe erforderlich sind.

Kotlin

/** A basic Camera preview class */
class CameraPreview(
        context: Context,
        private val mCamera: Camera
) : SurfaceView(context), SurfaceHolder.Callback {

    private val mHolder: SurfaceHolder = holder.apply {
        // Install a SurfaceHolder.Callback so we get notified when the
        // underlying surface is created and destroyed.
        addCallback(this@CameraPreview)
        // deprecated setting, but required on Android versions prior to 3.0
        setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS)
    }

    override fun surfaceCreated(holder: SurfaceHolder) {
        // The Surface has been created, now tell the camera where to draw the preview.
        mCamera.apply {
            try {
                setPreviewDisplay(holder)
                startPreview()
            } catch (e: IOException) {
                Log.d(TAG, "Error setting camera preview: ${e.message}")
            }
        }
    }

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

    override fun surfaceChanged(holder: SurfaceHolder, format: Int, w: Int, h: Int) {
        // 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.surface == null) {
            // preview surface does not exist
            return
        }

        // stop preview before making changes
        try {
            mCamera.stopPreview()
        } catch (e: Exception) {
            // 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
        mCamera.apply {
            try {
                setPreviewDisplay(mHolder)
                startPreview()
            } catch (e: Exception) {
                Log.d(TAG, "Error starting camera preview: ${e.message}")
            }
        }
    }
}

Java

/** A basic Camera preview class */
public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
    private SurfaceHolder mHolder;
    private Camera mCamera;

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

        // 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) {
        // The Surface has been created, now tell the camera where to draw the preview.
        try {
            mCamera.setPreviewDisplay(holder);
            mCamera.startPreview();
        } catch (IOException e) {
            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
        }
    }

    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) {
        // 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 {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();

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

Wenn Sie für die Kameravorschau eine bestimmte Größe festlegen möchten, legen Sie dies in der surfaceChanged()-Methode fest, wie in den Kommentaren oben erwähnt. Beim Festlegen der Vorschaugröße Werte aus getSupportedPreviewSizes() müssen verwendet werden. Legen Sie keine beliebigen Werte in der Methode setPreviewSize() fest.

Hinweis: Mit der Einführung der der Mehrfenstermodus unter Android 7.0 (API-Level 24) und höher können Sie länger davon ausgehen, dass das Seitenverhältnis der Vorschau dem Ihrer Aktivität entspricht auch nach dem Anruf bei setDisplayOrientation(). Je nach Fenstergröße und Seitenverhältnis kann die Breite Kameravorschau in ein Hochformat-Layout oder umgekehrt. Letterbox-Layout.

Vorschau in einem Layout platzieren

Eine Kameravorschauklasse, wie im vorherigen Abschnitt gezeigt, muss im Layout einer Aktivität zusammen mit anderen UI-Steuerelementen zum Aufnehmen von Bildern oder Videos. Dieses erfahren Sie, wie Sie ein grundlegendes Layout und eine Aktivität für die Vorschau erstellen.

Der folgende Layoutcode bietet eine sehr einfache Ansicht, die zum Anzeigen einer Kamera verwendet werden kann. in der Vorschau ansehen. In diesem Beispiel soll das FrameLayout-Element der Container für die Kameravorschauklasse. Dieser Layouttyp wird verwendet, damit ein zusätzliches Bild können Informationen oder Steuerelemente über die Vorschaubilder der Live-Kamera eingeblendet werden.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
  <FrameLayout
    android:id="@+id/camera_preview"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:layout_weight="1"
    />

  <Button
    android:id="@+id/button_capture"
    android:text="Capture"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:layout_gravity="center"
    />
</LinearLayout>

Auf den meisten Geräten ist die Standardausrichtung der Kameravorschau das Querformat. Dieses Beispiellayout definiert ein horizontales Layout (Querformat) und der Code unten legt die Ausrichtung der im Querformat anwenden können. Um das Rendern der Kameravorschau zu vereinfachen, sollten Sie das Ausrichtung der Anwendung auf das Querformat festlegen, indem Sie Folgendes zu Ihrem Manifests.

<activity android:name=".CameraActivity"
          android:label="@string/app_name"

          android:screenOrientation="landscape">
          <!-- configure this activity to use landscape orientation -->

          <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Hinweis:Eine Kameravorschau muss nicht im Querformat sein. Ab Android 2.2 (API-Level 8) können Sie mit der setDisplayOrientation()-Methode das Rotation des Vorschaubilds. Um die Ausrichtung der Vorschau zu ändern, wenn Nutzende die Beenden Sie in der Methode surfaceChanged() Ihrer Vorschauklasse zuerst die Vorschau, indem Sie Camera.stopPreview() die Ausrichtung ändern und dann Starten Sie die Vorschau noch einmal mit Camera.startPreview().

Fügen Sie in der Aktivität für die Kameraansicht Ihre Vorschauklasse dem FrameLayout-Element hinzu, wie im Beispiel oben dargestellt. Außerdem muss die Kameraaktivität dass die Kamera beim Pausieren oder Herunterfahren wieder freigegeben wird. Das folgende Beispiel zeigt, wie Sie eine Kameraaktivität ändern, um die Vorschauklasse anzufügen, die unter Erstellen von eine Vorschauklasse erstellen.

Kotlin

class CameraActivity : Activity() {

    private var mCamera: Camera? = null
    private var mPreview: CameraPreview? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Create an instance of Camera
        mCamera = getCameraInstance()

        mPreview = mCamera?.let {
            // Create our Preview view
            CameraPreview(this, it)
        }

        // Set the Preview view as the content of our activity.
        mPreview?.also {
            val preview: FrameLayout = findViewById(R.id.camera_preview)
            preview.addView(it)
        }
    }
}

Java

public class CameraActivity extends Activity {

    private Camera mCamera;
    private CameraPreview mPreview;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Create an instance of Camera
        mCamera = getCameraInstance();

        // Create our Preview view and set it as the content of our activity.
        mPreview = new CameraPreview(this, mCamera);
        FrameLayout preview = (FrameLayout) findViewById(R.id.camera_preview);
        preview.addView(mPreview);
    }
}

Hinweis:Die Methode getCameraInstance() im Beispiel oben bezieht sich auf die Beispielmethode unter Auf Kameras zugreifen.

Bilder aufnehmen

Sobald Sie eine Vorschauklasse und ein Ansichtslayout erstellt haben, in dem sie angezeigt werden soll, können Sie beginnen Sie mit der Aufnahme von Bildern mit Ihrer Anwendung. In Ihrem Anwendungscode müssen Sie Listener einrichten. damit die Benutzeroberfläche auf Nutzeraktionen reagiert, indem sie ein Bild aufnehmen.

Verwenden Sie zum Abrufen eines Bildes die Methode Camera.takePicture(). Diese Methode verwendet drei Parameter, die Daten von der Kamera empfangen. Um Daten im JPEG-Format zu empfangen, müssen Sie eine Camera.PictureCallback-Schnittstelle implementieren, um die Bilddaten zu empfangen und in eine Datei zu schreiben. Der folgende Code zeigt eine grundlegende Implementierung der Camera.PictureCallback-Schnittstelle zum Speichern eines von der Kamera empfangenen Bilds.

Kotlin

private val mPicture = Camera.PictureCallback { data, _ ->
    val pictureFile: File = getOutputMediaFile(MEDIA_TYPE_IMAGE) ?: run {
        Log.d(TAG, ("Error creating media file, check storage permissions"))
        return@PictureCallback
    }

    try {
        val fos = FileOutputStream(pictureFile)
        fos.write(data)
        fos.close()
    } catch (e: FileNotFoundException) {
        Log.d(TAG, "File not found: ${e.message}")
    } catch (e: IOException) {
        Log.d(TAG, "Error accessing file: ${e.message}")
    }
}

Java

private PictureCallback mPicture = new PictureCallback() {

    @Override
    public void onPictureTaken(byte[] data, Camera camera) {

        File pictureFile = getOutputMediaFile(MEDIA_TYPE_IMAGE);
        if (pictureFile == null){
            Log.d(TAG, "Error creating media file, check storage permissions");
            return;
        }

        try {
            FileOutputStream fos = new FileOutputStream(pictureFile);
            fos.write(data);
            fos.close();
        } catch (FileNotFoundException e) {
            Log.d(TAG, "File not found: " + e.getMessage());
        } catch (IOException e) {
            Log.d(TAG, "Error accessing file: " + e.getMessage());
        }
    }
};

Rufen Sie die Methode Camera.takePicture() auf, um das Erfassen eines Bildes auszulösen. Der folgende Beispielcode zeigt, wie diese Methode aus einem Schaltfläche View.OnClickListener.

Kotlin

val captureButton: Button = findViewById(R.id.button_capture)
captureButton.setOnClickListener {
    // get an image from the camera
    mCamera?.takePicture(null, null, picture)
}

Java

// Add a listener to the Capture button
Button captureButton = (Button) findViewById(R.id.button_capture);
captureButton.setOnClickListener(
    new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            // get an image from the camera
            mCamera.takePicture(null, null, picture);
        }
    }
);

Hinweis:Das Mitglied mPicture im folgenden Beispiel bezieht sich auf im obigen Beispielcode hinzufügen.

Achtung: Vergessen Sie nicht, die Camera durch Aufrufen von Camera.release(), wenn die Anwendung abgeschlossen ist. Informationen zum Freigeben der Kamera finden Sie unter Kamera loslösen.

Videos aufnehmen

Für Videoaufnahmen mit dem Android-Framework ist eine sorgfältige Verwaltung des Camera-Objekts und eine Abstimmung mit dem MediaRecorder erforderlich . Wenn du ein Video mit Camera aufzeichnest, musst du die Camera.lock()- und Camera.unlock()-Aufrufe verwalten, um MediaRecorder Zugriff auf die Kamerahardware zu gewähren. zusätzlich zu den Aufrufen Camera.open() und Camera.release().

Hinweis:Ab Android 4.0 (API-Level 14) werden die Aufrufe Camera.lock() und Camera.unlock() automatisch für Sie verwaltet.

Anders als beim Aufnehmen von Bildern mit der Kamera eines Geräts ist für die Videoaufnahme ein ganz bestimmter Anruf erforderlich. Reihenfolge. Sie müssen eine bestimmte Ausführungsreihenfolge einhalten, um sich erfolgreich auf das Video vorzubereiten und es aufzunehmen wie unten beschrieben.

1. Kamera öffnen: Verwende die Camera.open(). um eine Instanz des Kameraobjekts zu erhalten.
2. Vorschau verbinden – Bereite eine Live-Kamerabildvorschau vor, indem du ein SurfaceView über Camera.setPreviewDisplay() mit der Kamera verbindest.
3. Vorschau starten: Rufen Sie Camera.startPreview() auf, um die Live-Kamerabilder anzusehen.
4. Video aufnehmen: Die folgenden Schritte müssen in für die Videoaufzeichnung: <ph type="x-smartling-placeholder">
   </ph>
   1. Kamera entsperren: Rufen Sie Camera.unlock() auf, um die Kamera für MediaRecorder zu entsperren.
   2. MediaRecorder konfigurieren: Rufen Sie die folgenden MediaRecorder-Methoden in dieser Reihenfolge auf. Weitere Informationen finden Sie in der Referenzdokumentation zu MediaRecorder.
      1. setCamera() – Kamera für Videoaufnahmen festlegen und aktuelle Instanz Ihrer Anwendung verwenden von Camera.
      2. setAudioSource() – Legen Sie die Audioquelle – MediaRecorder.AudioSource.CAMCORDER verwenden.
      3. setVideoSource() – festgelegt der Videoquelle: MediaRecorder.VideoSource.CAMERA.
      4. Legen Sie das Videoausgabeformat und die Codierung fest. Für Android 2.2 (API-Level 8) und höher ist, verwenden Sie die Methode MediaRecorder.setProfile und rufen Sie mit CamcorderProfile.get() eine Profilinstanz ab. Für Android-Versionen vor 2.2 müssen Sie das Videoausgabeformat und die Codierungsparameter festlegen: <ph type="x-smartling-placeholder">
         </ph>
         1. setOutputFormat() – festgelegt Ausgabeformat verwenden möchten, geben Sie die Standardeinstellung oder MediaRecorder.OutputFormat.MPEG_4 an.
         2. setAudioEncoder() – festgelegt den Toncodierungstyp auswählen, geben Sie die Standardeinstellung oder MediaRecorder.AudioEncoder.AMR_NB an.
         3. setVideoEncoder() – festgelegt den Videocodierungstyp aus, geben Sie die Standardeinstellung oder MediaRecorder.VideoEncoder.MPEG_4_SP an.
      5. setOutputFile() – Legen Sie die Ausgabedatei fest. Verwenden Sie getOutputMediaFile(MEDIA_TYPE_VIDEO).toString() aus dem Beispiel. im Abschnitt Mediendateien speichern.
      6. setPreviewDisplay() - Geben Sie das Vorschau-Layoutelement SurfaceView an für Ihre Anwendung. Verwenden Sie dasselbe Objekt, das Sie für Connect Preview angegeben haben.

      Achtung: Sie müssen diese MediaRecorder-Konfigurationsmethoden in dieser Reihenfolge aufrufen. Andernfalls treten Fehler auf und die Aufzeichnung schlägt fehl.

   3. MediaRecorder vorbereiten – MediaRecorder vorbereiten mit den bereitgestellten Konfigurationseinstellungen durch Aufrufen von MediaRecorder.prepare().
   4. MediaRecorder starten: Starten Sie die Videoaufnahme durch Aufrufen von MediaRecorder.start().
5. Videoaufzeichnung beenden: Rufe der Reihe nach die folgenden Methoden auf: Videoaufzeichnung erfolgreich abgeschlossen haben: <ph type="x-smartling-placeholder">
   </ph>
   1. MediaRecorder beenden: Rufen Sie MediaRecorder.stop() auf, um die Videoaufnahme zu beenden.
   2. MediaRecorder zurücksetzen: Entfernen Sie optional die Konfigurationseinstellungen aus den Rekorder durch Aufrufen von MediaRecorder.reset().
   3. Release MediaRecorder – MediaRecorder veröffentlichen indem du MediaRecorder.release() anrufst.
   4. Kamera sperren: Sperren Sie die Kamera, damit sie in zukünftigen MediaRecorder-Sitzungen verwendet werden kann. Dazu rufen Sie Camera.lock() auf. Ab Android 4.0 (API-Level 14) ist dieser Aufruf nur dann erforderlich, wenn die MediaRecorder.prepare()-Aufruf schlägt fehl.
6. Vorschau beenden: Wenn Ihre Aktivität die Verwendung der Kamera beendet hat, stoppen Sie die Vorschau mit Camera.stopPreview() anzeigen.
7. Kamera freigeben: Lassen Sie die Kamera los, damit andere Anwendungen die Kamera verwenden können. indem Sie Camera.release() aufrufen.

Hinweis: Es ist möglich, MediaRecorder zu verwenden. ohne vorher eine Kameravorschau zu erstellen. Die ersten Schritte werden übersprungen. Sie können jedoch da Nutzende in der Regel lieber eine Vorschau sehen, bevor sie mit der Aufzeichnung beginnen, die hier besprochen werden.

Tipp:Wenn Ihre App normalerweise zum Aufzeichnen von Videos verwendet wird, legen Sie setRecordingHint(boolean) bis true vor Beginn deines in der Vorschau ansehen. Mit dieser Einstellung lässt sich die Aufnahmezeit verkürzen.

MediaRecorder konfigurieren

Wenn Sie die Klasse MediaRecorder zum Aufzeichnen von Videos verwenden, müssen Sie Konfigurationsschritten in einer bestimmten Reihenfolge und rufen Sie dann die MediaRecorder.prepare()-Methode auf, um die Konfiguration. Der folgende Beispielcode zeigt, wie die Konfiguration und Vorbereitung des MediaRecorder Kurs für die Videoaufzeichnung.

Kotlin

private fun prepareVideoRecorder(): Boolean {
    mediaRecorder = MediaRecorder()

    mCamera?.let { camera ->
        // Step 1: Unlock and set camera to MediaRecorder
        camera?.unlock()

        mediaRecorder?.run {
            setCamera(camera)

            // Step 2: Set sources
            setAudioSource(MediaRecorder.AudioSource.CAMCORDER)
            setVideoSource(MediaRecorder.VideoSource.CAMERA)

            // Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
            setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH))

            // Step 4: Set output file
            setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString())

            // Step 5: Set the preview output
            setPreviewDisplay(mPreview?.holder?.surface)

            setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
            setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT)
            setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT)


            // Step 6: Prepare configured MediaRecorder
            return try {
                prepare()
                true
            } catch (e: IllegalStateException) {
                Log.d(TAG, "IllegalStateException preparing MediaRecorder: ${e.message}")
                releaseMediaRecorder()
                false
            } catch (e: IOException) {
                Log.d(TAG, "IOException preparing MediaRecorder: ${e.message}")
                releaseMediaRecorder()
                false
            }
        }

    }
    return false
}

Java

private boolean prepareVideoRecorder(){

    mCamera = getCameraInstance();
    mediaRecorder = new MediaRecorder();

    // Step 1: Unlock and set camera to MediaRecorder
    mCamera.unlock();
    mediaRecorder.setCamera(mCamera);

    // Step 2: Set sources
    mediaRecorder.setAudioSource(MediaRecorder.AudioSource.CAMCORDER);
    mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);

    // Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
    mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_HIGH));

    // Step 4: Set output file
    mediaRecorder.setOutputFile(getOutputMediaFile(MEDIA_TYPE_VIDEO).toString());

    // Step 5: Set the preview output
    mediaRecorder.setPreviewDisplay(mPreview.getHolder().getSurface());

    // Step 6: Prepare configured MediaRecorder
    try {
        mediaRecorder.prepare();
    } catch (IllegalStateException e) {
        Log.d(TAG, "IllegalStateException preparing MediaRecorder: " + e.getMessage());
        releaseMediaRecorder();
        return false;
    } catch (IOException e) {
        Log.d(TAG, "IOException preparing MediaRecorder: " + e.getMessage());
        releaseMediaRecorder();
        return false;
    }
    return true;
}

Vor Android 2.2 (API-Level 8) musst du das Ausgabeformat und die Codierungsformate festlegen. -Parameter direkt anwenden, anstatt CamcorderProfile zu verwenden. Dieser Ansatz ist im folgenden Code dargestellt:

Kotlin

    // Step 3: Set output format and encoding (for versions prior to API Level 8)
    mediaRecorder?.apply {
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT)
        setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT)
    }

Java

    // Step 3: Set output format and encoding (for versions prior to API Level 8)
    mediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
    mediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.DEFAULT);
    mediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.DEFAULT);

Für MediaRecorder sind die folgenden Videoaufnahmeparameter angegeben Standardeinstellungen. Möglicherweise möchten Sie die folgenden Einstellungen für Ihre Anwendung anpassen:

• setVideoEncodingBitRate()
• setVideoSize()
• setVideoFrameRate()
• setAudioEncodingBitRate()
• setAudioChannels()
• setAudioSamplingRate()

MediaRecorder starten und beenden

Gehen Sie beim Starten und Beenden der Videoaufzeichnung mit der Klasse MediaRecorder so vor: muss eine bestimmte Reihenfolge eingehalten werden (siehe unten).

1. Kamera mit Camera.unlock() entsperren
2. Konfigurieren Sie MediaRecorder wie im obigen Codebeispiel gezeigt
3. Aufnahme mit MediaRecorder.start() starten
4. Video aufnehmen
5. Aufnahme mit MediaRecorder.stop() beenden
6. Medienrekorder mit MediaRecorder.release() loslassen
7. Kamera mit Camera.lock() sperren

Der folgende Beispielcode zeigt, wie eine Taste verkabelt wird, damit sie richtig gestartet und beendet wird. Videoaufnahme mit der Kamera und der Klasse MediaRecorder.

Hinweis:Lassen Sie die Kamera am Ende einer Videoaufnahme nicht los. Andernfalls wird die Vorschau beendet.

Kotlin

var isRecording = false
val captureButton: Button = findViewById(R.id.button_capture)
captureButton.setOnClickListener {
    if (isRecording) {
        // stop recording and release camera
        mediaRecorder?.stop() // stop the recording
        releaseMediaRecorder() // release the MediaRecorder object
        mCamera?.lock() // take camera access back from MediaRecorder

        // inform the user that recording has stopped
        setCaptureButtonText("Capture")
        isRecording = false
    } else {
        // initialize video camera
        if (prepareVideoRecorder()) {
            // Camera is available and unlocked, MediaRecorder is prepared,
            // now you can start recording
            mediaRecorder?.start()

            // inform the user that recording has started
            setCaptureButtonText("Stop")
            isRecording = true
        } else {
            // prepare didn't work, release the camera
            releaseMediaRecorder()
            // inform user
        }
    }
}

Java

private boolean isRecording = false;

// Add a listener to the Capture button
Button captureButton = (Button) findViewById(id.button_capture);
captureButton.setOnClickListener(
    new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            if (isRecording) {
                // stop recording and release camera
                mediaRecorder.stop();  // stop the recording
                releaseMediaRecorder(); // release the MediaRecorder object
                mCamera.lock();         // take camera access back from MediaRecorder

                // inform the user that recording has stopped
                setCaptureButtonText("Capture");
                isRecording = false;
            } else {
                // initialize video camera
                if (prepareVideoRecorder()) {
                    // Camera is available and unlocked, MediaRecorder is prepared,
                    // now you can start recording
                    mediaRecorder.start();

                    // inform the user that recording has started
                    setCaptureButtonText("Stop");
                    isRecording = true;
                } else {
                    // prepare didn't work, release the camera
                    releaseMediaRecorder();
                    // inform user
                }
            }
        }
    }
);

Hinweis:Im obigen Beispiel entspricht der prepareVideoRecorder()-Wert bezieht sich auf den Beispielcode unter MediaRecorder konfigurieren. Diese Methode übernimmt das Sperren Die Kamera konfigurieren und die MediaRecorder-Instanz konfigurieren und vorbereiten.

Kamera freigeben

Kameras sind eine Ressource, die von Apps auf einem Gerät gemeinsam genutzt wird. Ihre Anwendung kann die Kamera nicht verwenden dürfen, nachdem Camera eine Instanz heruntergeladen wurde. Achten Sie besonders darauf, das Kameraobjekt loszulassen, wenn Ihre Anwendung es nicht mehr verwendet, und sobald Ihre Anwendung pausiert wird (Activity.onPause()). Wenn Ihre App die Kamera nicht ordnungsgemäß freigibt, alle nachfolgenden Versuche, auf die Kamera zuzugreifen, einschließlich derer Ihrer eigenen Anwendung, scheitert und kann dazu führen, dass Ihre oder andere Anwendungen heruntergefahren werden.

Verwenden Sie die Methode Camera.release(), wie im Beispielcode unten gezeigt, um eine Instanz des Camera-Objekts freizugeben.

Kotlin

class CameraActivity : Activity() {
    private var mCamera: Camera?
    private var preview: SurfaceView?
    private var mediaRecorder: MediaRecorder?

    override fun onPause() {
        super.onPause()
        releaseMediaRecorder() // if you are using MediaRecorder, release it first
        releaseCamera() // release the camera immediately on pause event
    }

    private fun releaseMediaRecorder() {
        mediaRecorder?.reset() // clear recorder configuration
        mediaRecorder?.release() // release the recorder object
        mediaRecorder = null
        mCamera?.lock() // lock camera for later use
    }

    private fun releaseCamera() {
        mCamera?.release() // release the camera for other applications
        mCamera = null
    }
}

Java

public class CameraActivity extends Activity {
    private Camera mCamera;
    private SurfaceView preview;
    private MediaRecorder mediaRecorder;

    ...

    @Override
    protected void onPause() {
        super.onPause();
        releaseMediaRecorder();       // if you are using MediaRecorder, release it first
        releaseCamera();              // release the camera immediately on pause event
    }

    private void releaseMediaRecorder(){
        if (mediaRecorder != null) {
            mediaRecorder.reset();   // clear recorder configuration
            mediaRecorder.release(); // release the recorder object
            mediaRecorder = null;
            mCamera.lock();           // lock camera for later use
        }
    }

    private void releaseCamera(){
        if (mCamera != null){
            mCamera.release();        // release the camera for other applications
            mCamera = null;
        }
    }
}

Achtung:Wenn Ihre Anwendung das Ereignis Kamera verwenden, werden alle nachfolgenden Versuche, auf die Kamera zuzugreifen, darunter auch und können dazu führen, dass Ihre oder andere Anwendungen heruntergefahren werden.

Mediendateien werden gespeichert

Von Nutzern erstellte Mediendateien wie Bilder und Videos sollten auf einem externen Gerät Speicherverzeichnis (SD-Karte), um Systemspeicherplatz zu sparen und Nutzern den Zugriff auf diese Dateien zu ermöglichen ohne ihr Gerät. Es gibt viele Speicherorte in Verzeichnissen, in denen Mediendateien auf einem Gerät gespeichert werden können. Es gibt jedoch nur zwei Standard-Standorte, die Sie als Entwickler in Betracht ziehen sollten:

• Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES): Diese Methode gibt den standardmäßigen, den freigegebenen und den empfohlenen Wert zurück. Speicherort für Bilder und Videos. Dieses Verzeichnis ist öffentlich freigegeben, kann an diesem Ort gespeicherte Dateien leicht finden, lesen, ändern und löschen. Wenn Ihre Anwendung vom Nutzer deinstalliert haben, werden an diesem Speicherort gespeicherte Mediendateien nicht entfernt. Um dies zu vermeiden vorhandene Bilder und Videos beeinträchtigt, sollten Sie ein Unterverzeichnis für Ihre in diesem Verzeichnis zu laden, wie im Codebeispiel unten gezeigt. Diese Methode ist verfügbar in Android 2.2 (API-Level 8). Entsprechende Aufrufe in früheren API-Versionen finden Sie unter Freigegebene Dateien speichern.
• Context.getExternalFilesDir(Environment.DIRECTORY_PICTURES): Diese Methode gibt einen Standardstandort zum Speichern zurück. Bilder und Videos, die mit Ihrer App verknüpft sind. Wenn Ihre App deinstalliert ist, werden alle an diesem Speicherort gespeicherten Dateien entfernt. Für Dateien wird hier keine Sicherheit erzwungen und andere Anwendungen können sie lesen, ändern und löschen.

Der folgende Beispielcode zeigt, wie du einen File- oder Uri-Speicherort für eine Mediendatei erstellst, die beim Aufrufen der Kamera eines Geräts mit Intent oder als Teil der Kameraerstellung App.

Kotlin

val MEDIA_TYPE_IMAGE = 1
val MEDIA_TYPE_VIDEO = 2

/** Create a file Uri for saving an image or video */
private fun getOutputMediaFileUri(type: Int): Uri {
    return Uri.fromFile(getOutputMediaFile(type))
}

/** Create a File for saving an image or video */
private fun getOutputMediaFile(type: Int): File? {
    // To be safe, you should check that the SDCard is mounted
    // using Environment.getExternalStorageState() before doing this.

    val mediaStorageDir = File(
            Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),
            "MyCameraApp"
    )
    // This location works best if you want the created images to be shared
    // between applications and persist after your app has been uninstalled.

    // Create the storage directory if it does not exist
    mediaStorageDir.apply {
        if (!exists()) {
            if (!mkdirs()) {
                Log.d("MyCameraApp", "failed to create directory")
                return null
            }
        }
    }

    // Create a media file name
    val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss").format(Date())
    return when (type) {
        MEDIA_TYPE_IMAGE -> {
            File("${mediaStorageDir.path}${File.separator}IMG_$timeStamp.jpg")
        }
        MEDIA_TYPE_VIDEO -> {
            File("${mediaStorageDir.path}${File.separator}VID_$timeStamp.mp4")
        }
        else -> null
    }
}

Java

public static final int MEDIA_TYPE_IMAGE = 1;
public static final int MEDIA_TYPE_VIDEO = 2;

/** Create a file Uri for saving an image or video */
private static Uri getOutputMediaFileUri(int type){
      return Uri.fromFile(getOutputMediaFile(type));
}

/** Create a File for saving an image or video */
private static File getOutputMediaFile(int type){
    // To be safe, you should check that the SDCard is mounted
    // using Environment.getExternalStorageState() before doing this.

    File mediaStorageDir = new File(Environment.getExternalStoragePublicDirectory(
              Environment.DIRECTORY_PICTURES), "MyCameraApp");
    // This location works best if you want the created images to be shared
    // between applications and persist after your app has been uninstalled.

    // Create the storage directory if it does not exist
    if (! mediaStorageDir.exists()){
        if (! mediaStorageDir.mkdirs()){
            Log.d("MyCameraApp", "failed to create directory");
            return null;
        }
    }

    // Create a media file name
    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
    File mediaFile;
    if (type == MEDIA_TYPE_IMAGE){
        mediaFile = new File(mediaStorageDir.getPath() + File.separator +
        "IMG_"+ timeStamp + ".jpg");
    } else if(type == MEDIA_TYPE_VIDEO) {
        mediaFile = new File(mediaStorageDir.getPath() + File.separator +
        "VID_"+ timeStamp + ".mp4");
    } else {
        return null;
    }

    return mediaFile;
}

Hinweis:Environment.getExternalStoragePublicDirectory() ist für Android 2.2 (API-Level 8) oder höher liegen. Wenn die Ausrichtung auf Geräte mit älteren Android-Versionen erfolgt, verwende Environment.getExternalStorageDirectory(). . Weitere Informationen finden Sie unter Freigegebene Dateien speichern.

Damit die URI Arbeitsprofile unterstützt, müssen Sie zuerst Datei-URI in einen Inhalts-URI konvertieren Fügen Sie dann den Inhalts-URI EXTRA_OUTPUT von einem Intent.

Weitere Informationen zum Speichern von Dateien auf einem Android-Gerät finden Sie unter Datenspeicherung.

Kamerafunktionen

Android unterstützt eine Vielzahl von Kamerafunktionen, die du über deine Kamera-App steuern kannst. wie Bildformat, Blitzmodus, Fokuseinstellungen und vieles mehr. In diesem Abschnitt werden allgemeine Kamerafunktionen und ihre Verwendung. Die meisten Kamerafunktionen sind mithilfe des Camera.Parameters-Objekts. Es gibt jedoch mehrere wichtigen Funktionen, die mehr als einfache Einstellungen in Camera.Parameters erfordern. Diese Funktionen werden in den folgenden Abschnitten behandelt:

• Metering und Schwerpunkte
• Gesichtserkennung
• Video im Zeitraffer

Allgemeine Informationen zur Verwendung von Funktionen, die über Camera.Parameters gesteuert werden, finden Sie in der Verwendung der Kamera Funktionen. Detailliertere Informationen zur Verwendung von Funktionen, die über die Kameraparameter-Objekt enthält, folgen Sie den Links in der Funktionsliste unten zur API-Referenz Dokumentation.

Tabelle 1 Gängige Kamerafunktionen sortiert nach dem Android-API-Level, in dem sie eingeführt.

Funktion	API-Ebene	Beschreibung
Gesichtserkennung	14	Erkennen von menschlichen Gesichtern in einem Bild und verwenden Sie sie für den Fokus, Metering und weiße Bilder Guthaben
Messbereiche	14	Geben Sie einen oder mehrere Bereiche innerhalb eines Bildes zur Berechnung des Weißabgleichs an
Schwerpunkte	14	Einen oder mehrere Bildbereiche für den Fokus festlegen
White Balance Lock	14	Automatische Anpassung des Weißabgleichs starten oder beenden
Exposure Lock	14	Automatische Belichtungsanpassungen starten oder stoppen
Video Snapshot	14	Bild während der Videodrehung aufnehmen (Frame-Graben)
Video im Zeitraffer	11	Frames mit festgelegten Verzögerungen aufnehmen, um ein Video im Zeitraffer aufzunehmen
Multiple Cameras	9	Unterstützung für mehrere Kameras auf dem Gerät, darunter Front- und Rückkamera Kameras
Focus Distance	9	Meldet Abstände zwischen der Kamera und Objekten, die im Fokus zu sein scheinen
Zoom	8	Bildvergrößerung festlegen
Exposure Compensation	8	Belichtung erhöhen oder verringern
GPS Data	5	Geografische Standortdaten in das Bild ein- oder weglassen
White Balance	5	Weißabgleichmodus festlegen, der sich auf die Farbwerte im aufgenommenen Bild auswirkt
Focus Mode	5	Hier kannst du festlegen, wie die Kamera auf ein Motiv fokussiert, z. B. automatisch, fest, Makro oder unendlich.
Scene Mode	5	Einen voreingestellten Modus für bestimmte Arten von Fotografiesituationen wie Nacht, Strand oder Schnee anwenden oder Kerzenlicht-Szenen
JPEG Quality	5	Legen Sie die Komprimierungsstufe für ein JPEG-Bild fest, mit der die Ausgabedatei des Bildes vergrößert oder verkleinert wird. Qualität und Größe
Flash Mode	5	Blitz ein- oder ausschalten oder automatische Einstellung verwenden
Color Effects	5	Sie können einen Farbeffekt auf das aufgenommene Bild anwenden, z. B. Schwarzweiß, Sepiatönung oder Negativ.
Anti-Banding	5	Reduziert den Effekt von Streifen in Farbverläufen aufgrund der JPEG-Komprimierung.
Picture Format	1	Dateiformat für das Bild angeben
Picture Size	1	Geben Sie die Pixelabmessungen des gespeicherten Bildes an.

Hinweis: Diese Funktionen werden aus folgendem Grund nicht auf allen Geräten unterstützt: Hardware-Unterschiede und Softwareimplementierung. Informationen zum Prüfen der Verfügbarkeit Funktionen auf dem Gerät, auf dem Ihre App läuft, erhalten Sie unter Überprüfen Verfügbarkeit von Funktionen.

Verfügbarkeit von Funktionen wird geprüft

Bei der Nutzung der Kamerafunktionen von Android-Geräten sollten Sie als Erstes wissen, Nicht alle Kamerafunktionen werden auf allen Geräten unterstützt. Außerdem können Geräte, die eine bestimmte kann diese auf verschiedenen Ebenen oder mit anderen Optionen unterstützen. Daher ist ein Teil Ihres Der Entscheidungsprozess bei der Entwicklung einer Kamera-App besteht darin, zu entscheiden, welche Kamerafunktionen und auf welchem Niveau. Nachdem Sie diese Entscheidung getroffen haben, sollten Sie Code in Ihr Kamera-App, die prüft, ob die Gerätehardware diese Funktionen unterstützt, und schlägt fehl wenn eine Funktion nicht verfügbar ist.

Wenn Sie prüfen möchten, ob Kamerafunktionen verfügbar sind, rufen Sie eine Instanz der Kameraparameter ab. und die relevanten Methoden überprüfen. Im folgenden Codebeispiel wird gezeigt, wie Sie ein Camera.Parameters Objekt und prüfen Sie, ob die Kamera den Autofokus unterstützt Funktion:

Kotlin

val params: Camera.Parameters? = camera?.parameters
val focusModes: List<String>? = params?.supportedFocusModes
if (focusModes?.contains(Camera.Parameters.FOCUS_MODE_AUTO) == true) {
    // Autofocus mode is supported
}

Java

// get Camera parameters
Camera.Parameters params = camera.getParameters();

List<String> focusModes = params.getSupportedFocusModes();
if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
  // Autofocus mode is supported
}

Für die meisten Kamerafunktionen können Sie die oben gezeigte Technik verwenden. Die Das Camera.Parameters-Objekt bietet eine getSupported...()-, is...Supported()- oder getMax...()-Methode, um zu bestimmen, ob und in welchem Umfang ein Element unterstützt.

Falls bestimmte Kamerafunktionen erforderlich sind, können Sie durch Ergänzungen zu deinem App-Manifest fordern. Wenn Sie die Verwendung bestimmter wie Blitz und Autofokus zu entfernen, hindert Google Play Ihre App daran, auf Geräten installiert werden, die diese Funktionen nicht unterstützen. Eine Liste der Kamerafunktionen, die in deinem App-Manifest deklariert werden können, siehe Manifest Funktionen Referenz.

Kamerafunktionen verwenden

Die meisten Kamerafunktionen werden über ein Camera.Parameters-Objekt aktiviert und gesteuert. Sie rufen dieses Objekt ab, indem Sie zuerst eine Instanz von dem Camera-Objekt durch Aufrufen der getParameters()-Methode und Ändern des zurückgegebenen Parameters Objektiv zu entfernen und es dann wieder in das Kameraobjekt zu setzen, wie im folgenden Beispiel gezeigt. Code:

Kotlin

val params: Camera.Parameters? = camera?.parameters
params?.focusMode = Camera.Parameters.FOCUS_MODE_AUTO
camera?.parameters = params

Java

// get Camera parameters
Camera.Parameters params = camera.getParameters();
// set the focus mode
params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
// set Camera parameters
camera.setParameters(params);

Diese Technik funktioniert bei fast allen Kamerafunktionen und die meisten Parameter können jederzeit geändert werden. nachdem Sie eine Instanz des Camera-Objekts abgerufen haben. Änderungen an Parameter sind für den Nutzer in der Regel sofort in der Kameravorschau der Anwendung sichtbar. Auf Softwareseite kann es mehrere Frames dauern, bis Parameteränderungen wirksam werden, Kamerahardware verarbeitet die neuen Anweisungen und sendet dann aktualisierte Bilddaten.

Wichtig:Einige Kamerafunktionen können nicht beliebig geändert werden. In Wenn Sie die Größe oder Ausrichtung der Kameravorschau ändern, müssen Sie zuerst die die Vorschaugröße ändern und die Vorschau erneut starten. Ab Android 4.0 (API) Ebene 14) kann die Vorschauausrichtung geändert werden, ohne dass die Vorschau neu gestartet werden muss.

Für die Implementierung anderer Kamerafunktionen ist mehr Code erforderlich, darunter:

• Mess- und Fokusbereiche
• Gesichtserkennung
• Zeitraffervideo

In den folgenden Abschnitten finden Sie einen kurzen Überblick über die Implementierung dieser Funktionen.

Mess- und Fokusbereiche

Bei einigen fotografischen Szenarien liefert die automatische Fokussierung und die Belichtungsmessung unter Umständen keine die gewünschten Ergebnisse zu erzielen. Ab Android 4.0 (API-Level 14) bietet Ihre Kamera-App zusätzliche Steuerelemente, mit denen Ihre App oder Nutzer Bereiche in einem Bild angeben können, anhand derer Fokus- oder Helligkeitseinstellungen anpassen und diese Werte zur Verwendung bei der Aufnahme an die Kamera-Hardware übergeben. Bilder oder Videos.

Mess- und Fokusbereiche funktionieren ähnlich wie andere Kamerafunktionen, da Sie diese mithilfe von Methoden im Camera.Parameters-Objekt. Der folgende Code zeigt die Einstellung von zwei Lichtmessbereichen für eine Instanz von Camera:

Kotlin

// Create an instance of Camera
camera = getCameraInstance()

// set Camera parameters
val params: Camera.Parameters? = camera?.parameters

params?.apply {
    if (maxNumMeteringAreas > 0) { // check that metering areas are supported
        meteringAreas = ArrayList<Camera.Area>().apply {
            val areaRect1 = Rect(-100, -100, 100, 100) // specify an area in center of image
            add(Camera.Area(areaRect1, 600)) // set weight to 60%
            val areaRect2 = Rect(800, -1000, 1000, -800) // specify an area in upper right of image
            add(Camera.Area(areaRect2, 400)) // set weight to 40%
        }
    }
    camera?.parameters = this
}

Java

// Create an instance of Camera
camera = getCameraInstance();

// set Camera parameters
Camera.Parameters params = camera.getParameters();

if (params.getMaxNumMeteringAreas() > 0){ // check that metering areas are supported
    List<Camera.Area> meteringAreas = new ArrayList<Camera.Area>();

    Rect areaRect1 = new Rect(-100, -100, 100, 100);    // specify an area in center of image
    meteringAreas.add(new Camera.Area(areaRect1, 600)); // set weight to 60%
    Rect areaRect2 = new Rect(800, -1000, 1000, -800);  // specify an area in upper right of image
    meteringAreas.add(new Camera.Area(areaRect2, 400)); // set weight to 40%
    params.setMeteringAreas(meteringAreas);
}

camera.setParameters(params);

Das Camera.Area-Objekt enthält zwei Datenparameter: ein Rect-Objekt zum Angeben eines Bereichs innerhalb des Sichtfelds der Kamera sowie eine Gewichtung. -Wert, der der Kamera mitteilt, welchen Stellenwert dieser Bereich bei der Belichtungsmessung erhalten soll oder Fokusberechnungen.

Das Feld Rect in einem Camera.Area-Objekt beschreibt eine rechteckige Form, die auf einem Raster von 2000 x 2000 Einheiten abgebildet ist. Die Koordinaten -1000, -1000 die obere, linke Ecke des Kamerabildes und die Koordinaten 1000 und 1000 die rechte untere Ecke des Kamerabilds, wie in der folgenden Abbildung dargestellt.

Abbildung 1: Die roten Linien stellen das Koordinatensystem zur Angabe eines Camera.Area in einer Kameravorschau. Das blaue Feld zeigt den Standort und Form eines Kamerabereichs mit den Rect-Werten 333.333.667.667.

Die Grenzen dieses Koordinatensystems entsprechen immer dem äußeren Rand des Bildes, der sichtbar ist in Kameravorschau ansehen und nicht mit der Zoomstufe verkleinern oder erweitern. Die Drehung des Bildes Vorschau mit Camera.setDisplayOrientation() anzeigen das Koordinatensystem nicht neu kartiert.

Gesichtserkennung

Bei Bildern, auf denen Personen zu sehen sind, sind Gesichter in der Regel der wichtigste Teil des Bildes. zur Bestimmung des Fokus und des Weißabgleichs bei der Aufnahme verwendet werden. Mit Android 4.0 (API-Level 14) bietet APIs zur Identifizierung von Gesichtern und zur Berechnung von Bildeinstellungen mithilfe von Gesichtserkennungstechnologie.

Hinweis:Solange die Gesichtserkennung ausgeführt wird, setWhiteBalance(String), setFocusAreas(List<Camera.Area>) und setMeteringAreas(List<Camera.Area>) haben keine Auswirkungen.

Für die Verwendung der Gesichtserkennung in Ihrer Kamera-App sind einige allgemeine Schritte erforderlich:

• Prüfen, ob die Gesichtserkennung auf dem Gerät unterstützt wird
• Gesichtserkennungs-Listener erstellen
• Dem Kameraobjekt den Gesichtserkennungs-Listener hinzufügen
• Gesichtserkennung nach der Vorschau (und nach jedem Neustart der Vorschau) starten

Die Gesichtserkennung wird nicht auf allen Geräten unterstützt. Sie können prüfen, ob diese Funktion durch Aufrufen von getMaxNumDetectedFaces() unterstützt. Eine Ein Beispiel für diese Prüfung finden Sie in der startFaceDetection()-Beispielmethode unten.

Damit Sie bei Gesichtserkennung benachrichtigt werden und entsprechend reagieren können, muss Ihre Kamera-App folgende Einstellungen vornehmen: Listener für Gesichtserkennungsereignisse Dazu müssen Sie eine Listener-Klasse erstellen, die Implementiert die Camera.FaceDetectionListener-Schnittstelle, wie in der Beispielcode unten.

Kotlin

internal class MyFaceDetectionListener : Camera.FaceDetectionListener {

    override fun onFaceDetection(faces: Array<Camera.Face>, camera: Camera) {
        if (faces.isNotEmpty()) {
            Log.d("FaceDetection", ("face detected: ${faces.size}" +
                    " Face 1 Location X: ${faces[0].rect.centerX()}" +
                    "Y: ${faces[0].rect.centerY()}"))
        }
    }
}

Java

class MyFaceDetectionListener implements Camera.FaceDetectionListener {

    @Override
    public void onFaceDetection(Face[] faces, Camera camera) {
        if (faces.length > 0){
            Log.d("FaceDetection", "face detected: "+ faces.length +
                    " Face 1 Location X: " + faces[0].rect.centerX() +
                    "Y: " + faces[0].rect.centerY() );
        }
    }
}

Nachdem Sie diese Klasse erstellt haben, legen Sie sie im Camera-Objekt, wie im folgenden Beispielcode gezeigt:

Kotlin

camera?.setFaceDetectionListener(MyFaceDetectionListener())

Java

camera.setFaceDetectionListener(new MyFaceDetectionListener());

Ihre App muss die Gesichtserkennung jedes Mal starten, wenn Sie die Kameravorschau. Erstellen Sie eine Methode zum Starten der Gesichtserkennung, damit Sie sie nach Bedarf aufrufen können. im Beispielcode unten.

Kotlin

fun startFaceDetection() {
    // Try starting Face Detection
    val params = mCamera?.parameters
    // start face detection only *after* preview has started

    params?.apply {
        if (maxNumDetectedFaces > 0) {
            // camera supports face detection, so can start it:
            mCamera?.startFaceDetection()
        }
    }
}

Java

public void startFaceDetection(){
    // Try starting Face Detection
    Camera.Parameters params = mCamera.getParameters();

    // start face detection only *after* preview has started
    if (params.getMaxNumDetectedFaces() > 0){
        // camera supports face detection, so can start it:
        mCamera.startFaceDetection();
    }
}

Die Gesichtserkennung muss jedes Mal gestartet werden, wenn Sie die Kameravorschau starten oder neu starten. Wenn Sie die unter Vorschauklasse erstellen beschriebene Vorschauklasse verwenden, fügen Sie startFaceDetection() sowohl für die surfaceCreated() und surfaceChanged() in Ihrer Vorschauklasse, wie im Beispielcode unten dargestellt.

Kotlin

override fun surfaceCreated(holder: SurfaceHolder) {
    try {
        mCamera.setPreviewDisplay(holder)
        mCamera.startPreview()

        startFaceDetection() // start face detection feature
    } catch (e: IOException) {
        Log.d(TAG, "Error setting camera preview: ${e.message}")
    }
}

override fun surfaceChanged(holder: SurfaceHolder, format: Int, w: Int, h: Int) {
    if (holder.surface == null) {
        // preview surface does not exist
        Log.d(TAG, "holder.getSurface() == null")
        return
    }
    try {
        mCamera.stopPreview()
    } catch (e: Exception) {
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error stopping camera preview: ${e.message}")
    }
    try {
        mCamera.setPreviewDisplay(holder)
        mCamera.startPreview()

        startFaceDetection() // re-start face detection feature
    } catch (e: Exception) {
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error starting camera preview: ${e.message}")
    }
}

Java

public void surfaceCreated(SurfaceHolder holder) {
    try {
        mCamera.setPreviewDisplay(holder);
        mCamera.startPreview();

        startFaceDetection(); // start face detection feature

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

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

    if (holder.getSurface() == null){
        // preview surface does not exist
        Log.d(TAG, "holder.getSurface() == null");
        return;
    }

    try {
        mCamera.stopPreview();

    } catch (Exception e){
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error stopping camera preview: " + e.getMessage());
    }

    try {
        mCamera.setPreviewDisplay(holder);
        mCamera.startPreview();

        startFaceDetection(); // re-start face detection feature

    } catch (Exception e){
        // ignore: tried to stop a non-existent preview
        Log.d(TAG, "Error starting camera preview: " + e.getMessage());
    }
}

Hinweis: Denken Sie daran, diese Methode nach dem Aufruf von startPreview() Nicht versuchen, die Gesichtserkennung zu starten der Hauptaktivität der Kamera-App mit der Methode onCreate() da die Vorschau zu diesem Zeitpunkt in der Ausführung Ihrer Anwendung nicht verfügbar ist.

Zeitraffervideo

Mit Zeitraffervideos können Nutzer Videoclips erstellen, in denen Bilder von wenigen Sekunden oder Minuten auseinanderliegen. Diese Funktion verwendet MediaRecorder, um die Bilder zeitweise aufzuzeichnen. Videosequenzen.

Wenn Sie mit MediaRecorder ein Zeitraffervideo aufnehmen möchten, müssen Sie die Rekorder-Objekt, als ob Sie ein normales Video aufnehmen würden, und setzen Sie die Bilder pro Sekunde auf einen und eine der Zeitraffer-Qualitätseinstellungen verwenden, wie im Codebeispiel unten gezeigt.

Kotlin

mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH))
mediaRecorder.setCaptureRate(0.1) // capture a frame every 10 seconds

Java

// Step 3: Set a CamcorderProfile (requires API Level 8 or higher)
mediaRecorder.setProfile(CamcorderProfile.get(CamcorderProfile.QUALITY_TIME_LAPSE_HIGH));
...
// Step 5.5: Set the video capture rate to a low number
mediaRecorder.setCaptureRate(0.1); // capture a frame every 10 seconds

Diese Einstellungen müssen im Rahmen einer umfangreicheren Konfiguration für MediaRecorder vorgenommen werden. Ein vollständiges Codebeispiel für die Konfiguration finden Sie unter MediaRecorder konfigurieren. Sobald die Konfiguration abgeschlossen ist, starten Sie die Videoaufnahme so, als würden Sie einen normalen Videoclip aufnehmen. Weitere Informationen zum Konfigurieren und Ausführen von MediaRecorder finden Sie unter Videos aufnehmen.

Die Funktion Camera2Video und HdrViewfinder in den Beispielen mehr über die Verwendung der auf dieser Seite behandelten APIs.

Kamerafelder, die eine Berechtigung erfordern

Apps mit Android 10 (API-Level 29) oder höher müssen die CAMERA-Berechtigung, um auf die Werte der folgenden Felder zugreifen, getCameraCharacteristics() gibt Folgendes zurück:

• LENS_POSE_ROTATION
• LENS_POSE_TRANSLATION
• LENS_INTRINSIC_CALIBRATION
• LENS_RADIAL_DISTORTION
• LENS_POSE_REFERENCE
• LENS_DISTORTION
• LENS_INFO_HYPERFOCAL_DISTANCE
• LENS_INFO_MINIMUM_FOCUS_DISTANCE
• SENSOR_REFERENCE_ILLUMINANT1
• SENSOR_REFERENCE_ILLUMINANT2
• SENSOR_CALIBRATION_TRANSFORM1
• SENSOR_CALIBRATION_TRANSFORM2
• SENSOR_COLOR_TRANSFORM1
• SENSOR_COLOR_TRANSFORM2
• SENSOR_FORWARD_MATRIX1
• SENSOR_FORWARD_MATRIX2

Zusätzlicher Beispielcode

Beispiel-Apps können Sie in der Beispiel für Kamera2Basic und Offizielle CameraX-Beispiel-App.