API Camera

Le framework Android est compatible avec plusieurs appareils photo et fonctionnalités d'appareil photo disponibles sur les appareils, ce qui vous permet de capturer des images et des vidéos dans vos applications. Ce document décrit une approche simple et rapide de la capture d'image et de vidéo, ainsi qu'une approche avancée pour créer des expériences photo personnalisées pour vos utilisateurs.

Remarque:Cette page décrit la classe Camera, qui est désormais obsolète. Nous vous recommandons d'utiliser la bibliothèque Jetpack CameraX ou, pour des cas d'utilisation spécifiques, la classe camera2. CameraX et Camera2 fonctionnent sur Android 5.0 (niveau d'API 21) ou version ultérieure.

Points à prendre en compte

Avant d'autoriser votre application à utiliser des appareils photo sur des appareils Android, vous devez vous poser quelques questions sur la manière dont votre application prévoit d'utiliser cette fonctionnalité matérielle.

• Exigences relatives à l'appareil photo : l'utilisation d'un appareil photo est-elle si importante pour votre application que vous ne voulez pas qu'elle soit installée sur un appareil qui n'en est pas équipé ? Le cas échéant, vous devez déclarer les exigences concernant l'appareil photo dans votre fichier manifeste.
• Image rapide ou appareil photo personnalisé : comment votre application utilisera-t-elle l'appareil photo ? Voulez-vous simplement prendre une photo rapide ou un extrait vidéo, ou votre application proposera-t-elle une nouvelle façon d'utiliser les appareils photo ? Utiliser des applications d'appareil photo existantes pour obtenir un Snap ou un clip rapide Pour développer une fonctionnalité d'appareil photo personnalisée, consultez la section Créer une application d'appareil photo.
• Exigences concernant les services de premier plan : Quand votre application interagit-elle avec la caméra ? Sur Android 9 (niveau d'API 28) ou version ultérieure, les applications exécutées en arrière-plan ne peuvent pas accéder à l'appareil photo. Par conséquent, vous devez utiliser la caméra lorsque votre application est exécutée au premier plan ou dans un service de premier plan.
• Stockage : les images ou les vidéos générées par votre application sont-elles uniquement visibles par votre application ou partagées afin que d'autres applications telles que Galerie ou d'autres applications multimédias et de réseaux sociaux puissent les utiliser ? Voulez-vous que les images et les vidéos soient disponibles même si votre application est désinstallée ? Consultez la section Enregistrer des fichiers multimédias pour découvrir comment mettre en œuvre ces options.

Principes de base

Le framework Android permet de capturer des images et des vidéos via l'API android.hardware.camera2 ou l'appareil photo Intent. Voici les classes pertinentes:

android.hardware.camera2

Ce package est l'API principale permettant de contrôler les caméras des appareils. Elle peut être utilisée pour prendre des photos ou des vidéos lorsque vous créez une application d'appareil photo.

Camera

Cette classe est l'ancienne API obsolète permettant de contrôler les caméras des appareils.

SurfaceView

Cette classe permet de présenter à l'utilisateur un aperçu de la caméra en direct.

MediaRecorder

Cette classe permet d'enregistrer une vidéo à partir de la caméra.

Intent

Un type d'action d'intent MediaStore.ACTION_IMAGE_CAPTURE ou MediaStore.ACTION_VIDEO_CAPTURE peut être utilisé pour capturer des images ou des vidéos sans utiliser directement l'objet Camera.

Déclarations du fichier manifeste

Avant de commencer le développement de votre application avec l'API Camera, vous devez vous assurer que votre fichier manifeste contient les déclarations appropriées pour permettre l'utilisation du matériel de l'appareil photo et d'autres fonctionnalités associées.

• Autorisation d'accès à l'appareil photo : votre application doit demander l'autorisation d'utiliser l'appareil photo d'un appareil.

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

  Remarque:Si vous utilisez l'appareil photo en appelant une application d'appareil photo existante, votre application n'a pas besoin de demander cette autorisation.

• Fonctionnalités de l'appareil photo : votre application doit également déclarer l'utilisation des fonctionnalités de l'appareil photo, par exemple :

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

  Pour obtenir la liste des fonctionnalités de l'appareil photo, consultez la documentation de référence sur les fonctionnalités du fichier manifeste.

  Lorsque vous ajoutez des fonctionnalités d'appareil photo à votre fichier manifeste, Google Play empêche l'installation de votre application sur les appareils qui n'incluent pas d'appareil photo ou qui ne sont pas compatibles avec les fonctionnalités de caméra que vous spécifiez. Pour en savoir plus sur l'utilisation du filtrage basé sur les fonctionnalités avec Google Play, consultez la page Google Play et filtrage basé sur les fonctionnalités.

  Si votre application peut utiliser un appareil photo ou une fonctionnalité d'appareil photo pour fonctionner correctement, mais qu'elle n'en a pas besoin, vous devez le spécifier dans le fichier manifeste en incluant l'attribut android:required et en le définissant sur false:

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

• Autorisation de stockage : votre application peut enregistrer des images ou des vidéos sur la mémoire de stockage externe de l'appareil (carte SD) si elle cible Android 10 (niveau d'API 29) ou une version antérieure et spécifie les éléments suivants dans le fichier manifeste.

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

• Autorisation d'enregistrement audio : pour enregistrer du contenu audio avec capture vidéo, votre application doit demander l'autorisation de capture audio.

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

• Autorisation de localisation : si votre application tague des images avec des informations de localisation GPS, vous devez demander l'autorisation ACCESS_FINE_LOCATION. Notez que si votre application cible Android 5.0 (niveau d'API 21) ou une version ultérieure, vous devez également déclarer qu'elle utilise le GPS de l'appareil:

  <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" />
  

  Pour savoir comment obtenir la position de l'utilisateur, consultez Stratégies de localisation.

Avec des applications d'appareil photo existantes

Un moyen rapide d'activer la prise de photos ou de vidéos dans votre application sans beaucoup de code supplémentaire consiste à utiliser un Intent pour appeler une application d'appareil photo Android existante. Pour en savoir plus, consultez les cours de formation Prendre des photos en toute simplicité et Enregistrer des vidéos en toute simplicité.

Créer une application d'appareil photo

Certains développeurs peuvent avoir besoin d'une interface utilisateur d'appareil photo personnalisée en fonction de l'apparence de leur application ou fournissant des fonctionnalités spéciales. Écrire votre propre code de prise d'images peut offrir une expérience plus attrayante à vos utilisateurs.

Remarque: Le guide suivant concerne l'ancienne API Camera, qui est obsolète. Pour les applications d'appareil photo nouvelles ou avancées, la nouvelle API android.hardware.camera2 est recommandée.

Pour créer une interface d'appareil photo personnalisée pour votre application, procédez comme suit:

• Détecter et accéder aux caméras : crée un code pour vérifier l'existence de caméras et demander l'accès.
• Créer une classe Preview : créez une classe d'aperçu de l'appareil photo qui étend SurfaceView et implémente l'interface SurfaceHolder. Cette classe affiche un aperçu des images en direct de l'appareil photo.
• Créer une mise en page d'aperçu : une fois que vous disposez de la classe d'aperçu de l'appareil photo, créez une mise en page de vue qui intègre l'aperçu et les commandes d'interface utilisateur souhaitées.
• Configurer des écouteurs pour la capture : connectez des écouteurs pour les commandes d'interface afin de lancer la capture d'image ou de vidéo en réponse aux actions de l'utilisateur, telles que l'appui sur un bouton.
• Capture and Save Files (Capture et enregistrement des fichiers) : configurez le code pour prendre des photos ou des vidéos et enregistrer la sortie.
• Libérer l'appareil photo : après avoir utilisé l'appareil photo, votre application doit la libérer pour que d'autres applications puissent l'utiliser.

Le matériel photo est une ressource partagée qui doit être gérée avec soin afin que votre application n'entre pas en conflit avec d'autres applications qui pourraient également vouloir l'utiliser. Les sections suivantes expliquent comment détecter le matériel de l'appareil photo, demander l'accès à un appareil photo, prendre des photos ou enregistrer une vidéo, et libérer l'appareil photo lorsque votre application a terminé de l'utiliser.

Attention:N'oubliez pas de libérer l'objet Camera en appelant Camera.release() lorsque votre application a fini de l'utiliser. Si votre application ne libère pas correctement l'appareil photo, toutes les tentatives ultérieures d'accès à l'appareil photo, y compris celles effectuées par votre propre application, échoueront et risquent d'entraîner l'arrêt de votre application ou d'autres applications.

Détection du matériel de la caméra...

Si votre application ne nécessite pas spécifiquement un appareil photo via une déclaration de fichier manifeste, vérifiez si un appareil photo est disponible au moment de l'exécution. Pour effectuer cette vérification, utilisez la méthode PackageManager.hasSystemFeature(), comme indiqué dans l'exemple de code ci-dessous:

/** 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
    }
}

/** 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;
    }
}

Les appareils Android peuvent être équipés de plusieurs appareils photo, par exemple une caméra arrière pour la photographie et une caméra avant pour les appels vidéo. Android 2.3 (niveau d'API 9) ou version ultérieure vous permet de vérifier le nombre d'appareils photo disponibles sur un appareil à l'aide de la méthode Camera.getNumberOfCameras().

Accès aux caméras

Si vous avez déterminé que l'appareil sur lequel votre application s'exécute est équipé d'une caméra, vous devez demander à y accéder en obtenant une instance de Camera (sauf si vous utilisez un intent pour accéder à l'appareil photo).

Pour accéder à l'appareil photo principal, utilisez la méthode Camera.open() et assurez-vous d'intercepter toutes les exceptions, comme indiqué dans le code ci-dessous:

/** 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
    }
}

/** 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
}

Attention:Vérifiez toujours les exceptions lorsque vous utilisez Camera.open(). Si la recherche d'exceptions ne s'applique pas si l'appareil photo est utilisé ou n'existe pas, le système arrêtera votre application.

Sur les appareils équipés d'Android 2.3 (niveau d'API 9) ou version ultérieure, vous pouvez accéder à des appareils photo spécifiques à l'aide de Camera.open(int). L'exemple de code ci-dessus permet d'accéder à la première caméra arrière d'un appareil doté de plusieurs caméras.

Vérification des fonctionnalités de la caméra

Une fois que vous avez accès à une caméra, vous pouvez obtenir plus d'informations sur ses fonctionnalités à l'aide de la méthode Camera.getParameters() et en vérifiant les fonctionnalités prises en charge de l'objet Camera.Parameters renvoyé. Lorsque vous utilisez le niveau d'API 9 ou supérieur, utilisez Camera.getCameraInfo() pour déterminer si un appareil photo se trouve à l'avant ou à l'arrière de l'appareil, et pour déterminer l'orientation de l'image.

Créer une classe preview

Pour que les utilisateurs puissent prendre des photos ou enregistrer des vidéos de manière efficace, ils doivent pouvoir voir ce que voit la caméra de l'appareil. Une classe d'aperçu de l'appareil photo est une SurfaceView qui peut afficher les données d'image en direct provenant d'un appareil photo, afin que les utilisateurs puissent cadrer et capturer une photo ou une vidéo.

L'exemple de code suivant montre comment créer une classe d'aperçu de l'appareil photo de base pouvant être incluse dans une mise en page View. Cette classe implémente SurfaceHolder.Callback afin de capturer les événements de rappel pour créer et détruire la vue, qui sont nécessaires à l'attribution de l'entrée d'aperçu de la caméra.

/** 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}")
            }
        }
    }
}

/** 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());
        }
    }
}

Si vous souhaitez définir une taille spécifique pour l'aperçu de l'appareil photo, définissez-la dans la méthode surfaceChanged(), comme indiqué dans les commentaires ci-dessus. Lorsque vous définissez la taille de l'aperçu, vous devez utiliser les valeurs de getSupportedPreviewSizes(). Ne définissez pas de valeurs arbitraires dans la méthode setPreviewSize().

Remarque:Avec l'introduction de la fonctionnalité Multifenêtre dans Android 7.0 (niveau d'API 24) ou version ultérieure, vous ne pouvez plus supposer que le format de l'aperçu est le même que celui de votre activité, même après avoir appelé setDisplayOrientation(). En fonction de la taille de la fenêtre et du format, vous devrez peut-être ajuster un aperçu de l'appareil photo grand angle dans une mise en page orientée portrait, ou inversement, à l'aide d'une mise en page au format letterbox.

Placer l'aperçu dans une mise en page

Une classe d'aperçu de l'appareil photo, comme dans l'exemple de la section précédente, doit être placée dans la mise en page d'une activité, avec d'autres commandes d'interface utilisateur permettant de prendre une photo ou une vidéo. Cette section vous explique comment créer une mise en page et une activité de base pour l'aperçu.

Le code de mise en page suivant fournit une vue très basique pouvant être utilisée pour afficher un aperçu d'appareil photo. Dans cet exemple, l'élément FrameLayout est destiné à être le conteneur de la classe d'aperçu de l'appareil photo. Ce type de mise en page permet de superposer des informations ou des commandes supplémentaires sur les images d'aperçu de l'appareil photo en direct.

<?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>

Sur la plupart des appareils, l'aperçu de l'appareil photo est par défaut en mode paysage. Cet exemple de mise en page spécifie une mise en page horizontale (paysage), et le code ci-dessous fixe l'orientation de l'application en mode paysage. Pour simplifier l'affichage d'un aperçu de l'appareil photo, vous devez modifier l'orientation de l'activité d'aperçu de votre application en mode Paysage en ajoutant le code suivant à votre fichier manifeste.

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

Remarque:L'aperçu d'un appareil photo ne doit pas nécessairement être en mode Paysage. À partir d'Android 2.2 (niveau d'API 8), vous pouvez utiliser la méthode setDisplayOrientation() pour définir la rotation de l'image d'aperçu. Pour modifier l'orientation de l'aperçu lorsque l'utilisateur réoriente le téléphone, dans la méthode surfaceChanged() de votre classe d'aperçu, commencez par arrêter l'aperçu avec Camera.stopPreview(), modifiez l'orientation, puis redémarrez-le avec Camera.startPreview().

Dans l'activité de la vue de la caméra, ajoutez votre classe d'aperçu à l'élément FrameLayout indiqué dans l'exemple ci-dessus. L'activité de la caméra doit également être libérée lorsqu'elle est mise en pause ou éteinte. L'exemple suivant montre comment modifier une activité de caméra pour joindre la classe d'aperçu décrite dans la section Créer une classe d'aperçu.

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)
        }
    }
}

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);
    }
}

Remarque:La méthode getCameraInstance() de l'exemple ci-dessus fait référence à l'exemple de méthode présenté dans Accéder aux appareils photo.

Capture d'images

Une fois que vous avez créé une classe d'aperçu et une mise en page de vue dans laquelle l'afficher, vous pouvez commencer à capturer des images avec votre application. Dans le code de votre application, vous devez configurer des écouteurs pour que les commandes de votre interface utilisateur répondent à une action de l'utilisateur en prenant une photo.

Pour récupérer une image, utilisez la méthode Camera.takePicture(). Cette méthode utilise trois paramètres qui reçoivent des données de l'appareil photo. Pour recevoir des données au format JPEG, vous devez implémenter une interface Camera.PictureCallback afin de recevoir les données d'image et de les écrire dans un fichier. Le code suivant montre une implémentation de base de l'interface Camera.PictureCallback pour enregistrer une image envoyée par l'appareil photo.

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}")
    }
}

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());
        }
    }
};

Déclenchez la capture d'image en appelant la méthode Camera.takePicture(). L'exemple de code suivant montre comment appeler cette méthode à partir d'un bouton View.OnClickListener.

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

// 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);
        }
    }
);

Remarque:Dans l'exemple suivant, le membre mPicture fait référence à l'exemple de code ci-dessus.

Attention:N'oubliez pas de libérer l'objet Camera en appelant Camera.release() lorsque votre application a fini de l'utiliser. Pour savoir comment libérer la caméra, consultez Libérer la caméra.

Enregistrement de vidéos

La capture vidéo à l'aide du framework Android nécessite une gestion minutieuse de l'objet Camera et une coordination avec la classe MediaRecorder. Lorsque vous enregistrez une vidéo avec Camera, vous devez gérer les appels Camera.lock() et Camera.unlock() pour autoriser MediaRecorder à accéder à l'appareil photo, en plus des appels Camera.open() et Camera.release().

Remarque:À partir d'Android 4.0 (niveau d'API 14), les appels Camera.lock() et Camera.unlock() sont gérés automatiquement pour vous.

Contrairement à la prise de photos avec la caméra d'un appareil, l'enregistrement vidéo nécessite un ordre d'appel très particulier. Vous devez suivre un ordre d'exécution spécifique pour réussir à préparer et à capturer des vidéos avec votre application, comme indiqué ci-dessous.

1. Open Camera (Ouvrir l'appareil photo) : utilisez Camera.open() pour obtenir une instance de l'objet Camera.
2. Associer l'aperçu : préparez un aperçu de l'image de caméra en direct en connectant un SurfaceView à la caméra à l'aide de Camera.setPreviewDisplay().
3. Démarrer l'aperçu : appelez Camera.startPreview() pour commencer à afficher les images de caméra en direct.
4. Démarrer l'enregistrement de la vidéo : vous devez suivre les étapes suivantes pour pouvoir enregistrer une vidéo :
   1. Déverrouiller la caméra : déverrouillez la caméra pour que MediaRecorder puisse l'utiliser en appelant Camera.unlock().
   2. Configure MediaRecorder (Configurer MediaRecorder) : appelez les méthodes MediaRecorder suivantes dans cet ordre. Pour en savoir plus, consultez la documentation de référence sur MediaRecorder.
      1. setCamera() : configurez l'appareil photo à utiliser pour la capture vidéo, en utilisant l'instance actuelle de Camera de votre application.
      2. setAudioSource() : définissez la source audio, utilisez MediaRecorder.AudioSource.CAMCORDER.
      3. setVideoSource() : définissez la source vidéo à l'aide de MediaRecorder.VideoSource.CAMERA.
      4. Définissez le format et l'encodage de la sortie vidéo. Pour Android 2.2 (niveau d'API 8) ou version ultérieure, utilisez la méthode MediaRecorder.setProfile et obtenez une instance de profil à l'aide de CamcorderProfile.get(). Pour les versions d'Android antérieures à 2.2, vous devez définir le format de sortie vidéo et les paramètres d'encodage :
         1. setOutputFormat() : définissez le format de sortie, spécifiez le paramètre par défaut ou MediaRecorder.OutputFormat.MPEG_4.
         2. setAudioEncoder() : définissez le type d'encodage audio, spécifiez le paramètre par défaut ou MediaRecorder.AudioEncoder.AMR_NB.
         3. setVideoEncoder() : définissez le type d'encodage de la vidéo, spécifiez le paramètre par défaut ou MediaRecorder.VideoEncoder.MPEG_4_SP.
      5. setOutputFile() : définissez le fichier de sortie en utilisant getOutputMediaFile(MEDIA_TYPE_VIDEO).toString() à partir de l'exemple de méthode de la section Enregistrer des fichiers multimédias.
      6. setPreviewDisplay() : spécifiez l'élément de mise en page d'aperçu SurfaceView pour votre application. Utilisez le même objet que celui que vous avez spécifié pour l'aperçu de connexion.

      Attention:Vous devez appeler ces méthodes de configuration MediaRecorder dans cet ordre, sinon votre application rencontrera des erreurs et l'enregistrement échouera.

   3. Prepare MediaRecorder (Préparer MediaRecorder) : préparez le MediaRecorder avec les paramètres de configuration fournis en appelant MediaRecorder.prepare().
   4. Start MediaRecorder (Démarrer MediaRecorder) : lancez l'enregistrement vidéo en appelant MediaRecorder.start().
5. Stop Recording Video (Arrêter l'enregistrement vidéo) : appelez les méthodes suivantes dans l'ordre pour terminer l'enregistrement vidéo :
   1. Stop MediaRecorder (Arrêter MediaRecorder) : arrêtez l'enregistrement d'une vidéo en appelant MediaRecorder.stop().
   2. Reset MediaRecorder (Réinitialiser MediaRecorder) : vous pouvez éventuellement supprimer les paramètres de configuration de l'enregistreur en appelant MediaRecorder.reset().
   3. Release MediaRecorder : libérez MediaRecorder en appelant MediaRecorder.release().
   4. Verrouiller la caméra : verrouillez la caméra pour que les futures sessions MediaRecorder puissent l'utiliser en appelant Camera.lock(). À partir d'Android 4.0 (niveau d'API 14), cet appel n'est pas nécessaire, sauf si l'appel MediaRecorder.prepare() échoue.
6. Arrêter l'aperçu : lorsque votre activité a fini d'utiliser la caméra, arrêtez l'aperçu à l'aide de Camera.stopPreview().
7. Release Camera (Libérer l'appareil photo) : relâchez l'appareil photo pour que d'autres applications puissent l'utiliser en appelant Camera.release().

Remarque:Vous pouvez utiliser MediaRecorder sans créer d'aperçu d'appareil photo au préalable et ignorer les premières étapes de cette procédure. Toutefois, comme les utilisateurs préfèrent généralement voir un aperçu avant de démarrer un enregistrement, ce processus n'est pas abordé ici.

Conseil:Si votre application est généralement utilisée pour enregistrer des vidéos, définissez setRecordingHint(boolean) sur true avant de lancer l'aperçu. Ce paramètre permet de réduire le temps nécessaire pour démarrer l'enregistrement.

Configurer MediaRecorder

Lorsque vous utilisez la classe MediaRecorder pour enregistrer une vidéo, vous devez effectuer les étapes de configuration dans un ordre spécifique, puis appeler la méthode MediaRecorder.prepare() pour vérifier et implémenter la configuration. L'exemple de code suivant montre comment configurer et préparer correctement la classe MediaRecorder pour l'enregistrement vidéo.

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
}

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

Dans les versions antérieures à Android 2.2 (niveau d'API 8), vous devez définir directement les paramètres de format de sortie et de format d'encodage au lieu d'utiliser CamcorderProfile. Cette approche est illustrée dans le code suivant:

    // 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)
    }

    // 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);

Les paramètres d'enregistrement vidéo suivants pour MediaRecorder disposent de paramètres par défaut. Toutefois, vous pouvez les ajuster pour votre application:

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

Démarrage et arrêt de MediaRecorder

Lorsque vous démarrez et arrêtez l'enregistrement vidéo à l'aide de la classe MediaRecorder, vous devez suivre un ordre spécifique, comme indiqué ci-dessous.

1. Déverrouiller l'appareil photo avec Camera.unlock()
2. Configurez MediaRecorder comme indiqué dans l'exemple de code ci-dessus
3. Démarrer l'enregistrement avec MediaRecorder.start()
4. Enregistrer la vidéo
5. Arrêter l'enregistrement avec MediaRecorder.stop()
6. Libérer l'enregistreur multimédia avec MediaRecorder.release()
7. Verrouiller la caméra avec Camera.lock()

L'exemple de code suivant montre comment connecter un bouton pour démarrer et arrêter correctement un enregistrement vidéo à l'aide de l'appareil photo et de la classe MediaRecorder.

Remarque:Lorsque vous enregistrez une vidéo, ne relâchez pas la caméra, sinon l'aperçu s'arrêtera.

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
        }
    }
}

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
                }
            }
        }
    }
);

Remarque:Dans l'exemple ci-dessus, la méthode prepareVideoRecorder() fait référence à l'exemple de code indiqué dans la section Configurer MediaRecorder. Cette méthode permet de verrouiller la caméra, ainsi que de configurer et de préparer l'instance MediaRecorder.

Libération de la caméra

Les appareils photo sont des ressources partagées par les applications d'un appareil. Votre application peut utiliser l'appareil photo après avoir obtenu une instance de Camera. Vous devez veiller à libérer l'objet appareil photo lorsque votre application cesse de l'utiliser, et dès que votre application est mise en pause (Activity.onPause()). Si votre application ne libère pas correctement l'appareil photo, toutes les tentatives ultérieures d'accès à l'appareil photo, y compris celles effectuées par votre propre application, échoueront et entraîneront l'arrêt de votre application ou d'autres applications.

Pour libérer une instance de l'objet Camera, utilisez la méthode Camera.release(), comme indiqué dans l'exemple de code ci-dessous.

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
    }
}

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

Attention:Si votre application ne libère pas correctement l'appareil photo, toutes les tentatives ultérieures d'accès à l'appareil photo, y compris celles effectuées par votre propre application, échoueront et risquent d'arrêter votre application ou d'autres applications.

Enregistrement de fichiers multimédias

Les fichiers multimédias créés par les utilisateurs, tels que des images et des vidéos, doivent être enregistrés dans le répertoire de stockage externe d'un appareil (carte SD) afin d'économiser de l'espace système et de permettre aux utilisateurs d'y accéder sans leur appareil. Il existe de nombreux emplacements de répertoire possibles pour enregistrer des fichiers multimédias sur un appareil. Toutefois, en tant que développeur, vous ne devez envisager que deux emplacements standards:

• Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES) : cette méthode renvoie l'emplacement standard, partagé et recommandé pour enregistrer les photos et les vidéos. Ce répertoire étant partagé (public), d'autres applications peuvent facilement découvrir, lire, modifier et supprimer les fichiers enregistrés à cet emplacement. Si votre application est désinstallée par l'utilisateur, les fichiers multimédias enregistrés à cet emplacement ne seront pas supprimés. Pour éviter toute interférence avec les photos et vidéos existantes des utilisateurs, vous devez créer un sous-répertoire pour les fichiers multimédias de votre application dans ce répertoire, comme indiqué dans l'exemple de code ci-dessous. Cette méthode est disponible sur Android 2.2 (niveau d'API 8). Pour les appels équivalents dans les versions précédentes de l'API, consultez Enregistrer des fichiers partagés.
• Context.getExternalFilesDir(Environment.DIRECTORY_PICTURES) : cette méthode renvoie un emplacement standard pour enregistrer les images et les vidéos associées à votre application. Si votre application est désinstallée, tous les fichiers enregistrés à cet emplacement sont supprimés. La sécurité n'est pas appliquée aux fichiers situés à cet emplacement, et d'autres applications peuvent les lire, les modifier et les supprimer.

L'exemple de code suivant montre comment créer un emplacement File ou Uri pour un fichier multimédia pouvant être utilisé lors de l'appel de l'appareil photo d'un appareil avec un élément Intent ou dans le cadre d'une création d'application d'appareil photo.

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
    }
}

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

Remarque:Environment.getExternalStoragePublicDirectory() est disponible sur Android 2.2 (niveau d'API 8) ou version ultérieure. Si vous ciblez des appareils équipés de versions antérieures d'Android, utilisez plutôt Environment.getExternalStorageDirectory(). Pour en savoir plus, consultez Enregistrer des fichiers partagés.

Pour rendre l'URI compatible avec les profils professionnels, commencez par convertir l'URI du fichier en URI de contenu. Ajoutez ensuite l'URI de contenu au EXTRA_OUTPUT d'un Intent.

Pour en savoir plus sur l'enregistrement de fichiers sur un appareil Android, consultez l'article Stockage des données.

Fonctionnalités de l'appareil photo

Android est compatible avec un large éventail de fonctionnalités de l'appareil photo que vous pouvez contrôler avec votre application d'appareil photo, telles que le format d'image, le mode flash, les paramètres de mise au point, etc. Cette section présente les fonctionnalités courantes de la caméra et explique brièvement comment les utiliser. La plupart des fonctionnalités de la caméra sont accessibles et définies à l'aide de l'objet Camera.Parameters. Cependant, plusieurs fonctionnalités importantes nécessitent plus que de simples paramètres dans Camera.Parameters. Ces fonctionnalités sont abordées dans les sections suivantes:

• Mesure et domaines d'action
• Détection de visages
• Vidéo en accéléré

Pour obtenir des informations générales sur l'utilisation des fonctionnalités contrôlées via Camera.Parameters, consultez la section Utiliser les fonctionnalités de l'appareil photo. Pour en savoir plus sur l'utilisation des fonctionnalités contrôlées via l'objet des paramètres de l'appareil photo, suivez les liens de la liste des fonctionnalités ci-dessous vers la documentation de référence de l'API.

Tableau 1. Fonctionnalités d'appareil photo courantes triées en fonction du niveau d'API Android dans lequel elles ont été introduites.

Remarque:Ces fonctionnalités ne sont pas compatibles avec tous les appareils en raison de différences matérielles et de l'implémentation logicielle. Pour savoir comment vérifier la disponibilité des fonctionnalités sur l'appareil où votre application s'exécute, consultez la section Vérifier la disponibilité des fonctionnalités.

Vérifier la disponibilité des fonctionnalités

Lorsque vous envisagez d'utiliser les fonctionnalités de l'appareil photo sur les appareils Android, il faut d'abord savoir que ces fonctionnalités ne sont pas toutes prises en charge sur tous les appareils. De plus, les appareils compatibles avec une fonctionnalité particulière peuvent les prendre en charge à différents niveaux ou avec différentes options. Par conséquent, une partie de votre processus de décision lorsque vous développez une application d'appareil photo consiste à choisir les fonctionnalités de caméra que vous souhaitez prendre en charge et à quel niveau. Une fois cette décision prise, vous devez prévoir d'inclure dans votre application d'appareil photo du code qui vérifie si le matériel de l'appareil est compatible avec ces fonctionnalités et échoue correctement si une fonctionnalité n'est pas disponible.

Vous pouvez vérifier la disponibilité des fonctionnalités de l'appareil photo en obtenant une instance de l'objet de paramètres d'un appareil photo et en vérifiant les méthodes appropriées. L'exemple de code suivant montre comment obtenir un objet Camera.Parameters et vérifier si l'appareil photo est compatible avec la fonctionnalité d'autofocus:

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
}

// 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
}

Vous pouvez utiliser la technique illustrée ci-dessus pour la plupart des fonctionnalités de l'appareil photo. L'objet Camera.Parameters fournit une méthode getSupported...(), is...Supported() ou getMax...() pour déterminer si une fonctionnalité est compatible (et dans quelle mesure).

Si votre application nécessite certaines fonctionnalités de l'appareil photo pour fonctionner correctement, vous pouvez en ajouter en ajoutant le fichier manifeste de votre application. Lorsque vous déclarez l'utilisation de fonctionnalités d'appareil photo spécifiques, telles que le flash et l'autofocus, Google Play empêche l'installation de votre application sur les appareils non compatibles avec ces fonctionnalités. Pour obtenir la liste des fonctionnalités de l'appareil photo pouvant être déclarées dans le fichier manifeste de votre application, consultez la documentation de référence sur les fonctionnalités du fichier manifeste.

Utilisation des fonctionnalités de l'appareil photo

La plupart des fonctionnalités de la caméra sont activées et contrôlées à l'aide d'un objet Camera.Parameters. Pour obtenir cet objet, vous devez d'abord obtenir une instance de l'objet Camera, appeler la méthode getParameters(), modifier l'objet de paramètre renvoyé, puis le redéfinir dans l'objet appareil photo, comme illustré dans l'exemple de code suivant:

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

// 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);

Cette technique fonctionne pour presque toutes les fonctionnalités de l'appareil photo, et la plupart des paramètres peuvent être modifiés à tout moment après avoir obtenu une instance de l'objet Camera. Les modifications apportées aux paramètres sont généralement visibles immédiatement dans l'aperçu de l'appareil photo de l'application. Côté logiciel, plusieurs images peuvent être nécessaires pour que les modifications de paramètres prennent effet, car la caméra traite les nouvelles instructions, puis envoie les données d'image mises à jour.

Important:Certaines fonctionnalités de l'appareil photo ne peuvent pas être modifiées à tout moment. Plus spécifiquement, pour modifier la taille ou l'orientation de l'aperçu de l'appareil photo, vous devez d'abord arrêter l'aperçu, modifier la taille de l'aperçu, puis le redémarrer. À partir d'Android 4.0 (niveau d'API 14), l'orientation de l'aperçu peut être modifiée sans redémarrer l'aperçu.

D'autres fonctionnalités de l'appareil photo nécessitent davantage de code à implémenter, y compris:

• Mesures et zones de mise au point
• Détection de visages
• Vidéo en accéléré

Un aperçu rapide de la façon de mettre en œuvre ces fonctionnalités est fourni dans les sections suivantes.

Mesures et zones de mise au point

Dans certains scénarios photographiques, la mise au point automatique et la mesure de la lumière peuvent ne pas produire les résultats souhaités. À partir d'Android 4.0 (niveau d'API 14), votre application d'appareil photo peut fournir des commandes supplémentaires pour permettre à votre application ou aux utilisateurs de spécifier des zones d'une image à utiliser pour déterminer les paramètres de mise au point ou de niveau de luminosité, et de transmettre ces valeurs au matériel de l'appareil photo pour la capture d'images ou de vidéos.

Les zones de mesure et de mise au point fonctionnent de manière très semblable aux autres fonctionnalités de l'appareil photo, dans la mesure où vous les contrôlez via des méthodes dans l'objet Camera.Parameters. Le code suivant montre comment définir deux zones de mesure de la lumière pour une instance de Camera:

// 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
}

// 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);

L'objet Camera.Area contient deux paramètres de données: un objet Rect permettant de spécifier une zone dans le champ de vision de la caméra et une valeur de pondération, qui indique à la caméra le niveau d'importance de cette zone dans les calculs de mesure de la lumière ou de mise au point.

Le champ Rect d'un objet Camera.Area décrit une forme rectangulaire mappée sur une grille d'unités de 2 000 x 2 000 unités. Les coordonnées -1 000 et -1 000 représentent l'angle supérieur gauche de l'image de l'appareil photo, tandis que les coordonnées 1 000 et 1 000 représentent l'angle inférieur droit de l'image, comme illustré ci-dessous.

Figure 1 : Les lignes rouges illustrent le système de coordonnées permettant de spécifier un Camera.Area dans un aperçu d'appareil photo. Le cadre bleu indique l'emplacement et la forme d'une zone de caméra avec les valeurs Rect 333 333 667 667.

Les limites de ce système de coordonnées correspondent toujours au bord extérieur de l'image visible dans l'aperçu de l'appareil photo. Elles ne se réduisent ni ne s'agrandissent en fonction du niveau de zoom. De même, la rotation de l'aperçu de l'image à l'aide de Camera.setDisplayOrientation() ne remappe pas le système de coordonnées.

Détection de visages

Pour les photos sur lesquelles figurent des personnes, les visages constituent généralement la partie la plus importante de l'image. Ils doivent être utilisés pour déterminer à la fois la mise au point et la balance des blancs lors de la prise de vue. Le framework Android 4.0 (niveau d'API 14) fournit des API permettant d'identifier les visages et de calculer les paramètres d'image à l'aide de la technologie de reconnaissance des visages.

Remarque:Lorsque la fonctionnalité de détection de visages est en cours d'exécution, setWhiteBalance(String), setFocusAreas(List<Camera.Area>) et setMeteringAreas(List<Camera.Area>) n'ont aucun effet.

L'utilisation de la fonctionnalité de détection de visages dans l'application Appareil photo nécessite quelques étapes générales:

• Vérifier que l'appareil est compatible avec la détection des visages
• Créer un écouteur de détection de visages
• Ajouter l'écouteur de détection de visages à l'objet Appareil photo
• Lancer la détection des visages après l'aperçu (et après chaque redémarrage de l'aperçu)

La fonctionnalité de détection des visages n'est pas disponible sur tous les appareils. Vous pouvez vérifier que cette fonctionnalité est compatible en appelant getMaxNumDetectedFaces(). Vous trouverez un exemple de cette vérification dans l'exemple de méthode startFaceDetection() ci-dessous.

Pour être averti et répondre à la détection d'un visage, votre application Appareil photo doit définir un écouteur pour les événements de détection de visages. Pour ce faire, vous devez créer une classe d'écouteur qui implémente l'interface Camera.FaceDetectionListener, comme indiqué dans l'exemple de code ci-dessous.

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()}"))
        }
    }
}

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() );
        }
    }
}

Après avoir créé cette classe, définissez-la dans l'objet Camera de votre application, comme indiqué dans l'exemple de code ci-dessous:

camera?.setFaceDetectionListener(MyFaceDetectionListener())

camera.setFaceDetectionListener(new MyFaceDetectionListener());

Votre application doit lancer la fonction de détection des visages chaque fois que vous lancez (ou redémarrez) l'aperçu de l'appareil photo. Créez une méthode permettant de démarrer la détection des visages afin de pouvoir l'appeler si nécessaire, comme indiqué dans l'exemple de code ci-dessous.

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()
        }
    }
}

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();
    }
}

Vous devez lancer la détection des visages chaque fois que vous lancez (ou redémarrez) l'aperçu de l'appareil photo. Si vous utilisez la classe Preview présentée dans Créer une classe Preview, ajoutez la méthode startFaceDetection() aux méthodes surfaceCreated() et surfaceChanged() de votre classe Preview, comme indiqué dans l'exemple de code ci-dessous.

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}")
    }
}

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());
    }
}

Remarque:N'oubliez pas d'appeler cette méthode après avoir appelé startPreview(). N'essayez pas de démarrer la détection des visages dans la méthode onCreate() de l'activité principale de votre application d'appareil photo, car l'aperçu n'est pas disponible à ce stade de l'exécution de votre application.

Vidéo en accéléré

La vidéo en accéléré permet aux utilisateurs de créer des extraits vidéo combinant des images prises à quelques secondes ou minutes d'intervalle. Cette fonctionnalité utilise MediaRecorder pour enregistrer les images d'une séquence en accéléré.

Pour enregistrer une vidéo en accéléré avec MediaRecorder, vous devez configurer l'objet Enregistreur comme si vous enregistriez une vidéo normale, en définissant un faible nombre d'images capturées par seconde et en utilisant l'un des paramètres de qualité du mode Accéléré, comme illustré dans l'exemple de code ci-dessous.

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

// 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

Ces paramètres doivent être définis dans le cadre d'une procédure de configuration plus large pour MediaRecorder. Pour obtenir un exemple de code de configuration complet, consultez la section Configurer MediaRecorder. Une fois la configuration terminée, vous démarrez l'enregistrement vidéo comme si vous enregistriez un extrait vidéo normal. Pour en savoir plus sur la configuration et l'exécution de MediaRecorder, consultez la section Capturer des vidéos.

Les exemples Camera2Video et HdrViewfinder illustrent davantage l'utilisation des API abordées sur cette page.

Champs d'appareil photo nécessitant une autorisation

Les applications fonctionnant sous Android 10 (niveau d'API 29) ou version ultérieure doivent disposer de l'autorisation CAMERA pour accéder aux valeurs des champs suivants renvoyés par la méthode getCameraCharacteristics():

• 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

Exemples de code supplémentaires

Pour télécharger des applications exemples, consultez l'exemple Camera2Basic et l'application exemple officielle de CameraX.