Aller au contenu

Utilisation de l'appareil photo

Presque tous les appareils informatiques modernes sont dotés d'un appareil photo. Dans ce tutoriel, nous allons écrire une nouvelle application capable de demander l'accès à cet appareil photo, de prendre une photo, puis d'afficher cette photo dans la nouvelle application qui utilise l'appareil photo de votre appareil.

Ce tutoriel ne fonctionne pas sur toutes les plateformes !

Malheureusement, pour l'instant, ce tutoriel ne fonctionne que sur macOS et Android.

Bien que tous les iPhones soient équipés d'une caméra, le Simulateur iOS ne dispose pas d'une caméra fonctionnelle. Les appareils Windows et Linux ont également des caméras, mais Toga n'a actuellement pas la possibilité d'accéder à la caméra sur ces plateformes.

Le code présenté ici fonctionnera sous Windows ou Linux, mais il provoquera une erreur lorsque vous tenterez de prendre une photo.

Le code fonctionnera s'il est exécuté sur un appareil iOS réel, mais ne parviendra pas à prendre une photo s'il est déployé sur le simulateur iOS.

Démarrer un nouveau projet

Pour ce tutoriel, nous n'allons pas construire sur l'application du tutoriel de base - nous allons commencer un nouveau projet. Vous pouvez utiliser le même environnement virtuel que vous avez utilisé dans le premier projet, mais nous devons ré-exécuter l'assistant briefcase new.

Retournez dans le répertoire qui contient le dossier du projet helloworld, et démarrez un nouveau projet nommé "Hello Camera" :

(beeware-venv) $ cd ..
(beeware-venv) $ briefcase new
...
[hellocamera] Generated new application 'Hello Camera'

To run your application, type:

    $ cd hellocamera
    $ briefcase dev

(beeware-venv) $ cd hellocamera

Ajouter un code pour prendre une photo

L'assistant a généré un nouveau projet Toga vide. Nous pouvons maintenant ajouter le code pour prendre et afficher une photo. Modifiez le fichier app.py de la nouvelle application pour qu'il ait le contenu suivant :

import toga
from toga.style.pack import COLUMN, ROW


class HelloCamera(toga.App):
    def startup(self):
        main_box = toga.Box()

        self.photo = toga.ImageView(height=300, margin=5)
        camera_button = toga.Button(
            "Take photo",
            on_press=self.take_photo,
            margin=5,
        )

        main_box.add(self.photo)
        main_box.add(camera_button)

        self.main_window = toga.MainWindow(title=self.formal_name)
        self.main_window.content = main_box
        self.main_window.show()

    async def take_photo(self, widget, **kwargs):
        try:
            if not self.camera.has_permission:
                await self.camera.request_permission()

            image = await self.camera.take_photo()
            if image:
                self.photo.image = image
        except NotImplementedError:
            await self.main_window.dialog(
                toga.InfoDialog(
                    "Oh no!",
                    "The Camera API is not implemented on this platform",
                )
            )
        except PermissionError:
            await self.main_window.dialog(
                toga.InfoDialog(
                    "Oh no!",
                    "You have not granted permission to take photos",
                )
            )


def main():
    return HelloCamera()

Ce code comporte deux changements par rapport à l'application par défaut générée par Briefcase. Ces ajouts sont mis en évidence ci-dessus :

  1. Le premier bloc de code mis en évidence (dans la méthode startup()) ajoute les deux widgets nécessaires pour contrôler la caméra : une ImageView pour afficher une photo et un Button pour déclencher la caméra.
  2. Le deuxième bloc de code mis en évidence (la méthode take_photo()) définit le gestionnaire d'événements lorsque le bouton est enfoncé. Ce gestionnaire confirme d'abord que l'application a l'autorisation de prendre une photo ; si l'autorisation n'existe pas, elle est demandée. Ensuite, une photo est prise. La demande d'autorisation et la demande de prise de photo sont toutes deux des requêtes asynchrones, elles nécessitent donc l'utilisation de await ; pendant que l'application attend que l'utilisateur confirme les autorisations ou prenne la photo, la boucle événementielle de l'application peut continuer en arrière-plan.

Si l'appareil photo réussit à prendre une photo, il retournera un objet Image qui peut être assigné comme contenu du ImageView. Si la demande de photo a été annulée par l'utilisateur, l'appel self.camera.take_photo() retournera None, et le résultat peut être ignoré. Si l'utilisateur ne donne pas la permission d'utiliser la caméra, ou si la caméra n'est pas implémentée sur la plateforme actuelle, une erreur sera levée, et un dialogue sera affiché à l'utilisateur.

Ajout d'autorisations pour les appareils

Une partie du code que nous venons d'ajouter demande la permission d'utiliser l'appareil photo. Il s'agit d'une caractéristique commune aux plateformes d'applications modernes : vous ne pouvez pas accéder aux fonctions matérielles sans demander explicitement la permission à l'utilisateur.

Cependant, cette demande se fait en deux temps. La première se trouve dans le code que nous venons de voir ; mais avant que l'application puisse demander des autorisations, elle doit déclarer les autorisations qu'elle va demander.

Les permissions requises par chaque plateforme sont légèrement différentes, mais Briefcase a une représentation multiplateforme pour de nombreuses permissions matérielles communes. Dans la section de configuration [tool.briefcase.app.hellocamera] du fichier pyproject.toml de votre application, ajoutez ce qui suit (juste au-dessus de la déclaration sources) :

permission.camera = "App will take mugshots."

Elle déclare que votre application doit accéder à l'appareil photo, et fournit une brève description de la raison pour laquelle l'appareil photo est nécessaire. Cette description est nécessaire sur certaines plateformes (notamment macOS et iOS) et sera affichée à l'utilisateur en tant qu'information supplémentaire lors de la présentation de la boîte de dialogue d'autorisation.

Nous pouvons maintenant générer et exécuter l'application :

(beeware-venv) $ briefcase create
(beeware-venv) $ briefcase build
(beeware-venv) $ briefcase run

(beeware-venv) $ briefcase create android
(beeware-venv) $ briefcase build android
(beeware-venv) $ briefcase run android

Lorsque l'application est lancée, un bouton s'affiche. Appuyez sur ce bouton et la boîte de dialogue par défaut de l'appareil photo de la plateforme s'affichera. Prenez une photo ; la boîte de dialogue de l'appareil photo disparaîtra et la photo s'affichera dans l'application, juste au-dessus du bouton. Vous pouvez ensuite prendre une autre photo ; elle remplacera la première.

Ajouter des autorisations supplémentaires

Les permissions sont déclarées dans les fichiers générés lors de l'appel initial à briefcase create. Malheureusement, Briefcase ne peut pas mettre à jour ces fichiers une fois qu'ils ont été générés initialement ; donc si vous voulez ajouter une nouvelle permission à votre application, ou modifier les permissions existantes, vous devrez recréer l'application. Vous pouvez le faire en relançant briefcase create ; cela vous avertira que l'application existante sera écrasée, puis re-générera l'application avec les nouvelles permissions.