1. Présentation de la classe CameraManager
CameraManager est un gestionnaire de service système pour détecter, caractériser et se connecter à CameraDevices.
CameraManager est un service système chargé d'interroger et d'établir les connexions des caméras. Il a peu de fonctions. Voici quelques fonctions clés de CameraManager :
1) Encapsuler les informations de la caméra dans les caractéristiques de la caméra et fournir un moyen d'obtenir des instances de CameraCharacteristics.
2) Ouvrez l'appareil photo (openCamera) en fonction de l'ID de caméra spécifié.
3) Fournissez un raccourci pour régler le flash en mode lampe de poche.
Context.getSystemService()Une instance de cette classe peut être obtenue en appelant .
Gestionnaire de CameraManager = (CameraManager)getSystemService(Context.CAMERA_SERVICE);
Deuxièmement, la classe intérieure
1. Classe abstraite de rappel de disponibilité
Rappel lorsqu'un appareil photo devient utilisable ou ne peut pas être ouvert.
L'appareil photo devient utilisable lorsqu'il n'est plus utilisé ou lorsqu'un nouvel appareil photo amovible est fixé. Lorsque certaines applications ou certains services commencent à utiliser l'appareil photo, ou lorsque l'appareil photo amovible est déconnecté, ils deviennent indisponibles.
Étendez ce rappel et transmettez une instance de votre sous-classe à {@link CameraManager#registerAvailabilityCallback} pour être informé de ces changements de disponibilité.
Interface de rappel :
/**
La nouvelle caméra est déjà disponible.
L'implémentation par défaut de cette méthode ne fait rien.
Paramètres :
cameraId – Identifiant unique de la nouvelle caméra.
*/
public void onCameraAvailable(@NonNull String cameraId) {
// implémentation vide par défaut
}
/**
Les caméras précédemment disponibles ne sont plus disponibles.
Si une application a une instance CameraDevice active pour une caméra qui est actuellement déconnectée, l'application recevra une erreur de déconnexion.
L'implémentation par défaut de cette méthode ne fait rien.
Paramètres :
cameraId – Identifiant unique de la caméra déconnectée.
*/
public void onCameraUnavailable(@NonNull String cameraId) {
// implémentation vide par défaut
}
/**
Appelé chaque fois que la priorité d'accès à la caméra change.
Notification indiquant que la priorité d'accès à la caméra a changé et que la caméra peut maintenant être allumée. Une application qui a précédemment refusé l'accès à la caméra parce qu'un utilisateur de priorité supérieure utilisait déjà la caméra, ou qui s'est déconnectée d'une session de caméra active parce qu'un utilisateur de priorité supérieure a essayé d'ouvrir la caméra, doit tenter d'ouvrir à nouveau la caméra si elle veut encore l'utiliser. Notez que plusieurs applications peuvent recevoir ce rappel en même temps et qu'une seule d'entre elles réussira réellement à ouvrir la caméra, en fonction de la priorité d'accès et du moment exacts. Cette méthode est utile lorsque plusieurs applications peuvent être reprises en même temps et que l'utilisateur bascule entre elles, ou lorsque l'application utilisant actuellement la caméra passe du plein écran à l'incrustation d'image (PiP). Dans ce cas, le rappel de caméra disponible/indisponible ne sera pas appelé, mais une autre application peut maintenant avoir une priorité d'accès à la caméra plus élevée que l'application qui utilise actuellement la caméra.
L'implémentation par défaut de cette méthode ne fait rien.
*/
public void onCameraAccessPrioritiesChanged() { // implémentation vide par défaut }
/**
La caméra physique est à nouveau disponible.
Par défaut, toutes les machines physiques de la multi-caméra logique sont disponibles, donc lorsque onCameraAvailable de la multi-caméra logique est appelée, onPhysicalCameraAvailable n'est appelée sur aucune machine physique de la multi-caméra logique. Cependant, onPhysicalCameraUnavailable peut être appelé après onCameraAvailable si une caméra physique spécifique n'est pas disponible en premier lieu.
L'implémentation par défaut de cette méthode ne fait rien.
Paramètres :
cameraId - l'identifiant unique de la multi-caméra logique.
physicalCameraId – Identificateur unique de la caméra physique.
*/
public void onPhysicalCameraAvailable(@NonNull String cameraId,
@NonNull String physicalCameraId) {
// implémentation vide par défaut
}
/**
La caméra physique précédemment disponible n'est plus disponible.
Par défaut, toutes les machines physiques de la multi-caméra logique sont disponibles, donc lorsque onCameraAvailable de la multi-caméra logique est appelée, onPhysicalCameraAvailable n'est appelée sur aucune machine physique de la multi-caméra logique. onPhysicalCameraUnavailable peut être appelé après onCameraAvailable si une caméra physique spécifique n'est pas disponible initialement.
L'implémentation par défaut de cette méthode ne fait rien.
Paramètres :
cameraId - l'identifiant unique de la multi-caméra logique.
physicalCameraId – Identificateur unique de la caméra physique.
*/
public void onPhysicalCameraUnavailable(@NonNull String cameraId,
@NonNull String physicalCameraId) {
// implémentation vide par défaut
}
/**
L'appareil photo a été ouvert par l'application.
L'implémentation par défaut de cette méthode ne fait rien.
android.Manifest.permission.CAMERA_OPEN_CLOSE_LISTENER est requis pour recevoir ce rappel
Paramètres :
cameraId – L'identifiant unique de la caméra ouverte.
packageId – ID de package de l'application qui a ouvert la caméra.
*/
@SystemApi
@TestApi
@RequiresPermission(android.Manifest.permission.CAMERA_OPEN_CLOSE_LISTENER)
public void onCameraOpened(@NonNull String cameraId, @NonNull String packageId) {
// implémentation vide par défaut
}
/**
Une caméra précédemment ouverte a été fermée.
L'implémentation par défaut de cette méthode ne fait rien.
android.Manifest.permission.CAMERA_OPEN_CLOSE_LISTENER est nécessaire pour recevoir ce rappel.
Paramètres :
cameraId – identifiant unique de la caméra fermée.
*/
@SystemApi
@TestApi
@RequiresPermission(android.Manifest.permission.CAMERA_OPEN_CLOSE_LISTENER)
public void onCameraClosed(@NonNull String cameraId) {
// implémentation vide par défaut
}
2. Classe abstraite TorchCallback
Rappel pour le mode flash de l'appareil photo devenant indisponible, désactivé ou activé.
Le mode torche devient indisponible lorsque l'appareil photo auquel il appartient n'est pas disponible ou lorsque d'autres ressources de caméra dont il a besoin deviennent occupées en raison d'une autre activité de caméra prioritaire. Le mode torche est désactivé lorsqu'il est éteint ou lorsque l'appareil photo auquel il appartient n'est plus utilisé et que les autres ressources de l'appareil photo dont il a besoin ne sont plus occupées. Lorsque l'application appelle setTorchMode pour désactiver le mode torche de l'appareil photo, ou lorsque l'application active le mode torche d'un autre appareil photo (si plusieurs modes torche ne sont pas pris en charge en même temps), le mode torche de l'appareil photo est désactivé. Lorsque le mode torche est activé par setTorchMode, le mode torche sera activé.
Ne peut être réglé que par setTorchMode lorsque le mode torche est désactivé ou activé.
Étendez ce rappel et transmettez une instance de votre sous-classe à registerTorchCallback pour être informé de ces changements d'état.
/**
Le mode torche de la caméra ne peut pas être défini via setTorchMode.
Si le mode torche a été précédemment activé en appelant setTorchMode, désactivez-le avant d'appeler onTorchModeUnavailable. setTorchMode échouera jusqu'à ce que le mode torche soit désactivé ou réactivé.
L'implémentation par défaut de cette méthode ne fait rien.
Paramètres :
cameraId – Identifiant unique de la caméra pour laquelle le mode torche n'est pas disponible.
*/
public void onTorchModeUnavailable(@NonNull String cameraId) {
// implémentation vide par défaut
}
/**
Le mode torche de la caméra est activé ou désactivé et peut être modifié avec setTorchMode.
L'implémentation par défaut de cette méthode ne fait rien.
Paramètres :
cameraId – L'identifiant unique de la caméra dont le mode torche a été modifié.
activé - L'état dans lequel le mode torche de la caméra a été modifié. Vrai lorsque le mode torche est activé et peut être désactivé. Faux lorsque le mode torche est désactivé et peut être activé.
*/
public void onTorchModeChanged(@NonNull String cameraId, booléen activé) {
// implémentation vide par défaut
}
/**
En mode torche, le niveau de luminosité du flash de l'appareil photo a été modifié avec TurnOnTorchWithStrengthLevel. Ce rappel n'est pas déclenché lorsque la lampe torche est éteinte, même si l'intensité de la lampe torche est réinitialisée à la valeur par défaut
.
Paramètres :
cameraId - Identifiant unique de l'appareil photo dont le niveau de luminosité du flash a été modifié.
newStrengthLevel – Le niveau de luminosité du flash qui a été modifié.
*/
public void onTorchStrengthLevelChanged(@NonNull String cameraId, int newStrengthLevel) {
// implémentation vide par défaut
}
3. Méthode
/**
Obtenez les caractéristiques de la caméra en fonction de l'ID de la caméra et enregistrez les caractéristiques de la caméra dans un objet CameraCharacteristics. Un attribut est représenté sous la forme d'une paire clé-valeur, de sorte que l'objet est une collection de paires clé-valeur.
Interrogez les capacités de l'appareil photo. Ces fonctions sont immuables pour une caméra donnée.
À partir du niveau API 29, cette fonction peut également être utilisée pour interroger les capacités des caméras physiques qui ne peuvent être utilisées que dans le cadre d'une multicam logique. Ces caméras ne peuvent pas être ouvertes directement via openCamera
Également à partir du niveau API 29, alors que la plupart des informations de base sur les caméras sont toujours disponibles même sans l'autorisation CAMERA, certaines valeurs ne sont pas disponibles pour les applications qui ne détiennent pas cette autorisation. CameraCharacteristics.getKeysNeedingPermission répertorie les clés qui ne sont pas disponibles.
Paramètres :
cameraId – ID de l'appareil photo à interroger. Il peut s'agir d'un ID de caméra autonome qui peut être ouvert directement par openCamera, ou d'un ID de caméra physique qui ne peut être utilisé que dans le cadre d'une multicaméra logique.
Renvoie :
propriété de la caméra donnée.
Lance :
IllegalArgumentException - si cameraId ne correspond à aucun périphérique de caméra connu.
CameraAccessException - si l'appareil photo a été déconnecté.
*/
public CameraCharacteristics getCameraCharacteristics(@NonNull String cameraId)
lève CameraAccessException
/**
Interrogez la capacité d'extension de caméra de l'appareil photo.
Paramètres :
cameraId – ID de l'appareil photo à interroger. Il doit s'agir d'un identifiant de caméra indépendant pouvant être ouvert directement par openCamera.
Rturn :
propriété de la caméra donnée
Lance :
IllegalArgumentException - si cameraId ne correspond à aucun appareil photo connu.
CameraAccessException - si l'appareil photo a été déconnecté
*/
public CameraExtensionCharacteristics getCameraExtensionCharacteristics(
@NonNull String cameraId) lève CameraAccessException
/**
Obtenez une liste de caméras, chaque caméra est représentée par un identifiant de type chaîne, et le périphérique de caméra correspondant peut être obtenu ultérieurement via l'identifiant. La liste de tous les identifiants de caméra est stockée dans un tableau String , et le nombre de caméras sur l'appareil n'est que de quelques éléments dans le tableau.
Renvoie une liste des appareils photo actuellement connectés par identifiant, y compris les caméras que d'autres clients de l'API Camera peuvent utiliser.
Les caméras non amovibles utilisent des nombres entiers à partir de 0 comme identifiants, tandis que les caméras amovibles ont des identifiants uniques pour chaque appareil individuel, même s'ils sont du même modèle.
Cette liste n'inclut pas les caméras physiques qui ne peuvent être utilisées que dans le cadre d'un appareil logique multi-caméras.
Retour :
une liste des appareils photo actuellement connectés.
*/
public String[] getCameraIdList() lève CameraAccessException
/**
Similaire à getCameraIdList(). Cependant, getCamerIdListNoLazy() doit communiquer avec cameraserver pour obtenir la liste des ID de caméra. Ceci est pour la commodité des tests, car certains ID de caméra peuvent être "hors ligne" avec les modifications suivantes sans rappels du serveur de caméra pour l'
autorisation SYSTEM_CAMERA (bien qu'il ne s'agisse pas d'une autorisation modifiable, les tests peuvent appeler acquiert(drop)ShellPermissionIdentity() et efficacement modifier ses autorisations). Cet appel affecte également les ID de caméra renvoyés par getCameraIdList(). Les tests avec des ID d'autorité shell ne doivent pas mélanger getCameraIdList() et getCameraListNoLazyCalls().
*/
public String[] getCameraIdListNoLazy() lève CameraAccessException
/**
Renvoie un ensemble combiné d'identificateurs de périphérique de caméra actuellement connectés, prenant en charge la configuration simultanée des sessions de périphérique de caméra.
Les appareils de ces combinaisons peuvent être configurés simultanément par la même application de caméra client. Cependant, il n'est pas garanti que l'utilisation simultanée de ces caméras par deux applications différentes soit prise en charge.
Pour les opérations simultanées, dans l'ordre chronologique : - L'application doit d'abord fermer toutes les caméras ouvertes pour la session configurée à l'aide de CameraDevice.close. - Avant de configurer une session sur n'importe quel appareil photo, tous les appareils photo à utiliser simultanément doivent être ouverts à l'aide d'openCamera.
Chaque appareil de la combinaison est garanti pour prendre en charge la combinaison de flux, qui peut être obtenue en interrogeant la clé CameraCharacteristics.SCALER_MANDATORY_CONCURRENT_STREAM_COMBINATIONS dans getCameraCharacteristics.
Pour les opérations simultanées, si l'appareil photo a une plage de zoom non nulle spécifiée par CameraCharacteristics.CONTROL_ZOOM_RATIO_RANGE, sa plage de zoom complète peut ne pas s'appliquer. Les applications peuvent utiliser CaptureRequest.CONTROL_ZOOM_RATIO >=1 et <= CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM lors d'opérations simultanées.
La composition de l'ensemble peut inclure des dispositifs de caméra qui peuvent être utilisés par d'autres clients d'API de caméra.
Les sessions d'extension de caméra simultanées CameraExtensionSession ne sont pas prises en charge actuellement.
L'ensemble composite ne contient pas de caméras physiques qui ne peuvent être utilisées que dans le cadre d'un appareil logique multi-caméras.
Si un nouvel ID de caméra est disponible via CameraManager.AvailabilityCallback.onCameraUnavailable(String), le client peut appeler cette méthode pour vérifier si une nouvelle combinaison d'ID de caméra est disponible pour la diffusion simultanée.
Rturn :
L'ensemble combiné des appareils photo actuellement connectés, configurant éventuellement simultanément la session. L'ensemble de combinaisons sera vide si le sous-système de caméra ne prend pas en charge de telles combinaisons.
Lancer :
CameraAccessException - si l'appareil photo a été déconnecté.
*/
@NonNull public Set<Set<String>> getConcurrentCameraIds() lève CameraAccessException
/**
Vérifie si l'ensemble de caméras fourni et leur SessionConfiguration correspondante peuvent être configurés en même temps.
Cette méthode effectue une vérification d'exécution sur la combinaison SessionConfiguration et ID de caméra donnée. Le résultat confirme si une session de capture de caméra peut être créée simultanément à l'aide de CameraDevice.createCaptureSession(SessionConfiguration) avec succès sur un appareil photo donné à l'aide de la configuration de session transmise.
Cette méthode peut être appelée à tout moment avant, pendant et après une session de capture d'activité. Cela n'affecte en rien le comportement normal de la caméra et doit être beaucoup plus rapide que la création d'une session de capture régulière ou restreinte.
Bien que cette méthode soit plus rapide que la création d'une nouvelle session de capture, elle n'est pas destinée à être utilisée pour explorer tout l'espace des combinaisons prises en charge de flux simultanés. Les combinaisons de flux simultanés forcés disponibles peuvent être obtenues en interrogeant la clé CameraCharacteristics.SCALER_MANDATORY_CONCURRENT_STREAM_COMBINATIONS dans getCameraCharacteristics.
Notez que les paramètres de session sont ignorés et qu'il n'est pas nécessaire d'appeler SessionConfiguration.setSessionParameters.
Rturn :
vrai si le sous-système de caméra prend en charge la combinaison donnée de la configuration de session et de l'ID de caméra correspondant ; sinon, faux, ou si l'ensemble de caméras fourni n'est pas un sous-ensemble de l'ensemble renvoyé par getConcurrentCameraIds.
Lancer :
CameraAccessException - si l'un des appareils photo interrogés n'est plus connecté.
*/
@RequiresPermission(android.Manifest.permission.CAMERA)
public booléen isConcurrentSessionConfigurationSupported(
@NonNull Map<String, SessionConfiguration> cameraIdAndSessionConfig)
lève CameraAccessException
/**
Renvoie le niveau de luminosité du flash associé à cameraId.
Paramètres :
cameraId - l'identifiant unique de l'appareil photo auquel appartient le flash.
Retour :
Le niveau de luminosité du flash associé à cameraId. Lorsque la lampe de poche est éteinte, le niveau d'intensité est réinitialisé au niveau par défaut CameraCharacteristics.FLASH_INFO_STRENGTH_DEFAULT_LEVEL. Dans ce cas, la valeur de retour sera CameraCharacteristics.FLASH_INFO_STRENGTH_DEFAULT_LEVEL au lieu de 0.
Génère :
CameraAccessException - si le flash n'est pas accessible.
IllegalArgumentException - Si cameraId est null, cameraId ne correspond à aucun appareil photo actuellement ou précédemment disponible, ou l'appareil photo n'a pas de flash.
*/
public int getTorchStrengthLevel(@NonNull String cameraId) lève CameraAccessException
/**
La méthode openCamera() a trois paramètres, le premier paramètre est cameraId, ici l'id de la caméra arrière obtenu à l'étape précédente est utilisé. Le deuxième paramètre est l'objet de rappel du résultat du traitement, qui est le même que l'écouteur dans le mécanisme de traitement des événements. La méthode openCamera() est exécutée de manière asynchrone. Après l'appel, la méthode revient immédiatement et le code suivant continue de s'exécuter. Il faut un certain temps pour renvoyer le résultat indiquant si la caméra a été ouverte avec succès. Après le retour, la méthode correspondante de la objet de rappel est appelé. Le troisième paramètre est le thread qui exécute la méthode de rappel, qui peut être le thread principal ou un thread d'arrière-plan. L'objet de rappel doit être créé avant d'appeler la méthode openCamera().
Ouvre une connexion à la caméra avec l'ID donné.
Utilisez {@link #getCameraIdList} pour obtenir une liste des
appareils photo disponibles. Notez que même si l'identifiant est répertorié, si l'appareil
se déconnecte {@link
#openCamera} entre les appels à {@link #getCameraIdList}, ou si un client d'API d'appareil photo de priorité plus élevée commence à utiliser l'appareil photo.
À partir du niveau d'API 23, un appareil dont le rappel {@link AvailabilityCallback#onCameraUnavailable(String)} est appelé parce que l'appareil est utilisé par un client d'API de caméra d'arrière-plan de priorité inférieure peut toujours être ouvert en appelant cette méthode lors de l'appel du client d'API de caméra A priorité sur le client API de la caméra qui utilise actuellement l'appareil. En général, si l'activité de premier plan de niveau supérieur est en cours d'exécution dans votre processus d'application, votre processus obtiendra la priorité la plus élevée lors de l'accès à la caméra, et cette méthode réussira même si l'appareil photo est utilisé par un autre client API de caméra. Toute application de faible priorité qui perd le contrôle de la caméra de cette manière recevra un rappel {@link android.hardware.camera2.CameraDevice.StateCallback#onDisconnected}. L'ouverture du même identifiant de caméra deux fois dans la même application entraînera également le déclenchement du rappel {@link android.hardware.camera2.CameraDevice.StateCallback#onDisconnected} pour le {@link CameraDevice} lors du premier appel ouvert et de toutes les tâches en cours sera jeté.
Lorsque la caméra est ouverte avec succès, {@link CameraDevice.StateCallback#onOpened} sera appelé avec le {@link CameraDevice} nouvellement ouvert. L'appareil photo peut ensuite être configuré pour fonctionner en appelant {@link CameraDevice#createCaptureSession} et {@link CameraDevice#createCaptureRequest}.
Avant le niveau 30 de l'API, lorsqu'une application tentait d'ouvrir plusieurs {@link CameraDevice} avec différents ID et que l'appareil ne prenait pas en charge l'ouverture d'une telle combinaison, {@link #openCamera} échouait avec une {@link CameraAccessException} ou une One ou plus ouvert {@link CameraDevice} se déconnectera et recevra un rappel {@link android.hardware.camera2.CameraDevice.StateCallback#onDisconnected}. Le comportement qui se produit dépend de l'implémentation de l'appareil et peut varier d'un appareil à l'autre. À partir du niveau d'API 30, si l'appareil ne prend pas en charge
l'ouverture de la combinaison de caméras, il est garanti que l'appel {@link #openCamera} échouera et qu'aucun {@link CameraDevice} existant ne sera déconnecté.
Étant donné que l'appareil photo sera ouvert de manière asynchrone, toutes les opérations asynchrones effectuées sur l'instance CameraDevice renvoyée seront mises en file d'attente jusqu'à ce que le démarrage de l'appareil soit terminé et que la méthode {@link CameraDevice.StateCallback#onOpened onOpened} du rappel soit invoquée. Les opérations en attente sont alors traitées séquentiellement.
Si la caméra est déconnectée pendant l'initialisation après le retour de cet appel de fonction, le {@link CameraDevice.StateCallback#onDisconnected} et le {@link CameraDevice} déconnecté (et {@link CameraDevice.StateCallback#onOpened} seront sautés).
Si l'ouverture de l'appareil photo échoue, la méthode {@link CameraDevice.StateCallback#onError onError} du rappel de l'appareil sera appelée et les appels ultérieurs à l'appareil photo lèveront une {@link CameraAccessException}.
paramètre:
cameraId - L'identifiant unique de l'appareil photo pour ouvrir
le rappel - Le rappel appelé après l'ouverture de la caméra handler
- Le gestionnaire du rappel doit être appelé, ou utiliser le {@link android.os.Looper Looper} du thread actuel.
Lance ：
CameraAccessException - Si la caméra est désactivée par la politique de l'appareil, est déconnectée, est utilisée par un client d'API de caméra de priorité plus élevée, ou l'appareil a atteint ses ressources maximales et ne peut pas ouvrir cet appareil photo.
IllegalArgumentException - si cameraId ou callback est nul, ou cameraId ne correspond à aucun appareil photo actuellement ou précédemment disponible renvoyé par {@link #getCameraIdList}.
SecurityException - si l'application n'est pas autorisée à accéder à la caméra
*/
@RequiresPermission(android.Manifest.permission.CAMERA)
public void openCamera(@NonNull String cameraId,
@NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)
lève CameraAccessException
/**
Définit le mode flash pour une caméra ID donnée sans ouvrir l'appareil photo.
Utilisez getCameraIdList pour obtenir une liste des appareils photo disponibles et utilisez getCameraCharacteristics pour vérifier si un appareil photo a un flash. Notez que même si l'appareil photo est équipé d'un flash, l'activation du mode torche peut échouer si l'appareil photo ou d'autres ressources de l'appareil photo nécessaires pour activer le mode torche sont en cours d'utilisation.
Si l'appel de setTorchMode réussit à activer ou désactiver le mode torche, CameraManager.TorchCallback.onTorchModeChanged sera appelé. Cependant, même si l'activation du mode torche réussit, l'application n'a pas la propriété exclusive du flash ou de l'appareil photo. Lorsque l'appareil photo auquel appartient le flash n'est pas disponible ou que d'autres ressources de l'appareil photo gardant la torche allumée ne sont pas disponibles (CameraManager.TorchCallback.onTorchModeUnavailable sera appelé), le mode torche sera désactivé et deviendra indisponible. En outre, d'autres applications sont libres d'appeler setTorchMode pour désactiver le mode torche (CameraManager.TorchCallback.onTorchModeChanged sera appelé). Si l'application qui a récemment activé le mode torche se ferme, le mode torche s'éteint.
Paramètres :
cameraId - l'identifiant unique de l'appareil photo auquel appartient le flash.
activé – L'état de mode torche souhaité pour le dispositif de caméra cible. Réglez sur true pour activer le mode torche. Réglez sur false pour désactiver le mode torche.
Génère :
CameraAccessException - si le flash n'est pas accessible. Si un appareil photo est en cours d'utilisation, CameraAccessException.CAMERA_IN_USE est levée. CameraAccessException.MAX_CAMERA_IN_USE est levée si d'autres ressources de caméra nécessaires pour activer le mode torche sont en cours d'utilisation. Si le service de caméra n'est pas disponible, CameraAccessException.CAMERA_DISCONNECTED sera lancé.
IllegalArgumentException - Si cameraId est null, cameraId ne correspond à aucun appareil photo actuellement ou précédemment disponible, ou l'appareil photo n'a pas de flash.
*/
public void setTorchMode(@NonNull String cameraId, booléen activé)
lève CameraAccessException
/**
Inscrivez-vous pour recevoir des rappels afin d'être informé de la disponibilité de l'appareil photo.
L'enregistrement à nouveau du même rappel remplacera le gestionnaire par le nouveau fourni.
Lorsque le rappel est enregistré pour la première fois, il est appelé immédiatement et affiche l'état de disponibilité de tous les appareils photo actuellement connus.
CameraManager.AvailabilityCallback.onCameraUnavailable(String) est appelé chaque fois qu'un client API de caméra ouvre le périphérique de caméra. À partir du niveau d'API 23, d'autres clients d'API de caméra peuvent toujours ouvrir de tels appareils photo, et les clients existants seront expulsés s'ils ont une priorité plus élevée que les clients existants de l'appareil photo. Voir open() pour plus de détails.
Étant donné que ce rappel sera enregistré auprès du service de caméra, n'oubliez pas de le désinscrire lorsqu'il n'est plus nécessaire ; sinon le rappel continuera à recevoir des événements indéfiniment et peut empêcher la libération d'autres ressources. Plus précisément, l'appel du rappel sera indépendant du cycle de vie général de l'activité, et également indépendant de l'état de chaque instance de CameraManager.
Paramètres :
callback – le nouveau rappel pour envoyer les notifications de disponibilité de la caméra
handler – le gestionnaire qui doit être invoqué pour le rappel, ou null pour utiliser le looper du thread actuel.
Génère :
IllegalArgumentException - si le gestionnaire est nul mais que le thread actuel n'a pas de zone répétée.
*/
public void registerAvailabilityCallback(@NonNull AvailabilityCallback callback,
@Gestionnaire Nullable Handler)
/**
Supprimez le rappel précédemment ajouté ; le rappel ne recevra plus les rappels de connexion et de déconnexion.
La suppression des rappels non enregistrés n'a aucun effet.
Paramètres :
rappel - rappel pour supprimer de la liste de notification
*/
public void unregisterAvailabilityCallback(@NonNull AvailabilityCallback callback)
/**
Enregistrez un rappel pour être informé de l'état du mode torche.
Cette méthode se comporte de la même manière que registerTorchCallback(CameraManager.TorchCallback, Handler), sauf qu'elle prend un Executor au lieu d'un Handler comme paramètre.
Paramètres :
exécuteur - l'exécuteur qui sera utilisé pour invoquer le rappel
callback - nouveau rappel pour envoyer l'état du mode torche à
Throws :
IllegalArgumentException - si l'exécuteur est nul.
*/
public void registerTorchCallback(@NonNull @CallbackExecutor Exécuteur exécuteur,
@NonNull TorchCallback rappel)
/**
Supprimez le rappel précédemment ajouté ; le rappel ne recevra plus le rappel d'état du mode torche.
La suppression des rappels non enregistrés n'a aucun effet.
Paramètres :
rappel - rappel pour supprimer de la liste de notification
*/
public void unregisterTorchCallback(@NonNull TorchCallback callback)