Das Android-Framework unterstützt verschiedene Kameras und Kamerafunktionen auf Geräten, sodass Sie Bilder und Videos in Ihren Anwendungen aufnehmen können. In diesem Dokument wird ein schneller, einfacher Ansatz für die Bild- und Videoaufnahme sowie ein erweiterter Ansatz zum Erstellen benutzerdefinierter Kameraumgebungen für Nutzer beschrieben.
Hinweis:
Auf dieser Seite wird die Klasse Camera
beschrieben, die eingestellt wurde. Wir empfehlen die Verwendung der CameraX-Jetpack-Bibliothek oder, für bestimmte Anwendungsfälle, der Klasse camera2
. Sowohl CameraX als auch Camera2 funktionieren unter Android 5.0 (API-Level 21) und höher.
Weitere Informationen finden Sie in den folgenden Ressourcen:
Wissenswertes
Bevor Sie Ihre App für die Verwendung von Kameras auf Android-Geräten aktivieren, sollten Sie sich einige Fragen dazu stellen, wie Ihre App diese Hardwarefunktion verwenden soll.
- Kameraanforderung – Ist die Verwendung einer Kamera für Ihre Anwendung so wichtig, dass sie nicht auf einem Gerät ohne Kamera installiert werden soll? Falls ja, solltest du die Kameraanforderung in deinem Manifest deklarieren.
- Quick Picture oder benutzerdefinierte Kamera – Wie verwendet Ihre Anwendung die Kamera? Möchten Sie nur schnell ein Foto oder einen Videoclip aufnehmen oder wird Ihre App eine neue Möglichkeit für den Einsatz von Kameras bieten? Wenn Sie schnell einen Schnappschuss oder Clip erstellen möchten, sollten Sie vorhandene Kamera-Apps verwenden. Informationen zur Entwicklung einer benutzerdefinierten Kamerafunktion finden Sie im Abschnitt Kamera-App erstellen.
- Anforderung an Dienste im Vordergrund – Wann interagiert deine App mit der Kamera? Unter Android 9 (API-Level 28) und höher können im Hintergrund ausgeführte Apps nicht auf die Kamera zugreifen. Daher solltest du die Kamera entweder im Vordergrund oder als Teil eines Diensts im Vordergrund verwenden.
- Speicher: Sind die von Ihrer App generierten Bilder oder Videos nur für Ihre App sichtbar oder werden sie geteilt, damit sie von anderen Anwendungen wie Galerie oder anderen Medien und sozialen Apps verwendet werden können? Möchten Sie, dass die Bilder und Videos auch dann verfügbar sind, wenn Ihre App deinstalliert ist? Informationen zur Implementierung dieser Optionen findest du im Abschnitt Mediendateien speichern.
Grundlagen
Das Android-Framework unterstützt die Aufnahme von Bildern und Videos über die android.hardware.camera2
API oder die Kamera-Intent
. Dies sind die relevanten
Klassen:
android.hardware.camera2
- Dieses Paket ist die primäre API zum Steuern der Gerätekameras. Damit können Sie Fotos oder Videos aufnehmen, während Sie eine Kamera-App entwickeln.
Camera
- Diese Klasse ist die ältere eingestellte API zur Steuerung von Gerätekameras.
SurfaceView
- Dieser Kurs wird verwendet, um dem Nutzer eine Live-Kameravorschau zu präsentieren.
MediaRecorder
- In diesem Kurs werden Videos mit der Kamera aufgezeichnet.
Intent
- Mit dem Intent-Aktionstyp
MediaStore.ACTION_IMAGE_CAPTURE
oderMediaStore.ACTION_VIDEO_CAPTURE
können Bilder oder Videos erfasst werden, ohne dasCamera
-Objekt direkt zu verwenden.
Manifestdeklarationen
Bevor Sie mit der Entwicklung Ihrer App mit der Camera API beginnen, sollte Ihr Manifest die entsprechenden Deklarationen enthalten, die die Verwendung von Kamerahardware und anderen zugehörigen Funktionen zulassen.
- Kameraberechtigung: Ihre App muss die Berechtigung anfordern, eine Gerätekamera zu verwenden.
<uses-permission android:name="android.permission.CAMERA" />
Hinweis:Wenn Sie die Kamera verwenden, indem Sie eine vorhandene Kamera-App aufrufen, muss diese Berechtigung nicht angefordert werden.
- Kamerafunktionen: In Ihrer App muss auch die Verwendung von Kamerafunktionen deklariert werden, z. B.:
<uses-feature android:name="android.hardware.camera" />
Eine Liste der Kamerafunktionen finden Sie in der Manifest-Funktionsreferenz.
Wenn Sie dem Manifest Kamerafunktionen hinzufügen, verhindert Google Play, dass Ihre App auf Geräten installiert wird, die keine Kamera enthalten oder die von Ihnen angegebenen Kamerafunktionen nicht unterstützen. Weitere Informationen zur Verwendung der funktionsbasierten Filterung bei Google Play finden Sie unter Google Play und funktionsbasiertes Filtern.
Wenn Ihre App eine Kamera oder Kamerafunktion für den ordnungsgemäßen Betrieb verwenden kann, dies aber nicht erfordert, sollten Sie dies im Manifest angeben, indem Sie das Attribut
android:required
einbeziehen und auffalse
setzen:<uses-feature android:name="android.hardware.camera" android:required="false" />
- Speicherberechtigung: Deine App kann Bilder und Videos auf dem externen Speicher (SD-Karte) des Geräts speichern, wenn sie auf Android 10 (API-Level 29) oder niedriger ausgerichtet ist und im Manifest Folgendes angibt.
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
- Berechtigung für Audioaufnahme: Für die Audioaufnahme mit Videoaufnahme muss Ihre Anwendung die Berechtigung zur Audioaufnahme anfordern.
<uses-permission android:name="android.permission.RECORD_AUDIO" />
-
Standortberechtigung – Wenn Ihre Anwendung Bilder mit GPS-Standortinformationen kennzeichnet, müssen Sie die Berechtigung
ACCESS_FINE_LOCATION
anfordern. Wenn deine App auf Android 5.0 (API-Level 21) oder höher ausgerichtet ist, musst du außerdem deklarieren, 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, die Aufnahme von Bildern oder Videos in Ihrer App ohne viel zusätzlichen Code zu ermöglichen, besteht darin, mit einem Intent
eine vorhandene Android-Kamera-App aufzurufen.
Einzelheiten hierzu findest du in den Lektionen Einfaches Aufnehmen von Fotos und Videos einfach aufzeichnen.
Kamera-App erstellen
Einige Entwickler benötigen möglicherweise eine Kamerabenutzeroberfläche, die an das Erscheinungsbild ihrer Anwendung angepasst ist oder spezielle Funktionen bietet. Einen eigenen Code für die Aufnahme von Bildern zu schreiben, kann den Nutzern ein besseres Erlebnis bieten.
Hinweis: Die folgende Anleitung bezieht sich auf die ältere, verworfene Camera
API. Für neue oder erweiterte Kameraanwendungen wird die neuere android.hardware.camera2
API empfohlen.
So erstellen Sie eine benutzerdefinierte Kameraoberfläche für Ihre Anwendung:
- Kamera erkennen und aufrufen: Erstellen Sie Code, um das Vorhandensein von Kameras zu prüfen und den Zugriff anzufordern.
- Vorschauklasse erstellen: Erstellen Sie eine Kameravorschauklasse, die
SurfaceView
erweitert und dieSurfaceHolder
-Schnittstelle implementiert. Diese Klasse zeigt eine Vorschau der Live-Bilder der Kamera an. - Vorschaulayout erstellen: Nachdem Sie die Kameravorschauklasse erstellt haben, erstellen Sie ein Ansichtslayout, das die Vorschau und die gewünschten Steuerelemente der Benutzeroberfläche enthält.
- Listener für Capture einrichten: Verbinden Sie Listener für die Steuerelemente Ihrer Benutzeroberfläche, um bei Nutzeraktionen wie dem Drücken einer Schaltfläche die Aufnahme von Bildern oder Videos zu starten.
- Dateien erfassen und speichern: Richten Sie den Code zum Erfassen von Bildern oder Videos und Speichern der Ausgabe ein.
- Kamera freigeben: Nach der Verwendung der Kamera muss sie von der Anwendung zur Verwendung durch andere Anwendungen ordnungsgemäß freigegeben werden.
Die Kamerahardware ist eine gemeinsam genutzte Ressource, die sorgfältig verwaltet werden muss, damit Ihre Anwendung nicht mit anderen Anwendungen kollidiert, die sie ebenfalls verwenden möchten. In den folgenden Abschnitten wird erläutert, wie Sie Kamerahardware erkennen, Zugriff auf eine Kamera anfordern, Bilder oder Videos aufnehmen und die Kamera freigeben, wenn Ihre Anwendung sie nicht mehr verwendet.
Achtung:Denken Sie daran, das Objekt Camera
freizugeben, indem Sie Camera.release()
aufrufen, wenn Ihre Anwendung es nicht mehr verwendet. Wenn Ihre Anwendung die Kamera nicht ordnungsgemäß freigibt, schlagen alle nachfolgenden Zugriffsversuche auf die Kamera fehl, auch die Ihrer eigenen Anwendung, und können dazu führen, dass Ihre oder andere Anwendungen heruntergefahren werden.
Kamerahardware wird erkannt
Wenn für Ihre App keine Kamera mit Manifestdeklaration erforderlich ist, sollten Sie prüfen, ob eine Kamera zur Laufzeit verfügbar ist. Verwenden Sie dazu 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 Rückkamera für Fotografie und eine Frontkamera für Videoanrufe. Mit Android 2.3 (API-Level 9) und höher können Sie die Anzahl der auf einem Gerät verfügbaren Kameras mit der Methode Camera.getNumberOfCameras()
prüfen.
Zugriff auf Kameras
Wenn Sie festgestellt haben, dass das Gerät, auf dem Ihre Anwendung ausgeführt wird, eine Kamera hat, müssen Sie den Zugriff durch Abrufen einer Instanz von Camera
anfordern (es sei denn, Sie verwenden einen Intent für den Zugriff auf die Kamera).
Verwenden Sie die Methode Camera.open()
, um auf die primäre Kamera zuzugreifen. Achten Sie dabei 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:Wenn Sie Camera.open()
verwenden, sollten Sie immer auf Ausnahmen prüfen. Wenn Sie nicht auf Ausnahmen prüfen, wenn die Kamera verwendet wird oder nicht vorhanden ist, wird Ihre Anwendung vom System heruntergefahren.
Auf Geräten mit Android 2.3 (API-Level 9) oder höher kannst du mit Camera.open(int)
auf bestimmte Kameras zugreifen. Mit dem Beispielcode oben wird auf die erste rückseitige Kamera eines Geräts mit mehr als einer Kamera zugegriffen.
Kamerafunktionen werden geprüft
Sobald Sie Zugriff auf eine Kamera haben, können Sie mithilfe der Methode Camera.getParameters()
weitere Informationen zu ihren Funktionen abrufen. Prüfen Sie außerdem das zurückgegebene Camera.Parameters
-Objekt auf unterstützte Funktionen. Wenn du API-Level 9 oder höher verwendest, kannst du mit Camera.getCameraInfo()
feststellen, ob sich eine Kamera auf der Vorder- oder Rückseite des Geräts befindet und wie die Bilder ausgerichtet sind.
Vorschauklasse erstellen
Damit Nutzer effektiv Fotos oder Videos aufnehmen können, müssen sie sehen können, was die Gerätekamera sieht. Eine Kameravorschauklasse ist eine SurfaceView
, die die Live-Bilddaten einer Kamera anzeigen kann, damit Nutzer ein Bild oder Video aufnehmen und aufnehmen können.
Der folgende Beispielcode zeigt, wie Sie eine einfache Kameravorschauklasse erstellen, die in ein View
-Layout aufgenommen werden kann. Mit dieser Klasse wird SurfaceHolder.Callback
implementiert, um die Callback-Ereignisse zum Erstellen und Löschen der Ansicht zu erfassen. Diese sind für das Zuweisen der Kameravorschaueingabe erforderlich.
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 eine bestimmte Größe für die Kameravorschau festlegen möchten, legen Sie dies in der Methode surfaceChanged()
fest, wie in den Kommentaren oben beschrieben. Beim Festlegen der Vorschaugröße müssen Sie Werte aus getSupportedPreviewSizes()
verwenden.
Legen Sie in der Methode setPreviewSize()
keine beliebigen Werte fest.
Hinweis:Mit der Einführung der
Mehrfensterfunktion in Android 7.0 (API-Ebene 24) und höher können Sie nicht mehr davon ausgehen, dass das Seitenverhältnis der Vorschau mit Ihrer Aktivität übereinstimmt, auch nachdem Sie setDisplayOrientation()
aufgerufen haben.
Je nach Fenstergröße und -verhältnis müssen Sie möglicherweise eine Weitwinkelvorschau der Kamera in ein Layout im Hochformat anpassen oder umgekehrt, indem Sie ein Letterbox-Layout verwenden.
Vorschau in ein Layout einfügen
Eine Kameravorschauklasse wie das im vorherigen Abschnitt gezeigte Beispiel muss zusammen mit anderen Steuerelementen der Benutzeroberfläche zum Aufnehmen eines Fotos oder Videos im Layout einer Aktivität platziert werden. In diesem Abschnitt 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 Kameravorschau verwendet werden kann. In diesem Beispiel ist das FrameLayout
-Element als Container für die Kameravorschauklasse vorgesehen. Dieser Layouttyp wird verwendet, damit zusätzliche Bildinformationen oder Steuerelemente über die Live-Kameravorschaubilder gelegt werden können.
<?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. In diesem Beispiellayout wird ein horizontales Layout (Querformat) angegeben und der folgende Code legt die Ausrichtung der Anwendung im Querformat fest. Um das Rendern einer Kameravorschau zu vereinfachen, sollten Sie die Ausrichtung der Vorschauaktivitäten Ihrer Anwendung ins Querformat ändern. Fügen Sie dazu dem Manifest Folgendes hinzu.
<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 Methode setDisplayOrientation()
die Rotation des Vorschaubilds festlegen. Wenn Sie die Vorschauausrichtung ändern möchten, wenn der Nutzer das Smartphone neu richtet, beenden Sie die Vorschau in der surfaceChanged()
-Methode der Vorschauklasse, indem Sie Camera.stopPreview()
die Ausrichtung ändern und sie dann mit Camera.startPreview()
noch einmal starten.
Fügen Sie in der Aktivität für die Kameraansicht die Vorschauklasse dem FrameLayout
-Element hinzu, das im Beispiel oben gezeigt wird. Außerdem muss durch Ihre Kameraaktivität sichergestellt sein, dass die Kamera loslässt, wenn sie pausiert oder heruntergefahren wird. Das folgende Beispiel zeigt, wie Sie eine Kameraaktivität so ändern, dass die Vorschauklasse angehängt wird, die unter Vorschauklasse erstellen beschrieben wird.
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
Nachdem Sie eine Vorschauklasse und ein Ansichtslayout für die Darstellung erstellt haben, können Sie mit der Aufnahme von Bildern mit Ihrer Anwendung beginnen. In Ihrem Anwendungscode müssen Sie Listener einrichten, damit die Steuerelemente der Benutzeroberfläche mit der Aufnahme eines Bildes auf eine Nutzeraktion reagieren können.
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()); } } };
Lösen Sie die Aufnahme eines Bildes aus, indem Sie die Methode Camera.takePicture()
aufrufen. Der folgende Beispielcode zeigt, wie diese Methode über die Schaltfläche View.OnClickListener
aufgerufen wird.
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:Im folgenden Beispiel bezieht sich das Mitglied mPicture
auf den Beispielcode oben.
Achtung:Denken Sie daran, das Objekt Camera
freizugeben, indem Sie Camera.release()
aufrufen, wenn Ihre Anwendung es nicht mehr verwendet. Informationen zum Lösen der Kamera finden Sie unter Kamera freigeben.
Aufnehmen von Videos
Die Videoaufnahme mit dem Android-Framework erfordert eine sorgfältige Verwaltung des Camera
-Objekts und Koordination mit der MediaRecorder
-Klasse. Bei der Videoaufzeichnung mit Camera
musst du neben den Camera.open()
- und Camera.release()
-Aufrufen die Aufrufe Camera.lock()
und Camera.unlock()
verwalten, um MediaRecorder
Zugriff auf die Kamerahardware zu gewähren.
Hinweis: Ab Android 4.0 (API-Level 14) werden die Aufrufe Camera.lock()
und Camera.unlock()
automatisch für dich verwaltet.
Im Gegensatz zur Aufnahme von Bildern mit der Kamera eines Geräts erfordert das Aufnehmen von Videos eine ganz bestimmte Aufrufreihenfolge. Sie müssen eine bestimmte Reihenfolge für die Ausführung einhalten, um mit Ihrer Anwendung Videos vorzubereiten und wie unten beschrieben aufzunehmen.
- Kamera öffnen: Verwenden Sie
Camera.open()
, um eine Instanz des Kameraobjekts abzurufen. - Vorschau verbinden: Sie können eine Live-Bildvorschau der Kamera erstellen, indem Sie ein
SurfaceView
überCamera.setPreviewDisplay()
mit der Kamera verbinden. - Vorschau starten: Rufen Sie
Camera.startPreview()
auf, um sich die Live-Kamerabilder anzeigen zu lassen. - Videoaufnahme starten: Für die Videoaufnahme müssen die folgenden Schritte in der richtigen Reihenfolge ausgeführt werden:
- Kamera entsperren – Entsperre die Kamera zur Verwendung durch
MediaRecorder
, indem duCamera.unlock()
aufrufst. - MediaRecorder konfigurieren: Rufe die folgenden
MediaRecorder
-Methoden in dieser Reihenfolge auf. Weitere Informationen finden Sie in der Referenzdokumentation zuMediaRecorder
.setCamera()
: Lege die Kamera fest, die für die Videoaufnahme verwendet werden soll. Verwende die aktuelle Instanz vonCamera
deiner Anwendung.setAudioSource()
: Legen Sie die Audioquelle fest. Verwenden Sie dazuMediaRecorder.AudioSource.CAMCORDER
.setVideoSource()
: Legen Sie die Videoquelle fest. Verwenden SieMediaRecorder.VideoSource.CAMERA
.- Lege das Ausgabeformat und die Codierung des Videos fest. Verwenden Sie für Android 2.2 (API-Level 8) und höher die Methode
MediaRecorder.setProfile
und rufen Sie eine Profilinstanz mitCamcorderProfile.get()
ab. Bei Android-Versionen vor 2.2 müssen das Videoausgabeformat und die Codierungsparameter festgelegt werden:setOutputFormat()
: Legen Sie das Ausgabeformat fest und geben Sie die Standardeinstellung an oderMediaRecorder.OutputFormat.MPEG_4
.setAudioEncoder()
: Legen Sie den Toncodierungstyp fest, geben Sie die Standardeinstellung an oderMediaRecorder.AudioEncoder.AMR_NB
.setVideoEncoder()
: Legen Sie den Videocodierungstyp fest, geben Sie die Standardeinstellung an oderMediaRecorder.VideoEncoder.MPEG_4_SP
.
setOutputFile()
: Legen Sie die Ausgabedatei fest. Verwenden Sie dazugetOutputMediaFile(MEDIA_TYPE_VIDEO).toString()
der Beispielmethode im Abschnitt Mediendateien speichern.setPreviewDisplay()
: Geben Sie das Vorschau-LayoutelementSurfaceView
für Ihre App an. 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 in Ihrer Anwendung Fehler auf und die Aufzeichnung schlägt fehl. - Prepare MediaRecorder: Bereiten Sie den
MediaRecorder
mit den angegebenen Konfigurationseinstellungen vor. Rufen Sie dazuMediaRecorder.prepare()
auf. - MediaRecorder starten: Rufe
MediaRecorder.start()
auf, um ein Video aufzunehmen.
- Kamera entsperren – Entsperre die Kamera zur Verwendung durch
- Videoaufzeichnung beenden: Rufen Sie der Reihe nach die folgenden Methoden auf, um eine Videoaufzeichnung erfolgreich abzuschließen:
- MediaRecorder beenden: Beende die Videoaufzeichnung durch Aufrufen von
MediaRecorder.stop()
. - MediaRecorder zurücksetzen: Entfernen Sie optional die Konfigurationseinstellungen aus dem Rekorder, indem Sie
MediaRecorder.reset()
aufrufen. - MediaRecorder Release – Lasse
MediaRecorder
durch Aufrufen vonMediaRecorder.release()
los. - Kamera sperren: Rufe
Camera.lock()
auf, damit die Kamera in zukünftigenMediaRecorder
-Sitzungen verwendet werden kann. Ab Android 4.0 (API-Level 14) ist dieser Aufruf nur erforderlich, wenn derMediaRecorder.prepare()
-Aufruf fehlschlägt.
- MediaRecorder beenden: Beende die Videoaufzeichnung durch Aufrufen von
- Vorschau beenden: Wenn deine Aktivität die Verwendung der Kamera beendet hat, kannst du die Vorschau mit
Camera.stopPreview()
beenden. - Kamera freigeben: Lassen Sie die Kamera los, damit andere Anwendungen sie verwenden können. Rufen Sie dazu
Camera.release()
auf.
Hinweis:Sie können MediaRecorder
verwenden, ohne vorher eine Kameravorschau zu erstellen, und die ersten Schritte dieses Vorgangs überspringen. Da Nutzer sich jedoch normalerweise vor dem Start einer Aufzeichnung eine Vorschau ansehen möchten, wird dieser Vorgang hier nicht erläutert.
Tipp:Wenn Ihre Anwendung normalerweise zum Aufzeichnen von Videos verwendet wird, legen Sie setRecordingHint(boolean)
auf true
fest, bevor Sie die Vorschau starten. Mit dieser Einstellung können Sie die Startzeit der Aufzeichnung verkürzen.
MediaRecorder konfigurieren
Wenn Sie die Klasse MediaRecorder
zum Aufzeichnen von Videos verwenden, müssen Sie die Konfigurationsschritte in einer bestimmten Reihenfolge ausführen und dann die Methode MediaRecorder.prepare()
aufrufen, um die Konfiguration zu prüfen und zu implementieren. Der folgende Beispielcode zeigt, wie die MediaRecorder
-Klasse für die Videoaufzeichnung richtig konfiguriert und vorbereitet wird.
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 direkt festlegen, anstatt CamcorderProfile
zu verwenden. Dieser Ansatz wird im folgenden Code veranschaulicht:
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);
Die folgenden Parameter für die Videoaufnahme für MediaRecorder
sind Standardeinstellungen festgelegt. Sie können diese Einstellungen für Ihre App jedoch anpassen:
setVideoEncodingBitRate()
setVideoSize()
setVideoFrameRate()
setAudioEncodingBitRate()
setAudioChannels()
setAudioSamplingRate()
MediaRecorder starten und beenden
Wenn Sie die Videoaufzeichnung mit der Klasse MediaRecorder
starten und beenden, müssen Sie eine bestimmte Reihenfolge einhalten, wie unten aufgeführt.
- Kamera mit
Camera.unlock()
entsperren - Konfigurieren Sie
MediaRecorder
wie im obigen Codebeispiel gezeigt - Aufnahme mit
MediaRecorder.start()
starten - Video aufnehmen
- Aufnahme mit
MediaRecorder.stop()
beenden - Lasse den Medienrekorder mit
MediaRecorder.release()
los - Kamera mit
Camera.lock()
sperren
Der folgende Beispielcode zeigt, wie eine Schaltfläche verbunden wird, um die Videoaufzeichnung mit der Kamera und der Klasse MediaRecorder
richtig zu starten und zu beenden.
Hinweis:Lassen Sie die Kamera nicht los, wenn Sie eine Videoaufnahme abgeschlossen haben. Andernfalls wird die Vorschau angehalten.
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 bezieht sich die Methode prepareVideoRecorder()
auf den Beispielcode unter MediaRecorder konfigurieren. Mit dieser Methode wird die Kamera gesperrt und die MediaRecorder
-Instanz konfiguriert und vorbereitet.
Kamera freigeben
Kameras sind Ressourcen, die von Anwendungen auf einem Gerät gemeinsam genutzt werden. Ihre Anwendung kann die Kamera nach dem Abrufen einer Instanz von Camera
verwenden. Achten Sie besonders darauf, das Kameraobjekt freizugeben, wenn Ihre Anwendung es nicht mehr verwendet, und sobald Ihre Anwendung pausiert wird (Activity.onPause()
). Wird die Kamera durch Ihre Anwendung nicht ordnungsgemäß freigegeben, schlagen alle nachfolgenden Zugriffsversuche auf die Kamera – auch durch Ihre eigene Anwendung – fehl und können dazu führen, dass Ihre Anwendung oder andere Anwendungen heruntergefahren werden.
Um eine Instanz des Camera
-Objekts freizugeben, verwenden Sie die Camera.release()
-Methode, wie im folgenden Beispielcode gezeigt.
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 die Kamera nicht ordnungsgemäß freigibt, schlagen alle nachfolgenden Zugriffsversuche auf die Kamera fehl, auch durch Ihre eigene Anwendung, und können dazu führen, dass Ihre Anwendung oder andere Anwendungen heruntergefahren werden.
Mediendateien werden gespeichert
Von Nutzern erstellte Mediendateien, z. B. Bilder und Videos, sollten im externen Speicherverzeichnis eines Geräts (SD-Karte) gespeichert werden, um Systemspeicherplatz zu sparen und Nutzern den Zugriff auf diese Dateien ohne ihr Gerät zu ermöglichen. Es gibt viele mögliche Verzeichnisspeicherorte zum Speichern von Mediendateien auf einem Gerät, es gibt jedoch nur zwei Standardspeicherorte, die du als Entwickler in Betracht ziehen solltest:
Environment.getExternalStoragePublicDirectory
(Environment.DIRECTORY_PICTURES
): Diese Methode gibt den standardmäßigen, geteilten und empfohlenen Speicherort zum Speichern von Bildern und Videos zurück. Dieses Verzeichnis ist freigegeben (öffentlich), sodass andere Anwendungen an diesem Speicherort gespeicherte Dateien leicht finden, lesen, ändern und löschen können. Wenn Ihre App vom Nutzer deinstalliert wird, werden Mediendateien, die an diesem Speicherort gespeichert sind, nicht entfernt. Damit vorhandene Bilder und Videos von Nutzern nicht beeinträchtigt werden, sollten Sie in diesem Verzeichnis ein Unterverzeichnis für die Mediendateien Ihrer Anwendung erstellen, wie im folgenden Codebeispiel gezeigt. Diese Methode ist in Android 2.2 (API-Level 8) verfügbar. Entsprechende Aufrufe in früheren API-Versionen finden Sie unter Freigegebene Dateien speichern.Context.getExternalFilesDir
(Environment.DIRECTORY_PICTURES
): Diese Methode gibt einen Standardspeicherort für Bilder und Videos zurück, die mit Ihrer App verknüpft sind. Wenn Ihre App deinstalliert wird, werden alle an diesem Speicherort gespeicherten Dateien entfernt. Für Dateien an diesem Speicherort wird keine Sicherheit erzwungen. Andere Anwendungen können sie lesen, ändern oder löschen.
Der folgende Beispielcode zeigt, wie ein File
- oder Uri
-Speicherort für eine Mediendatei erstellt wird, die beim Aufrufen der Kamera eines Geräts mit einer Intent
oder als Teil einer Erstellung einer Kamera-App verwendet werden kann.
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 ab Android 2.2 (API-Level 8) verfügbar. Wenn deine Anzeigen auf Geräte mit älteren Android-Versionen ausgerichtet sind, verwende stattdessen Environment.getExternalStorageDirectory()
. Weitere Informationen finden Sie unter Freigegebene Dateien speichern.
Damit der URI Arbeitsprofile unterstützt,
konvertieren Sie zuerst den Datei-URI in einen Inhalts-URI. Fügen Sie dann den Inhalts-URI in EXTRA_OUTPUT
einer Intent
ein.
Weitere Informationen zum Speichern von Dateien auf einem Android-Gerät finden Sie unter Datenspeicher.
Kamerafunktionen
Android unterstützt eine Vielzahl von Kamerafunktionen, die Sie über Ihre Kamera-App steuern können, darunter Bildformat, Blitzmodus, Fokuseinstellungen und vieles mehr. In diesem Abschnitt werden die gängigen Kamerafunktionen und ihre Verwendung kurz erläutert. Auf die meisten Kamerafunktionen kann mit dem through Camera.Parameters
-Objekt zugegriffen werden und es kann festgelegt werden. Es gibt jedoch einige wichtige Funktionen, für die mehr als einfache Einstellungen in Camera.Parameters
erforderlich sind. Diese Funktionen werden in den folgenden Abschnitten behandelt:
Allgemeine Informationen zur Verwendung von Funktionen, die über Camera.Parameters
gesteuert werden, finden Sie im Abschnitt Kamerafunktionen verwenden. Weitere Informationen zur Verwendung von Funktionen, die über das Kameraparameterobjekt gesteuert werden, finden Sie über die Links in der Liste der Funktionen zur API-Referenzdokumentation.
Funktion | API-Ebene | Beschreibung |
---|---|---|
Gesichtserkennung | 14 | Erkennen Sie menschliche Gesichter in einem Bild und verwenden Sie sie zur Fokussierung, Messung und zum Weißabgleich. |
Messbereiche | 14 | Einen oder mehrere Bereiche in einem Bild zur Berechnung des Weißabgleichs angeben |
Schwerpunkte | 14 | Einen oder mehrere Bereiche in einem Bild zur Fokussierung festlegen |
White Balance Lock |
14 | Automatische Weißabgleichanpassungen stoppen oder starten |
Exposure Lock |
14 | Automatische Belichtungsanpassung starten oder stoppen |
Video Snapshot |
14 | Bild während der Videodrehung aufnehmen (Frame-Erfassung) |
Zeitraffervideo | 11 | Frames mit festgelegten Verzögerungen aufnehmen, um ein Video im Zeitraffer aufzunehmen |
Multiple Cameras |
9 | Unterstützung für mehr als eine Kamera auf einem Gerät, einschließlich Front- und Rückkameras |
Focus Distance |
9 | Gibt die Abstände zwischen der Kamera und Objekten an, 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 einbeziehen oder auslassen |
White Balance |
5 | Stellen Sie den Weißabgleichmodus ein. Dieser wirkt sich auf die Farbwerte im aufgenommenen Bild aus. |
Focus Mode |
5 | Einstellen, 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 Fotosituationen anwenden, z. B. Nacht-, Strand-, Schnee- oder Kerzenlichtszenen |
JPEG Quality |
5 | Legen Sie die Komprimierungsstufe für ein JPEG-Bild fest. Dadurch werden Qualität und Größe der Ausgabedatei erhöht oder verringert. |
Flash Mode |
5 | Blitz ein- oder ausschalten oder automatische Einstellung verwenden |
Color Effects |
5 | Wenden Sie einen Farbeffekt auf das aufgenommene Bild an, z. B. Schwarz-Weiß, Sepiaton oder Negativ. |
Anti-Banding |
5 | Reduziert durch die JPEG-Komprimierung den Effekt von Streifenbildung bei Farbverläufen |
Picture Format |
1 | Dateiformat für das Bild angeben |
Picture Size |
1 | Legen Sie die Pixelabmessungen des gespeicherten Bilds fest. |
Hinweis:Diese Funktionen werden aufgrund von Hardwareunterschieden und Softwareimplementierung nicht auf allen Geräten unterstützt. Informationen zum Prüfen der Verfügbarkeit von Funktionen auf dem Gerät, auf dem Ihre Anwendung ausgeführt wird, finden Sie unter Verfügbarkeit von Funktionen prüfen.
Verfügbarkeit von Funktionen wird geprüft
Wenn Sie Kamerafunktionen auf Android-Geräten verwenden, müssen Sie zuerst wissen, dass nicht alle Kamerafunktionen auf allen Geräten unterstützt werden. Außerdem können Geräte, die eine bestimmte Funktion unterstützen, diese auf einer anderen Stufe oder mit anderen Optionen unterstützen. Daher müssen Sie bei der Entwicklung einer Kameraanwendung entscheiden, welche Kamerafunktionen Sie auf welcher Ebene unterstützen möchten. Nach dieser Entscheidung sollten Sie Code in Ihre Kameraanwendung einbinden, um zu prüfen, ob die Gerätehardware diese Funktionen unterstützt und ordnungsgemäß ausfällt, wenn eine Funktion nicht verfügbar ist.
Sie können die Verfügbarkeit von Kamerafunktionen prüfen, indem Sie eine Instanz des Parameterobjekts einer Kamera abrufen und die relevanten Methoden prüfen. Das folgende Codebeispiel zeigt, wie Sie ein Camera.Parameters
-Objekt abrufen und prüfen, ob die Kamera die Autofokus-Funktion unterstützt:
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 }
Sie können die oben beschriebene Technik für die meisten Kamerafunktionen verwenden. Das Camera.Parameters
-Objekt bietet eine getSupported...()
-, is...Supported()
- oder getMax...()
-Methode, um festzustellen, ob und in welchem Umfang ein Feature unterstützt wird.
Wenn für Ihre App bestimmte Kamerafunktionen erforderlich sind, damit sie ordnungsgemäß funktionieren, können Sie diese über Ergänzungen zu Ihrem App-Manifest anfordern. Wenn du die Verwendung bestimmter Kamerafunktionen wie Blitz und Autofokus angibst, schränkt Google Play die Installation deiner App auf Geräten ein, die diese Funktionen nicht unterstützen. Eine Liste der Kamerafunktionen, die in Ihrem App-Manifest deklariert werden können, finden Sie in der Funktionsreferenz des Manifests.
Kamerafunktionen verwenden
Die meisten Kamerafunktionen werden mit einem Camera.Parameters
-Objekt aktiviert und gesteuert. Um dieses Objekt zu erhalten, rufen Sie zuerst eine Instanz des Camera
-Objekts ab, rufen die Methode getParameters()
auf, ändern das zurückgegebene Parameterobjekt und setzen es dann wieder in das Kameraobjekt ein, wie im folgenden Beispielcode gezeigt:
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 für fast alle Kamerafunktionen. Die meisten Parameter können jederzeit geändert werden, nachdem Sie eine Instanz des Camera
-Objekts abgerufen haben. Änderungen an Parametern sind für den Nutzer in der Regel sofort in der Kameravorschau der Anwendung sichtbar.
Softwareseitig kann es mehrere Frames dauern, bis Parameteränderungen tatsächlich wirksam werden, wenn die Kamerahardware die neuen Anweisungen verarbeitet und dann aktualisierte Bilddaten sendet.
Wichtig:Einige Kamerafunktionen können nicht automatisch geändert werden. Insbesondere wenn Sie die Größe oder Ausrichtung der Kameravorschau ändern möchten, müssen Sie sie zuerst beenden, ihre Größe ändern und die Vorschau dann neu starten. Ab Android 4.0 (API-Level 14) kann die Vorschauausrichtung geändert werden, ohne dass die Vorschau neu gestartet wird.
Für die Implementierung anderer Kamerafunktionen ist mehr Code erforderlich:
- Mess- und Fokusbereiche
- Gesichtserkennung
- Zeitraffervideo
In den folgenden Abschnitten erhalten Sie einen kurzen Überblick über die Implementierung dieser Funktionen.
Mess- und Fokusbereiche
In einigen fotografischen Szenarien liefert die automatische Fokussierung und Lichtmessung möglicherweise nicht die gewünschten Ergebnisse. Ab Android 4.0 (API-Level 14) bietet Ihre Kamera-App zusätzliche Steuerelemente, mit denen Ihre App oder Nutzer Bereiche in einem Bild zur Bestimmung der Fokus- oder Lichtintensität festlegen und diese zur Aufnahme von Bildern oder Videos an die Kamerahardware weitergeben können.
Die Bereiche für Messung und Fokus funktionieren sehr ähnlich wie andere Kamerafunktionen, da Sie sie über Methoden im Camera.Parameters
-Objekt steuern. Mit dem folgenden Code werden zwei Lichtmessbereiche für eine Instanz von Camera
festgelegt:
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 Festlegen eines Bereichs im Sichtfeld der Kamera und einen Gewichtswert, der der Kamera mitteilt, welche Bedeutung dieser Bereich bei Lichtmessungen oder Fokusberechnungen erhalten soll.
Das Feld Rect
in einem Camera.Area
-Objekt beschreibt eine rechteckige Form, die auf einem Raster von 2.000 × 2.000 Pixeln abgebildet ist. Die Koordinaten -1000 und -1000 stehen für die linke obere Ecke des Kamerabildes und die Koordinaten 1000 und 1000 für die untere rechte Ecke des Kamerabildes, wie in der folgenden Abbildung dargestellt.
Die Grenzen dieses Koordinatensystems entsprechen immer dem äußeren Rand des Bilds, das in der Kameravorschau sichtbar ist, und werden bei der Zoomstufe nicht verkleinert oder erweitert. Ebenso wird das Koordinatensystem bei der Drehung der Bildvorschau mit Camera.setDisplayOrientation()
nicht neu abgebildet.
Gesichtserkennung
Bei Bildern, auf denen Personen zu sehen sind, sind Gesichter in der Regel der wichtigste Teil des Bilds und sollten zur Bestimmung von Fokus und Weißabgleich bei der Aufnahme verwendet werden. Das Framework Android 4.0 (API-Level 14) bietet APIs für die Erkennung von Gesichtern und die Berechnung von Bildeinstellungen mithilfe der Gesichtserkennungstechnologie.
Hinweis:Während die Gesichtserkennung ausgeführt wird, haben setWhiteBalance(String)
, setFocusAreas(List<Camera.Area>)
und setMeteringAreas(List<Camera.Area>)
keine Auswirkungen.
Zur 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
- Gesichtserkennungs-Listener dem Kameraobjekt hinzufügen
- Gesichtserkennung nach der Vorschau starten (und nach jedem Vorschauneustart)
Die Gesichtserkennung wird nicht auf allen Geräten unterstützt. Wenn Sie prüfen möchten, ob dieses Feature unterstützt wird, rufen Sie getMaxNumDetectedFaces()
auf. Ein Beispiel für diese Prüfung finden Sie unten in der Beispielmethode startFaceDetection()
.
Damit Sie benachrichtigt werden und auf die Gesichtswiedererkennung reagieren können, muss Ihre Kamera-App einen Listener für Gesichtserkennungsereignisse einrichten. Dazu müssen Sie eine Listener-Klasse erstellen, die die Camera.FaceDetectionListener
-Schnittstelle implementiert, wie im Beispielcode unten gezeigt.
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, setzen Sie sie in das Camera
-Objekt Ihrer Anwendung, wie im folgenden Beispielcode gezeigt:
Kotlin
camera?.setFaceDetectionListener(MyFaceDetectionListener())
Java
camera.setFaceDetectionListener(new MyFaceDetectionListener());
Ihre Anwendung muss die Gesichtserkennungsfunktion jedes Mal starten, wenn Sie die Kameravorschau starten oder neu starten. Erstellen Sie eine Methode zum Starten der Gesichtserkennung, damit Sie sie bei Bedarf aufrufen können, wie im Beispielcode unten gezeigt.
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(); } }
Sie müssen die Gesichtserkennung jedes Mal starten, wenn Sie die Kameravorschau starten oder neu starten. Wenn Sie die unter Vorschauklasse erstellen gezeigte Vorschauklasse verwenden, fügen Sie die Methode startFaceDetection()
sowohl der Methode surfaceCreated()
als auch der Methode surfaceChanged()
in Ihrer Vorschauklasse hinzu, wie im Beispielcode unten gezeigt.
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 Aufrufen von startPreview()
aufzurufen. Versuchen Sie nicht, die Gesichtserkennung in der Methode onCreate()
der Hauptaktivität Ihrer Kamera-App zu starten, da die Vorschau zu diesem Zeitpunkt während der Ausführung Ihrer App nicht verfügbar ist.
Zeitraffervideo
Mit Zeitraffervideos können Nutzer Videoclips erstellen, in denen Bilder im Abstand von wenigen Sekunden oder Minuten kombiniert werden. Dieses Feature verwendet MediaRecorder
, um die Bilder für eine Zeitraffersequenz aufzuzeichnen.
Um ein Zeitraffervideo mit MediaRecorder
aufzunehmen, musst du das Rekorder-Objekt so konfigurieren, dass du ein normales Video aufnimmst. Setze die Anzahl der erfassten Bilder pro Sekunde auf eine niedrige Zahl und verwende eine der Einstellungen für die Zeitrafferqualität, wie im folgenden Codebeispiel 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 eines umfassenderen Konfigurationsverfahrens 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 Videoaufzeichnung so, als würden Sie einen normalen Videoclip aufzeichnen. Weitere Informationen zum Konfigurieren und Ausführen von MediaRecorder
finden Sie unter Videos aufnehmen.
In den Beispielen für Camera2Video und HdrViewfinder wird die Verwendung der auf dieser Seite behandelten APIs weiter veranschaulicht.
Kamerafelder, für die eine Berechtigung erforderlich ist
Apps mit Android 10 (API-Level 29) oder höher müssen die Berechtigung CAMERA
haben, um auf die Werte der folgenden Felder zugreifen zu können, die von der Methode getCameraCharacteristics()
zurückgegeben werden:
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 im Camera2Basic-Beispiel und in der offiziellen CameraX-Beispiel-App herunterladen.