From 33058f2b292b3a581333bdfb21b8f671898c5060 Mon Sep 17 00:00:00 2001 From: Peter Bengtsson Date: Tue, 8 Dec 2020 14:40:17 -0500 Subject: initial commit --- files/fr/webapi/browser/index.html | 209 ++++++++++++++ files/fr/webapi/camera/index.html | 23 ++ .../webapi/detecting_device_orientation/index.html | 289 +++++++++++++++++++ files/fr/webapi/idle/index.html | 65 +++++ files/fr/webapi/index.html | 123 ++++++++ files/fr/webapi/mobile_connection/index.html | 151 ++++++++++ files/fr/webapi/network_information/index.html | 89 ++++++ files/fr/webapi/network_stats/index.html | 89 ++++++ files/fr/webapi/pointer_lock/index.html | 319 +++++++++++++++++++++ files/fr/webapi/power_management/index.html | 123 ++++++++ files/fr/webapi/proximity/index.html | 120 ++++++++ .../index.html" | 98 +++++++ files/fr/webapi/websms/index.html | 62 ++++ 13 files changed, 1760 insertions(+) create mode 100644 files/fr/webapi/browser/index.html create mode 100644 files/fr/webapi/camera/index.html create mode 100644 files/fr/webapi/detecting_device_orientation/index.html create mode 100644 files/fr/webapi/idle/index.html create mode 100644 files/fr/webapi/index.html create mode 100644 files/fr/webapi/mobile_connection/index.html create mode 100644 files/fr/webapi/network_information/index.html create mode 100644 files/fr/webapi/network_stats/index.html create mode 100644 files/fr/webapi/pointer_lock/index.html create mode 100644 files/fr/webapi/power_management/index.html create mode 100644 files/fr/webapi/proximity/index.html create mode 100644 "files/fr/webapi/utiliser_les_\303\251v\303\251n\303\251ments_de_luminosit\303\251/index.html" create mode 100644 files/fr/webapi/websms/index.html (limited to 'files/fr/webapi') diff --git a/files/fr/webapi/browser/index.html b/files/fr/webapi/browser/index.html new file mode 100644 index 0000000000..776952894f --- /dev/null +++ b/files/fr/webapi/browser/index.html @@ -0,0 +1,209 @@ +--- +title: Using the Browser API +slug: WebAPI/Browser +tags: + - WebAPI +translation_of: Mozilla/Gecko/Chrome/API/Browser_API/Using +--- +

{{ non-standard_header() }}

+ +

{{ B2GOnlyHeader2('privileged') }}

+ +

Résumé

+ +

L'API HTML Browser (Navigateur HTML) est une extension de l'élément {{HTMLElement("iframe")}} qui permet aux applications d'implémenter des navigateurs ou des applications de navigations. Cela implique deux choses principales :

+ + + +

Il est également possible de communiquer sur le fait que le contenu intégré soit une application web. Dans ce cas, le contenu sera chargé avec le contexte pertinent (comme les permissions).

+ +

Utilisation

+ +

Un élément {{HTMLElement("iframe")}} est transformé en fenêtre de navigateur en utilisant l'attribut {{htmlattrxref("mozbrowser","iframe")}} :

+ +
<iframe src="http://hostname.tld" mozbrowser>
+ +

Afin d'intégrer une application web, il faut également renseigner l'attribut {{htmlattrxref("mozapp","iframe")}}, la valeur sera le chemin vers le manifeste de l'application :

+ +
<iframe src="http://hostname.tld" mozapp='http://chemin/du/manifeste.webapp' mozbrowser>
+ +

Enfin, en utilisant l'attribut {{htmlattrxref("remote","iframe")}} le contenu de l'élément{{HTMLElement("iframe")}} peut être chargé en utilisant uniquement un processus fils qui sera séparé de celui de la page qui contient l'élément {{HTMLElement("iframe")}}.

+ +
<iframe src="http://hostname.tld" mozbrowser remote>
+ +
+

Warning : Ce dernier attribut est indispensable pour des raisons de sécurité lors du chargement de contenu provenant d'une origine inconnue. Si vous ne l'utilisez pas, cela rendra votre application vulnérable aux attaques d'un site web malveillant.

+
+ +

Permissions de l'application

+ +

Chaque application qui souhaite intégrer une fenêtre de navigateur devra avoir la permission browser au sein du manifeste d'application.

+ +
{
+  "permissions": {
+    "browser": {}
+  }
+}
+ +

Si elle souhaite intégrer une application web, l'application hôte devra disposer de la permission embed-apps.

+ +
{
+  "permissions": {
+    "browser": {},
+    "embed-apps": {}
+  }
+}
+ +

Méthodes supplémentaires

+ +

Afin d'être conforme aux spécifications d'un navigateur  {{HTMLElement("iframe")}}, Firefox OS étend l'interface DOM {{domxref("HTMLIFrameElement")}}. Ces nouvelles méthodes permettent d'augmenter les capacités de l'élément  {{HTMLElement("iframe")}} :

+ +

Les méthodes de navigation

+ +

Ces méthodes permettent de naviguer au sein de l'historique de l'élément {{HTMLElement("iframe")}}. Elles sont nécessaires afin d'implémenter les boutons de pages précédentes, suivantes ou le bouton d'actualisation de la page.

+ + + +

Les méthodes liées aux performances

+ +

Ces méthodes sont utilisées pour gérer les ressources utilisées par un navigateur contenu dans un élément {{HTMLElement("iframe")}}. Cela est particulièrement utile lorsqu'il s'agit d'un navigateur utilisant des onglets.

+ + + +

Méthodes liées aux événements

+ +

Afin de gérer le contenu du navigateur {{HTMLElement("iframe")}} il est nécessaire d'introduire de nouveaux événements (voir ci-après). Les méthodes suivantes peuvent être utilisées pour manipuler ces événements :

+ + + +

Méthodes diverses

+ +

Ces méthodes sont des utilitaires destinés aux applications qui conteiennent un navigateur {{HTMLElement("iframe")}}.

+ + + +

Événements

+ +

Afin de permettre à une application de manipuler le navigateur {{HTMLElement("iframe")}}, l'application peut écouter, surveiller les nouveaux événements qui se passent au sein du navigateur  {{HTMLElement("iframe")}}. Il est possible de surveiller les événements suivant :

+ + + +

Exemple

+ +

Dans cet exemple, nous verrons comment implémenter un navigateur intégré de manière simplifiée.

+ +

HTML

+ +

Dans le code HTML, il faut juste ajouter une barre pour la saisie de l'URL, un bouton « Aller à », un bouton « Arrêter » et un élément  {{HTMLElement("iframe")}} pour le navigateur.

+ +
<header>
+  <input id="url">
+  <button id="go">Aller à</button>
+  <button id="stop">Arrêter</button>
+</header>
+
+<iframe src="about:blank" mozbrowser remote></iframe>
+
+ +

CSS

+ +

Il est possible de passer du bouton « Aller à » au bouton « Arrêter »  (et vice versa) en utilisant ce fragment de code CSS :

+ +
button:disabled {
+  display: none;
+}
+ +

JavaScript

+ +

Et maintenant, il faut ajouter les fonctionnalités nécessaires au navigateur :

+ +
document.addEventListener("DOMContentLoaded", function () {
+  var url  = document.getElementById("url");
+  var go   = document.getElementById("go");
+  var stop = document.getElementById("stop");
+
+  var browser = document.getElementsByTagName("iframe")[0];
+
+  // Cette fonction permet de passer entre le bouton "Aller" au bouton "Arreter"
+  // (et vice versa). Si le navigateur charge, le bouton "Aller" est désactivé
+  // et le bouton "Arrêter" est activé. Sinon, on a l'état inverse.
+  function uiLoading(isLoading) {
+      go.disabled =  isLoading;
+    stop.disabled = !isLoading;
+  }
+
+  go.addEventListener("touchend", function () {
+    browser.setAttribute("src", url.value);
+  });
+
+  stop.addEventListener("touchend", function () {
+    browser.stop();
+  });
+
+  // Quand le navigateur charge, on change l'état des boutons "Aller" et "Arrêter"
+  browser.addEventListener('mozbrowserloadstart', function () {
+    uiLoading(true);
+  });
+
+  // Quand le navigateur a fini de charger du contenu,
+  // on change l'état des boutons "Aller" et "Arrêter"
+  browser.addEventListener('mozbrowserloadend', function () {
+    uiLoading(false);
+  });
+
+  // Si jamais il y a une erreur il faut également
+  // changer l'état des boutons "Aller" et "Arrêter"
+  browser.addEventListener('mozbrowsererror', function (event) {
+    uiLoading(false);
+    alert("Erreur de chargement : " + event.detail);
+  });
+
+  // Lorsqu'un utilisateur suit un lien il faut s'assurer que
+  // l'emplacement de la nouvelle page apparaît dans la barre d'URL
+  browser.addEventListener('mozbrowserlocationchange', function (event) {
+    url.value = event.detail;
+  });
+});
+ +

Voir aussi

+ + diff --git a/files/fr/webapi/camera/index.html b/files/fr/webapi/camera/index.html new file mode 100644 index 0000000000..20053d8670 --- /dev/null +++ b/files/fr/webapi/camera/index.html @@ -0,0 +1,23 @@ +--- +title: Camera API +slug: WebAPI/Camera +tags: + - Video + - WebAPI +translation_of: Archive/B2G_OS/API/Camera_API +--- +

{{ ApiRef() }}

+

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('certified') }}

+

L'API Camera permet aux applications de gérer la caméra (ou l'appareil photo) de l'appareil. Cela leur permet de prendre des photos, d'enregistrer des vidéos et d'obtenir des informations concernant le focus, le zoom, la balance des blancs, le flash... Cette API à privilèges ne peut être utilisée que par les applications certifiées.

+
+

Note : Sauf si vous avez l'intention de développer une application remplaçant l'application Caméra/Appareil Photo par défaut, vous ne devriez pas utiliser cette API. Si vous souhaitez simplement accéder à la caméra (ou l'appareil photo) de votre appareil, vous devriez utiliser l'API Web Activities.

+
+

Voir aussi

+ +

 

diff --git a/files/fr/webapi/detecting_device_orientation/index.html b/files/fr/webapi/detecting_device_orientation/index.html new file mode 100644 index 0000000000..63d99497df --- /dev/null +++ b/files/fr/webapi/detecting_device_orientation/index.html @@ -0,0 +1,289 @@ +--- +title: Détecter l'orientation de l'appareil +slug: WebAPI/Detecting_device_orientation +tags: + - Device Orientation + - Firefox OS + - Mobile + - Motion + - Orientation +translation_of: Web/API/Detecting_device_orientation +--- +

{{SeeCompatTable}}

+ +

Résumé

+ +

De plus en plus d'appareils connectés à Internet sont capable de déterminer leur orientation. C'est-à-dire qu'ils peuvent fournir des données indiquant des changements dans leur orientation par rapport à la gravité. En particulier les appareils portables, comme les téléphones mobiles, peuvent utiliser cette information pour effectuer automatiquement une rotation de l'écran, afin de toujours proposer la meilleure disposition possible pour le contenu à afficher.

+ +

Il existe deux événements JavaScript pour gérer l'orientation. Le premier est {{domxref("DeviceOrientationEvent")}}, qui est envoyé quand l'accéléromètre détecte un changement d'orientation de l'appareil. En recevant et en analysant les données fournies par ces événements d'orientation, il est possible de répondre de manière interactive aux changements d'orientation et d'élévation causés par les mouvements imprimés à l'appareil par l'utilisateur.

+ +

Le second événement est {{ domxref("DeviceMotionEvent") }}, qui est envoyé quand un changement d’accélération est ajouté. Il est différent de {{domxref("DeviceOrientationEvent")}}, car il écoute les changements d'accélération par opposition à l'orientation. Parmi les capteurs capables de détecter {{ domxref("DeviceMotionEvent") }}, on trouve les capteurs des ordinateurs portables utilisés pour protéger des chutes les périphériques de stockage. Ils sont communément présents dans les appareils mobiles (tablettes, téléphones intelligents).

+ +

Traitement des événements d'orientation

+ +

Tout ce dont vous avez besoin pour commencer à recevoir les changements d'orientation est d’écouter l’événement {{ event("deviceorientation") }} :

+ +
+

Note: gyronorm.js est un polyfill pour normaliser les données de l'accéléromètre et du gyroscope sur les appareils mobiles. C'est utile pour surmonter certaines différences dans la prise en charge des périphériques pour l'orientation du périphérique.

+
+ +
window.addEventListener("deviceorientation", handleOrientation, true);
+
+ +

Après l’enregistrement de votre gestionnaire d'événements (event listener en anglais), dans ce cas, une fonction JS appelée handleOrientation(), votre fonction d'écoute est appelée périodiquement pour récupérer les données de l'orientation mise à jour.

+ +

L'événement d'orientation contient quatre valeurs ::

+ + + +

La fonction gérant l’événement pourrait ressembler à ceci :

+ +
function handleOrientation(event) {
+  var absolute = event.absolute;
+  var alpha    = event.alpha;
+  var beta     = event.beta;
+  var gamma    = event.gamma;
+
+  // Faites quelque chose avec les données acquises. ;)
+}
+
+ +

Détail des valeurs d'orientation

+ +

La valeur reportée pour chaque axe indique l'angle de rotation autour d'un axe donné, en référence à un système de coordonnées standard. Ces valeurs sont décrites de façon plus détaillée dans cet article Orientation et déplacement expliquée.

+ + + +

Exemple d'orientation

+ +

Cet exemple fonctionne sur tout navigateur supportant l’événement {{event("deviceorientation")}} et sur tout appareil capable de détecter son orientation.

+ +

Imaginons une balle dans un jardin :

+ +
<div class="jardin">
+  <div class="balle"></div>
+</div>
+
+<pre class="resultat"></pre>
+
+ +

Ce jardin fait 200 pixels de long (Oui c'est un « petit » jardin !), et la balle est au centre :

+ +
.jardin {
+  position: relative;
+  width : 200px;
+  height: 200px;
+  border: 5px solid #CCC;
+  border-radius: 10px;
+}
+
+.balle {
+  position: absolute;
+  top   : 90px;
+  left  : 90px;
+  width : 20px;
+  height: 20px;
+  background: green;
+  border-radius: 100%;
+}
+
+ +

Maintenant, on définit le déplacement de la balle en fonction de celui de l'appareil :

+ +
var jardin = document.querySelector('.jardin'),
+    balle = document.querySelector('.balle'),
+    resultat = document.querySelector('.resultat'),
+    maxX = jardin.clientWidth  - balle.clientWidth,
+    maxY = jardin.clientHeight - balle.clientHeight;
+
+function handleOrientation(event) {
+  var x = event.beta,  // En degré sur l'interval [-180,180].
+      y = event.gamma; // En degré sur l'interval [-90,90].
+
+  resultat.innerHTML  = "beta : " + x + "<br />";
+  resultat.innerHTML += "gamma: " + y + "<br />";
+
+  // Parce-que l'on ne veut pas avoir l'appareil à l'envers.
+  // On restreint les valeurs de x à l'intervalle [-90,90].
+  if (x >  90) { x =  90};
+  if (x < -90) { x = -90};
+  // Pour rendre le calcul plus simple.
+  // On délimite l'intervalle de x et y sur [0, 180].
+  x += 90;
+  y += 90;
+
+  // 10 est la moitié de la taille de la balle.
+  // Cela centre le point de positionnement au centre de la balle.
+
+  balle.style.top  = (maxX * x / 180 - 10) + "px";
+  balle.style.left = (maxY * y / 180 - 10) + "px";
+}
+
+window.addEventListener('deviceorientation', handleOrientation);
+
+ +

Et voici le résultat en temps réel :

+ +
{{EmbedLiveSample("Exemple_d'orientation", '230', '260')}}
+ +
 
+ +
{{LiveSampleLink("Exemple_d'orientation", "Cliquez ici")}} pour ouvrir cet exemple dans une nouvelle fenêtre;  l'événement {{event("deviceorientation")}} ne marche pas dans les {{HTMLElement("iframe", "iframes")}} cross-origin dans tous les navigateurs.
+ +
 
+ +
+

Attention : Chrome et Firefox ne gèrent pas les angles de la même façon, certaines directions sur les axes sont inversées.

+
+ +

Traiter les événement de mouvement

+ +

Les événements de mouvement gèrent l'orientation de la même façon à l'exception près qu’ils portent un nom d’événement différent : {{event("devicemotion")}}

+ +
window.addEventListener("devicemotion", handleMotion, true);
+
+ +

Ce qui change réellement est l'information fournie par l'objet {{ domxref("DeviceMotionEvent") }} passée comme paramètre par la fonction HandleMotion.

+ +

Les événements de mouvement contiennent quatre propriétés :

+ + + +

Explication des valeurs de mouvement

+ +

L'objet {{ domxref("DeviceMotionEvent") }} fourni aux développeurs Web des informations sur la vitesse de changement d'orientation et de position de l'appareil. Les changements rapportés sont fournis pour les trois axes (voir Orientation et déplacement expliquées pour les détails).

+ +

Pour {{domxref("DeviceMotionEvent.acceleration","acceleration")}} et {{domxref("DeviceMotionEvent.accelerationIncludingGravity","accelerationIncludingGravity")}}, Les axes correspondent à :

+ + + +

Pour {{domxref("DeviceMotionEvent.rotationRate","rotationRate")}}, c'est un peu différent. L'information correspond à :

+ + + +

Au final, {{domxref("DeviceMotionEvent.interval","interval")}} représente l'intervalle de temps, en millisecondes, pour les données générées par l'appareil.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpécificationStatutCommentaires
{{SpecName('Device Orientation')}}{{Spec2('Device Orientation')}}Spécification initiale.
+ +

Compatibilité des navigateurs

+ +

{{CompatibilityTable()}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FonctionnalitéChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
{{domxref("DeviceOrientationEvent")}}7.03.6[1]
+ 6		{{CompatUnknown()}}{{CompatUnknown()}}{{CompatUnknown()}}
{{domxref("DeviceMotionEvent")}}{{CompatVersionUnknown()}}6{{CompatUnknown()}}{{CompatUnknown()}}{{CompatUnknown()}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FonctionnalitéAndroidFirefox Mobile (Gecko)IE PhoneOpera MobileSafari Mobile
{{domxref("DeviceOrientationEvent")}}3.03.6[1]
+ 6		{{ CompatNo() }}{{ CompatNo() }}4.2
{{domxref("DeviceMotionEvent")}}{{ CompatVersionUnknown() }}6{{ CompatUnknown() }}{{ CompatUnknown() }}{{ CompatUnknown() }}
+
+ +

Notes d'implementation pour Gecko 

+ +
    +
  1. Firefox 3.6, 4, et 5 supportent mozOrientation au lieu de l'événement standard {{domxref("DeviceOrientationEvent")}}.
    2. +
+ +

Voir aussi

+ + diff --git a/files/fr/webapi/idle/index.html b/files/fr/webapi/idle/index.html new file mode 100644 index 0000000000..1679ac97f7 --- /dev/null +++ b/files/fr/webapi/idle/index.html @@ -0,0 +1,65 @@ +--- +title: Idle API +slug: WebAPI/Idle +translation_of: Archive/B2G_OS/API/Idle_API +--- +
+ {{non-standard_header}} {{B2GOnlyHeader2('certified')}}
+

Summary

+

L'API Idle est utilisée pour notifier une application lorsque l'utilisateur est inactif. Cela permet à une application d'intervenir lorsque l'utilisateur ne fait rien avec son appareil. Le cas d'utilisation le plus courant consiste à économiser la batterie; dans ce cas, Il est couramment utilisé en conjonction avec le Power Management API.

+

Surveiller un utilisateur inactif

+

Quand une application veut être averti de l'inactivité du système, elle doit inscrire un idle observer. Un idle observer est un objet composé de trois propriétés :

+ +

Exemple: diminuer la luminosité de l'écran lorsque l'utilisateur est inactif

+

Dans cet exemple, un observateur idle est mis en place pour réduire la luminosité de l'écran à 50 % lorsque l'utilisateur est inactif pendant 10 secondes et le restaurer à 100 % lorsque l'utilisateur est de nouveau actif. Un deuxième observateur est mis en place pour éteindre l'écran lorsque l'utilisateur est inactif pendant au moins 15 secondes.

+
// REMARQUE: mozPower fait partie de l'API de gestion de puissance (Power Management API)
+
+var fadeLight = {
+  time: 10, // 10 secondes
+
+  onidle: function () {
+    // L'utilisateur ne semble pas actif, nous allons diminuer la luminosité de l'écran
+    navigator.mozPower.screenBrightness = 0.5;
+  },
+
+  onactive: function () {
+    // OK, l'utilisateur est de retour, nous allons ré-éclairer l'écran
+    navigator.mozPower.screenBrightness = 1;
+  }
+}
+
+var screenOff = {
+  time: 15, // quinze seconds
+
+  onidle: function () {
+    // OK, l'utilisateur a eu sa chance, mais il est vraiment inactif, nous allons désactiver l'écran
+    navigator.mozPower.screenEnabled = false;
+  },
+
+  onactive: function () {
+    // OK, l'utilisateur est de retour, nous allons allumer l'écran
+    navigator.mozPower.screenEnabled = true;
+  }
+}
+
+// Enregistrer les observateurs inactifs
+
+navigator.addIdleObserver(fadeLight);
+navigator.addIdleObserver(screenOff);
+
+

Ce code définit deux objets idle observer : fadeLight et screenOff, puis appelle {{domxref("window.navigator.addIdleObserver","navigator.addIdleObserver()")}} une fois pour chacun d'eux afin de les enregistrer dans le système. Les applications peuvent mettre en place autant d'observateurs inactif que nécessaire.

+

Si l'application n'a plus besoin de surveiller l’inactivité de l'utilisateur, il peut enlever les observateurs en appelant la méthode {{domxref("window.navigator.removeIdleObserver","navigator.removeIdleObserver()")}}, comme indiqué ci-dessous :

+
navigator.removeIdleObserver(fadeLight);
+navigator.removeIdleObserver(screenOff);
+
+

Spécification

+

Ne fait partie d'aucune spécification pour le moment ; cependant, cette API sera discutée au W3C dans le cadre de la System Applications Working Group.

+

Voir aussi

+ diff --git a/files/fr/webapi/index.html b/files/fr/webapi/index.html new file mode 100644 index 0000000000..63cb0a8ed1 --- /dev/null +++ b/files/fr/webapi/index.html @@ -0,0 +1,123 @@ +--- +title: WebAPI +slug: WebAPI +tags: + - Portail +translation_of: Web/API +--- +

Le terme WebAPI permet de regrouper différentes API permettant d'accéder aux composants ou aux caractéristiques des appareil (comme la batterie, les vibrations...). Elles permettent aussi d'accéder aux informations enregistrées sur l'appareil (liste de contacts, agenda...). En créant ces API, nous espérons offrir de nouvelles possibilités au Web, jusqu'a présent réservées aux plates-formes propriétaires.

+ +
+

Note : La documentation semble légère sur le sujet : il n'en est rien. Beaucoup de documents ont été écrits et des liens sont en train d'être ajoutés. Nous travaillons beaucoup à améliorer cela, de nombreux articles apparaîtront très prochainement. Vous pouvez consulter la page de l'état de documentation sur WebAPI qui récapitule le travail fait sur la documentation WebAPI.

+
+ +
+

Note : Pour obtenir des explications rapides sur chaque badge, consultez la documentation sur les applications .

+
+ +
+
+

Les API de Communication

+ +
+
Bluetooth
+
L'API WebBluetooth permet d'accéder, à un bas niveau, aux fonctionnalités Bluetooth de l'appareil.
+
Mobile Connection API {{NonStandardBadge}}
+
Cette API permet de connaître les informations concernant la connexion : force du signal, informations sur l'opérateur ...
+
Network Information API
+
Cette API fournit des informations de bases sur la connexion réseau utilisée (la vitesse de connexion entre autres).
+
Network Stats API {{NonStandardBadge}}
+
Cette API enregistres des données sur l'utilisation des données réseaux et fournit cette information aux applications disposant des privilèges nécessaires.
+
Telephony {{NonStandardBadge}}
+
Cette API permet aux applications d'interagir avec les appels téléphoniques en utilisant l'interface utilisateur.
+
WebSMS {{NonStandardBadge}}
+
Cette API permet aux applications d'envoyer/recevoir des SMS et d'accéder aux messages enregistrés dans l'appareil.
+
WiFi Information API {{NonStandardBadge}}
+
Cette API est un API avec privilèges permettant de fournir des informations liées au WiFi : réseau utilisé, force du signal, réseaux disponibles...
+
+ +

Les API Matériel

+ +
+
Ambient Light Sensor API
+
Cette API fournit un accès au capteur de lumière environnante. Cela permet à l'application de connaître la luminosité présente autour de l'appareil.
+
Battery Status API
+
Cette API fournit des informations sur la batterie (niveau de la charge, savoir si l'appareil est en cours de charge...).
+
Camera API {{NonStandardBadge}}
+
Cette API permet aux applications de prendre des photos et/ou d'enregistrer des vidéos en utilisant l'appareil photo et/ou la caméra.
+
Geolocation API
+
Cette API fournit des informations sur la position géographique de l'appareil.
+
Pointer Lock API
+
Cette API permet aux applications de verrouiller l'accès du pointeur (de la souris) et d'accéder aux déplacements (relatifs) et non aux coordonnées absolues. Cela est particulièrement utile pour les jeux.
+
Power Management API {{NonStandardBadge}}
+
Cette API permet aux application d'allumer ou d'éteindre l'écran, le processeur, de connaître la puissance de l'appareil, le processeur... Elle permet aussi de surveiller (écoute et inspection) les événements de verrouillage des ressources (resources lock).
+
Proximity API
+
Cette API permet aux applications de détecter si quelque chose est à proximité de l'appareil (par exemple le visage de l'utilisateur).
+
Device Orientation API
+
Cette API permet d'envoyer des notifications lorsque l'appareil change d'orientation.
+
Screen Orientation API
+
Cette API permet d'envoyer des notifications lorsque l'écran change d'orientation. Il est aussi possible d'utiliser cette API pour permettre à l'API d'indiquer l'orientation à utiliser par l'application.
+
Vibration API
+
Cette API permet aux applications de contrôler les vibrations de l'appareil. Cela peut permettre de faire vibrer l'appareil pendant un jeu par exemple. Cette API n'est pas conçue pour provoquer des vibrations de notifications (dans ce cas il faut utiliser l'API Alarm).
+
Voir tout...
+
+
+ +
+

Les API de gestion des données

+ +
+
FileHandle API
+
Cette API permet d'interagir avec les fichiers en écriture tout en gérant les options de verrouillages.
+
IndexedDB
+
Permet de stocker des informations côté client et fournit un support pour effectuer des recherches de manière performante. Ces documents doivent être déplacés.
+
Settings API {{NonStandardBadge}}
+
Cette API permet aux applications de connaître et de modifier les options liées à la configuration du système, enregistrées de manière permanente dans l'appareil.
+
+ +

Les autres API

+ +
+
Alarm API
+
Cette API permet aux applications de planifier des notifications. Elle offre également  la possibilité de lancer une application de manière automatique à un moment donné.
+
Apps API {{NonStandardBadge}}
+
Cette API d'applications web offre la possibilité de gérer et d'installer des applications web. Cette API permet aussi aux applications de définir les informations liées au paiement.
+
Browser API {{NonStandardBadge}}
+
Cette API offre la possibilité de construire un navigateur web en n'utilisant que des technologies Web (et donc un navigateur dans un navigateur).
+
+ +
+
Idle API
+
Cette API permet aux applications de recevoir des notifications, notamment lorsque l'utilisateur n'est pas en train d'utiliser l'appareil.
+
Permissions API {{NonStandardBadge}}
+
Cette API permet de gérer les autorisations des applications au sein d'un même endroit. Elle est utilisée par l'application Réglages.
+
Simple Push API
+
Cette API permet à la plate-forme d'envoyer des messages de notifications à certaines applications en particulier.
+
Time/Clock API {{NonStandardBadge}}
+
Cette API offre la possibilité de régler l'heure. Le fuseau horaire est lui réglé avec l' API Settings.
+
Web Activities {{NonStandardBadge}}
+
Cette API permet à une application de déléguer une activité à une autre application. Un application peut, par exemple, demander à une autre application de sélectionner (ou de créer) une photo et de la renvoyer à la première application. C'est généralement l'utilisateur qui sera capable de configurer la façon dont les applications seront choisies.
+
+ +

La communauté WebAPI

+ +

Si vous souhaitez avoir de l'aide concernant ces API, il y a plusieurs moyens d'échanger avec les autres développeurs.

+ +
    +
  • Le forum WebAPI : {{DiscussionList("dev-webapi", "mozilla.dev.webapi")}}
    • +
  • Le canal IRC WebAPI : #webapi
    • +
+ +

N'oubliez pas la netiquette...

+ + + +
    +
  • Le Document Object Model (DOM), représentant la structure du document HTML comme un arbre
    • +
  • JavaScript - Langage de script largement utilisé sur le Web.
    • +
  • Doc status: Une liste de sujets en lien avec WebAPI ainsi que l'état de leur documentation
    • +
+
+
+ +

 

diff --git a/files/fr/webapi/mobile_connection/index.html b/files/fr/webapi/mobile_connection/index.html new file mode 100644 index 0000000000..b815442da0 --- /dev/null +++ b/files/fr/webapi/mobile_connection/index.html @@ -0,0 +1,151 @@ +--- +title: Mobile Connection +slug: WebAPI/Mobile_Connection +tags: + - WebAPI +translation_of: Archive/B2G_OS/API/Mobile_Connection_API +--- +

{{ draft }}

+

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('certified') }}

+

Résumé

+

Cette API a été conçue pour 2 choses :

+ +

Cette API peut donc accéder à des fonctionnalités qui pourront avoir un impact sur l'abonnement de l'utilisateur (certaines fonctionnalités seront payantes ou pourront endommager l'ICC) : elle est donc limitée aux applications certifiées.

+

Le point d'entrée de cette API est la propriété {{domxref("window.navigator.mozMobileConnection","navigator.mozMobileConnection")}} , cette propriété est une instance de l'interface {{domxref("MozMobileConnection")}}.

+

État de la connexion mobile

+

L'état de la connexion mobile se partage en deux. D'un côté, la connexion voice et de l'autre la connexion data. Les données relatives à chaque type de connexion sont accessibles à travers les propriétés {{domxref("MozMobileConnection.voice")}} et {{domxref("MozMobileConnection.data")}} qui renvoient toutes les deux un objet {{domxref("MozMobileConnectionInfo")}}.

+

Ces objets donnent accès à toutes les informations liées à la qualité du réseau (la force du signal, la qualité du signal, la position des cellules réseau, la restriction de l'usage, les données en itinérance, etc.), et à l'opérateur réseau.

+
var cnx = navigator.mozMobileConnection;
+
+console.log("L'opérateur voix est :" + cnx.voice.network.longName);
+
+if (cnx.voice.connected) {
+  console.log("La force du signal est :" + (+cnx.voice.relSignalStrength) + "%");
+} else {
+  console.log("L'état de la connexion est : " + cnx.voice.state);
+}
+
+

Les fonctionnalités ICC

+

Les fonctionnalités offertes par l'ICC peuvent se ranger dans deux catégories :  la gestion de l'ICC même ou l'utilisation des commandes disponibles et intégrées au sein de STK (SIM Application Toolkit).

+

Les actions de base

+

Le {{domxref("MozMobileConnection")}} fournit un ensemble de méthodes pour gérer les différents comportements des cartes ICC.

+
+

Note : L'ensemble des méthodes de l'interface MozMobileConnection sont intégralement asynchrones. Elles renvoient toutes un objet {{domxref("DOMRequest")}} qui possède les gestionnaires d'événements onsuccess et onerror afin de gérer les succès ou échecs suite à l'appel de la méthode.

+
+

Verrouillage de la carte

+

Tant que la carte est verrouillée, un utilisateur sera incapable de l'utiliser pour atteindre le réseau mobile. Il est possible de gérer le verrouillage de la carte avec les méthodes {{domxref("MozMobileConnection.getCardLock","getCardLock()")}}, {{domxref("MozMobileConnection.setCardLock","setCardLock()")}} et {{domxref("MozMobileConnection.unlockCardLock","unlockCardLock()")}}.

+

Si le {{domxref("MozMobileConnection.getCardLock","getCardLock()")}} permet d'obtenir certaines informations précises sur le verrouillage, il est également possible d'avoir des informations plus concises sur le verrouillage grâce à {{domxref("MozMobileConnection.cardState")}} qui renvoie une chaîne de caractères représentant l'état actuel du verrouillage.

+
+

Note : Même dans le cas où les requêtes ont réussi, cela ne signifie pas forcément que les opérations aient été réussies. C'est pourquoi les changements d'état de la carte sont suivis grâce à des événements indépendants :

+ +
+
var cnx = navigator.mozMobileConnection;
+
+function unlockCard() {
+  var unlockOptions = {
+    lockType: "pin",
+    pin     : prompt("Veuillez saisir votre PIN")
+  }
+
+  var unlock = cnx.unlockCardLock(unlockOptions);
+
+  unlock.onsuccess = function () {
+    console.log("Le code PIN a bien été reçu.");
+
+    if (this.result.success === false) {
+      if (this.result.retryCount > 0) {
+        console.log("Vous avez fait une faute dans votre code PIN : " + this.result.retryCount + " essais restants.");
+      } else {
+        console.log("Votre carte est vérrouillée, vous devez contact votre opérateur afin de recevoir un code de déblocage.");
+      }
+    }
+  }
+
+  unlock.onerror = function () {
+    console.log("Il y a eu un problème !")
+  }
+}
+
+cnx.addEventListener('icccardlockerror', function () {
+  // S'il y a une erreur, demander à l'utilisateur de resaisir le code PIN
+  unlockCard();
+});
+
+cnx.addEventListener('cardsatechange', function () {
+  // Dans le cas où l'état de la carte change et nécessite un dévérouillage
+  if (cnx.cardState === 'pinRequired') {
+    unlockCard();
+  }
+}
+
+// Le premier appel à unlockCard s'il est nécessaire
+if (cnx.cardState === 'pinRequired') {
+  unlockCard();
+}
+
+

Les messages MMI

+

Un message MMI est un code, lisible par les humains, qui, une fois tapé avec le clavier du téléphone, déclenche une action spécifique depuis le RIL ou d'obtenir une réponse depuis le réseau via une requête USSD. Un exemple : taper un code pour obtenir le numéro IMEI du téléphone.

+

De tels messages sont envoyés en utilisant la méthode  {{domxref("MozMobileConnection.sendMMI()")}} (et peuvent être annulés avec {{domxref("MozMobileConnection.cancelMMI","cancelMMI()")}}). Même si la réponse sera un objet {{domxref("DOMRequest")}}, la réponse à un tel message pourra être gérée de deux manières :

+ +
var cnx = navigator.mozMobileConnection;
+
+cnx.addEventHandler('ussdreceived', function (evt) {
+  console.log('Message réseau : ' + evt.data.message);
+});
+
+var MMIRequest = cnx.sendMMI(prompt('Provide a valid MMI'));
+
+MMIRequest.onerror = function() {
+  console.log("Il y a eu un problème...");
+}
+
+

Options de renvoi d'appels

+

Les options de renvoi d'appels permettent de définir la façon dont un appel peut, ou non, être transféré vers un autre numéro de téléphone.

+

Ces options sont gérées par les méthodes {{domxref("MozMobileConnection.getCallForwardingOption","getCallForwardingOption()")}} et {{domxref("MozMobileConnection.setCallForwardingOption","setCallForwardingOption()")}} .

+
var options = {
+  action      : MozMobileCFInfo.CALL_FORWARD_ACTION_ENABLE,
+  reason      : MozMobileCFInfo.CALL_FORWARD_REASON_UNCONDITIONAL,
+  serviceClass: MozMobileConnectionInfo.ICC_SERVICE_CLASS_VOICE,
+  number      : prompt('À quelle numéro doit être transféré l appel ?'),
+  timeSeconds : 5
+};
+
+var setOption = navigator.mozMobileConnection.setCallForwardingOption(options);
+
+setOption.onsuccess = function () {
+  console.log('Options paramétrées avec succès');
+}
+
+setOption.onerror = function () {
+  console.log('Impossible de paramétrer les options : ' + this.error.name);
+}
+
+

Commandes STK

+

Les commandes STK dépendent de plusieurs facteurs (opérateur, modèle de puces...) mais sont toujours accessibles via la propriété {{domxref("MozMobileConnection.icc")}} qui renverra un objet {{domxref("MozIccManager")}}.

+
+

Avertissement : Il est recommandé de n'utiliser les commandes STK uniquement si vous êtes parfaitement conscient de ce que vous faites. En effet, cela peut endommager la puce électronique et la rendre inutilisable.

+
+

Spécification

+

Cette API n'appartient à aucune spécification.

+

Voir aussi

+ diff --git a/files/fr/webapi/network_information/index.html b/files/fr/webapi/network_information/index.html new file mode 100644 index 0000000000..076718cbcc --- /dev/null +++ b/files/fr/webapi/network_information/index.html @@ -0,0 +1,89 @@ +--- +title: Network Information API +slug: WebAPI/Network_Information +tags: + - WebAPI +translation_of: Web/API/Network_Information_API +--- +

{{ SeeCompatTable() }}

+ +

L'API Network Information (Informations réseau) fournit des informations sur la connexion de l'appareil : la bande-passante, si la connexion est mesurée ou non. Elle peut être utilisée pour choisir entre du contenu en haute définition ou en basse définition selon la connexion de l'utilisateur. L'API ne représente qu'un seul objet, ajouté au DOM : {{domxref("window.navigator.connection")}}.

+ +

Exemples

+ +

Détecter les changements de connexion

+ +

Cet exemple permet de connaître les changements liés à la connexion d'un utilisateur. Cela ressemble notamment à la façon dont une application saura si l'utilisateur passe d'une connexion coûteuse à une autre connexion moins chère et pourra réduire la demande de bande passante afin de réduire les coûts pour l'utilisateur.

+ +
var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+
+function updateConnectionStatus() {
+  alert("Bande passante de la connexion : " + connection.bandwidth + " MB/s");
+  if (connection.metered) {
+    alert("La connexion est mesurée !");
+  }
+}
+
+connection.addEventListener("change", updateConnectionStatus);
+updateConnectionStatus();
+
+ +

Préchargement de ressources gourmandes

+ +

L'objet connexion est pratique pour décider de précharger des ressources nécessitant une grosse quantité de bande passante ou de mémoire. Cet exemple devra être appelé après que la page ait été chargé. Il détermine si précharger la vidéo est judicieux selon le type de la connexion. Si une connexion cellulaire est trouvée, alors preloadVideo est réglé à faux. Ici pour faire simple, on ne teste qu'un type de connexion; dans un cas réel on aurait plutôt utilisé une structure de contrôle switch ou une autre méthode pour avoir tout les cas possibles de {{domxref("NetworkInformation.type")}}. Malgré la valeur type, on peut avoir une estimation de la vitesse de la connexion à travers la propriété {{domxref("NetworkInformation.effectiveType")}}.

+ +
let preloadVideo = true;
+var connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+if (connection) {
+  if (connection.effectiveType === 'cellular') {
+    preloadVideo = false;
+  }
+}
+ +

Interfaces

+ +
+
{{domxref("NetworkInformation")}}
+
Fournit des informations sur la connexion de l'appareil et fournit la possibilité aux scriptes d'être informé en cas de changement. L'interface NetworkInformation ne peut pas être instanciée; à la place on y accède à travers l'interface {{domxref("Navigator")}}.
+
+ +

Spécification

+ + + + + + + + + + + + + + + + +
SpécificationStatusCommentaire
{{SpecName('Network Information', '', 'Network Information API')}}{{Spec2('Network Information')}}Spécification initiale
+ +

Compatibilité des navigateurs

+ +

NetworkInformation

+ + + +

{{Compat("api.NetworkInformation")}}

+ + + + + +

{{Compat("api.Navigator.connection")}}

+ +

Voir aussi

+ + diff --git a/files/fr/webapi/network_stats/index.html b/files/fr/webapi/network_stats/index.html new file mode 100644 index 0000000000..363d5ca3fe --- /dev/null +++ b/files/fr/webapi/network_stats/index.html @@ -0,0 +1,89 @@ +--- +title: Network Stats +slug: WebAPI/Network_Stats +tags: + - WebAPI +translation_of: Archive/B2G_OS/API/Network_Stats_API +--- +

{{ draft }}

+

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('certified') }}

+

Résumé

+

L'API Network Stats (statistiques réseaux) permet de surveiller l'utilisation des données et de fournir ces informations aux applications disposant des privilèges nécessaires.

+

On peut accéder aux données grâce à {{domxref("window.navigator.mozNetworkStats","navigator.mozNetworkStats")}} qui est une instance de l'interface {{domxref("MozNetworkStatsManager")}}.

+

Accès aux données

+

Les informations concernant le volume de données envoyé/reçu est automatiquement enregistré par le système. On peut y accéder avec la méthode {{domxref("MozNetworkStatsManager.getNetworkStats()")}}. Cette méthode prend un objet de configuration comme premier paramètre, celui-ci doit contenir les propriétés suivantes :

+ +

Lorsqu'elle est appelée, cette méthode renvoie un objet {{domxref("DOMRequest")}} permettant de savoir si la requête d'informations a réussi ou échoué. Si elle a réussi, le résultat de la requête, result, est un objet {{domxref("MozNetworkStats")}}.

+
var manageWifi   = navigator.mozNetworkStats.connectionTypes.indexOf('wifi')   > -1;
+var manageMobile = navigator.mozNetworkStats.connectionTypes.indexOf('mobile') > -1;
+
+var config = {
+  start: new Date(),
+  end  : new Date(),
+  connectionType: manageWifi ? 'wifi' : null
+};
+
+var request = navigator.mozNetworkStats.getNetworkStats(config);
+
+request.onsuccess = function () {
+  console.log("Données reçues : " + request.result.data[0].rxBytes + " bytes");
+  console.log("Données envoyées : " + request.result.data[0].txBytes + " bytes")
+}
+
+request.onerror = function () {
+  console.log("Il y a eu un problème : ", request.error);
+}
+
+

Échantillonage temporel

+

Afin de voir comment évolue l'utilisation des données au cours du temps, on stocke l'information sous forme de morceaux. Chaque morceau de données représente la quantité de données échangées depuis l'enregistrement du précédent morceau.

+

Lorsqu'une requête est faite pour obtenir ces statistiques, un objet {{domxref("MozNetworkStats")}} est envoyé qui contient autant de « morceaux » que possible pour l'intervalle start-end.  Le nombre total de morceaux dépend de deux paramètres (ces paramètres sont en lecture seule) :

+ +

Chaque morceau de données est un objet {{domxref("MozNetworkStatsData")}} et tous les morceaux de données d'un moment donné sont accessibles via la propriété {{domxref("MozNetworkStats.data")}}. Cette propriété est un Array d'objets {{domxref("MozNetworkStatsData")}}.

+
var rate = navigator.mozNetworkStats.sampleRate;
+var max  = navigator.mozNetworkStats.maxStorageSample;
+
+var config = {
+  start: new Date() - (rate * max), // Cela permet d'obtenir tous les morceaux de données disponibles.
+  end  : new Date(),
+  connectionType: 'mobile'
+};
+
+var request = navigator.mozNetworkStats.getNetworkStats(config);
+
+request.onsuccess = function () {
+  var total = {
+    receive: 0,
+    send   : 0
+  };
+
+  this.result.forEach(function (chunk) {
+    total.receive += chunk.rxBytes;
+    total.send    += chunk.txBytes;
+  });
+
+  console.log("Depuis : " + config.start.toString());
+  console.log("Données reçues : " + (total.receive * 1000).toFixed(2) + "Ko");
+  console.log("Données envoyées : " + (total.send * 1000).toFixed(2) + "Ko")
+}
+
+request.onerror = function () {
+  console.log("Il y a eu un problème : ", request.error);
+}
+

Spécification

+

Cette API ne fait partie d'aucune spécification.

+

Voir aussi

+ diff --git a/files/fr/webapi/pointer_lock/index.html b/files/fr/webapi/pointer_lock/index.html new file mode 100644 index 0000000000..e3d6ea14f3 --- /dev/null +++ b/files/fr/webapi/pointer_lock/index.html @@ -0,0 +1,319 @@ +--- +title: Pointer Lock API +slug: WebAPI/Pointer_Lock +tags: + - API + - Avancé + - Jeux + - Reference + - mouse lock + - pointer lock +translation_of: Web/API/Pointer_Lock_API +--- +
{{DefaultAPISidebar("Pointer Lock API")}}
+ +

Pointer lock (en français Verrouillage du pointeur, précedement appelé mouse lock) permet d'obtenir des informations sur le déplacement de la souris à travers le temps, et ne se cantonne pas à fournir la position absolue du curseur sur l'écran. Cette interface donne accès aux données brutes de la souris, permet de verrouiller la cible des évènements à un élément unique, limiter jusqu'où le mouvement de la souris peut aller dans une direction donnée et cacher le curseur de la vue.
+
+ Cette API est utile pour les applications qui ont besoin d'écouter la souris pour contrôler des mouvements ou faire pivoter des objets sur leurs axes. Les jeux 3D de type FPS (First Person Shooter), les outils de modelisation, les vidéos immersives ou encore les cartes satellites sont autant de candidats idéals. L'utilisateur peut en effet changer l'angle de vue en bougeant simplement sa souris et sans cliquer sur aucun bouton ce qui les laisse donc disponibles pour effectuer d'autres actions.
+
+ Comme Pointer lock continue de déclencher des évènements même quand le curseur est en dehors des limites du navigateur ou de l'écran, les joueurs peuvent cliquer sur les boutons et déplacer le curseur de la souris sans se soucier de quitter la zone de jeu et de cliquer accidentellement sur une autre application qui changerait le focus de la souris en dehors du jeu.

+ +

Concepts de base

+ +

Pointer Lock partage des similtudes avec la capture de souris. La capture de souris offre un flot ininterrompu d'évènements sur un élément cible quand la souris glisse mais s'arrête quand le bouton est relaché. Pour cette raison, Pointer lock diffère de la capture de souris sur les points suivants :

+ + + +

Vue d'ensemble des méthodes/propriétées

+ +

Cette section fournit une brève description de chaque propriété et méthode associée à la spécification de Pointer Lock.

+ +

requestPointerLock()

+ +

L'API Pointer lock, de manière similaire à l'API Fullscreen, étend les les éléments DOM en ajoutant une nouvelle méthode, {{domxref("Element.requestPointerLock","requestPointerLock()")}}. Comme le préfixe fournisseur a récemment été retiré, vous devriez utiliser la syntaxe ci-dessous, par exemple pour demander un verrouillage deu pointeur sur un élément canvas:

+ +
canvas.requestPointerLock = canvas.requestPointerLock ||
+                            canvas.mozRequestPointerLock ||
+                            canvas.webkitPointerLockElement;
+
+canvas.requestPointerLock()
+ +

pointerLockElement et exitPointerLock()

+ +

L'API Pointer Lock étend également l'interface {{domxref("Document")}}, ajoutant à la fois une nouvelle propriété et une nouvelle méthode. La propriété {{domxref("Document.pointerLockElement","pointerLockElement")}}  est utilisée pour accéder à l'élément actuellement verrouillé (s'il y en a). La méthode {{domxref("Document.exitPointerLock","exitPointerLock()")}}  est utilisée pour libérer le verrou du pointeur.

+ +

La propriété {{domxref("Document.pointerLockElement","pointerLockElement")}}  est utile pour déterminer si un élément est actuellement verrouillé (pour une vérification booléenne par exemple) et également pour obtenir une référence vers l'élément s'il existe.

+ +

Voici un exemple d'utilisation de pointerLockElement:

+ +
document.pointerLockElement = document.pointerLockElement    ||
+                              document.mozPointerLockElement ||
+                              document.webkitPointerLockElement;
+
+// 1) Utiliser une vérification booléenne--le pointeur est-il verrouillé?
+if (!!document.pointerLockElement) {
+  // pointeur verrouillé
+} else {
+  // pointeur non verrouillé
+}
+
+// 2) Accéder à l'élément verrouillé
+if (document.pointerLockElement === someElement) {
+  // someElement est l'élément sur lequel le pointeur est verrouillé
+}
+
+ +

La méthode {{domxref("Document.exitPointerLock()")}} est utilisée pour libérer le verrouillage du pinteur, et, comme {{domxref("Element.requestPointerLock","requestPointerLock")}}, marche de manière asynchrone, on utilise les événements {{event("pointerlockchange")}} et {{event("pointerlockerror")}}, que vous verrez plus en détails ci-dessous.

+ +
document.exitPointerLock = document.exitPointerLock    ||
+                           document.mozExitPointerLock ||
+                           document.webkitExitPointerLock;
+
+// Essaie de déverrouiller
+document.exitPointerLock();
+
+ +

Événement pointerlockchange

+ +

Quand l'état de verrouillage du pointeur change — par exemple quand on appelle {{domxref("Element.requestPointerLock","requestPointerLock()")}}, {{domxref("Document.exitPointerLock","exitPointerLock()")}}, que l'utilisateur presse la touche ECHAP, etc.—l'événement {{event("pointerlockchange")}} est envoyé au document. C'est un simple événement qui ne contient pas de données supplémentaires.

+ +
document.pointerLockElement = document.pointerLockElement    ||
+                              document.mozPointerLockElement ||
+                              document.webkitPointerLockElement;
+
+function pointerLockChange() {
+  if (!!document.pointerLockElement) {
+    console.log("Verrouillé.");
+  } else {
+    console.log("Non verrouillé.");
+  }
+}
+
+document.addEventListener('pointerlockchange', pointerLockChange, false);
+document.addEventListener('mozpointerlockchange', pointerLockChange, false);
+document.addEventListener('webkitpointerlockchange', pointerLockChange, false);
+
+ +

Événement pointerlockerror

+ +

Quand une erreur est causée par l'appel de {{domxref("Element.requestPointerLock","requestPointerLock()")}} ou {{domxref("Document.exitPointerLock","exitPointerLock()")}}, l'événement {{event("pointerlockerror")}} est envoyé au document. C'est un simple événement qui ne contient pas de données supplémentaires.

+ +
document.addEventListener('pointerlockerror', lockError, false);
+document.addEventListener('mozpointerlockerror', lockError, false);
+document.addEventListener('webkitpointerlockerror', pointerLockChange, false);
+
+function lockError(e) {
+  alert("Pointer lock failed");
+}
+
+ +
Note: Jusqu'à Firefox 50, les événements ci-dessus étaient préfixés avec moz.
+ +

Extensions aux événements de souris

+ +

L'API Pointer lock étend l'interface {{domxref("MouseEvent")}} normale avec les attributs de mouvement. Deux nouveaux attributs sont ajoutés aux événements de souris —{{domxref("MouseEvent.movementX","movementX")}} et {{domxref("MouseEvent.movementY","movementY")}}— fournissant le changement de position de la souris. Ces paramètres ont pour valeur les différences entre les valeurs des propriétés de {{domxref("MouseEvent.screenX","screenX")}} / {{domxref("MouseEvent.screenY","screenY")}} stockées dans les événements {{event("mousemove")}}, eNow et ePrevious. En d'autres termes, movementX = eNow.screenX - ePrevious.screenX.

+ +

État verrouillé

+ +

Quand le verrouillage du pointeur est activé, les propriétés standard {{domxref("MouseEvent.clientX","clientX")}}, {{domxref("MouseEvent.clientY","clientY")}}, {{domxref("MouseEvent.screenX","screenX")}}, et {{domxref("MouseEvent.screenY","screenY")}} sont gardées constantes, comme si la souris ne bougeait pas. Les propriétés {{domxref("MouseEvent.movementX","movementX")}} et {{domxref("MouseEvent.movementY","movementY")}} continuent de fournir le changement de position de la souris. Il n'y a pas de limite aux valeurs {{domxref("MouseEvent.movementX","movementX")}} et {{domxref("MouseEvent.movementY","movementY")}}, si la souris continue de bouger toujours dans la même direction. Le curseur de la souris n'existe pas et il ne peut pas sortir de la fenêtre ou être bloqué par un bord de l'écran.

+ +

État déverrouillé

+ +

Les paramètres {{domxref("MouseEvent.movementX","movementX")}} et {{domxref("MouseEvent.movementY","movementY")}} sont disponibles quel que soit l'état de la souris, verrou ou non.

+ +

Quand la souris est déverrouillée, il est possible que le curseur soit en dehors de la fenêtre et il est alors remis automatiquement à l'intérieur. Si cela arrive, {{domxref("MouseEvent.movementX","movementX")}} et {{domxref("MouseEvent.movementY","movementY")}} sont définis à zéro.

+ +

Simple exemple pas à pas

+ +

Nous avons écrit une démo de verrouillage de pointer pour vous montrer comment l'utiliser pour mettre en place un système de contrôle simple (voir le code source). La démo ressemble à ça:

+ +

A red circle on top of a black background.

+ +

Cette démo utilise JavaScript pour dessiner une balle dans un élément {{ htmlelement("canvas") }}. Quand vous cliquez sur le canvas, le verrouillage du pointeur est utilisé pour supprimer le curseur de la souris à l'écran et vous permettre de déplacer la balle avec la souris. Voyons comment cela fonctionne.

+ +

On définit les positions initiales x et y sur le canvas:

+ +
var x = 50;
+var y = 50;
+ +

Les méthodes de verrouillage de pointeur sont préfixées dans les anciennes versions des navigateurs, on prend donc en compte les différentes implémentations des navigateurs:

+ +
canvas.requestPointerLock = canvas.requestPointerLock ||
+                            canvas.mozRequestPointerLock ||
+                            canvas.webkitRequestPointerLock;
+
+document.exitPointerLock = document.exitPointerLock ||
+                           document.mozExitPointerLock ||
+                           document.webkitExitPointerLock;
+ +

Maintenant, on définit un gestionnaire d'événement qui appelle la méthode requestPointerLock() quand le canvas est cliqué, ce qui déclenche le verrouillage du pointeur.

+ +
canvas.onclick = function() {
+  canvas.requestPointerLock();
+}
+ +

Et maintenant le gestionnaire d'événement pour le verrouillage: pointerlockchange. Quand cet événement se déclenche, on appelle lockChangeAlert() pour gérer le changement.

+ +
// Gestionnaire d'événement de changement d'état du verrouilllage pour les différents navigateurs
+document.addEventListener('pointerlockchange', lockChangeAlert, false);
+document.addEventListener('mozpointerlockchange', lockChangeAlert, false);
+document.addEventListener('webkitpointerlockchange', lockChangeAlert, false);
+
+ +

La fonction suivante vérifie si la propriété pointLockElement est sur notre canvas. Si c'est le cas, on attache un gestionnaire d'événement pour gérer les mouvements de la souris avec la fonction updatePosition(). Sinon, elle enlève le gestionnaire d'événement.

+ +
function lockChangeAlert() {
+  if (document.pointerLockElement === canvas) {
+    console.log('The pointer lock status is now locked');
+    document.addEventListener("mousemove", updatePosition, false);
+  } else {
+    console.log('The pointer lock status is now unlocked');
+    document.removeEventListener("mousemove", updatePosition, false);
+  }
+}
+ +

La fonction updatePosition() met à jour la position de la balle sur le canvas (les valeurs x et y), et inclut également des instructions if() pour vérifier si la balle est sortie des bords du canvas. Dans ce cas, la balle se ressort au bord opposé. Elle vérifie également si un appel à requestAnimationFrame() a été effectué et si ce n'est pas le cas, l'appelle pour qu'elle déclenche la fonction canvasDraw() et mette à jour le canvas. Un tracker est mis en place pour afficher les valeurs X et Y à l'écran, pour référence.

+ +
var tracker = document.getElementById('tracker');
+
+var animation;
+function updatePosition(e) {
+  x += e.movementX;
+  y += e.movementY;
+  if (x > canvas.width + RADIUS) {
+    x = -RADIUS;
+  }
+  if (y > canvas.height + RADIUS) {
+    y = -RADIUS;
+  }
+  if (x < -RADIUS) {
+    x = canvas.width + RADIUS;
+  }
+  if (y < -RADIUS) {
+    y = canvas.height + RADIUS;
+  }
+  tracker.textContent = "X position: " + x + ", Y position: " + y;
+
+  if (!animation) {
+    animation = requestAnimationFrame(function() {
+      animation = null;
+      canvasDraw();
+    });
+  }
+}
+ +

La fonction canvasDraw() affiche la balle aux position x et y en cours:

+ +
function canvasDraw() {
+  ctx.fillStyle = "black";
+  ctx.fillRect(0, 0, canvas.width, canvas.height);
+  ctx.fillStyle = "#f00";
+  ctx.beginPath();
+  ctx.arc(x, y, RADIUS, 0, degToRad(360), true);
+  ctx.fill();
+}
+ +

iframe limitations

+ +

Le verrouilage du pointeur ne peut concerner qu'une seule iframe à la fois. Quand vous verrouillez une iframe, vous ne pouvez pas essayer de verrouiller une autre iframe et y transférer la cible; une erreur sera levée. Pour éviter cette limitation, déverrouillez d'abord la première iframe, puis verrouillez la seconde.

+ +

Tandis que cela fonctionne pour les iframes par défaut, les iframes en "sandbox" bloquent le verrouillage. La possibilité d'éviter cette limitation, sous la forme de la combinaison attribut/valeur <iframe sandbox="allow-pointer-lock">, devrait bientôt apparaître dans Chrome.

+ +

Spécifications

+ + + + + + + + + + + + + + + + +
SpecificationEtatCommentaire
{{SpecName('Pointer Lock')}}{{Spec2('Pointer Lock')}}Initial specification.
+ +

Compatibilité navigateur

+ +

{{ CompatibilityTable() }}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeEdgeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Basic support +

{{CompatVersionUnknown}}

+ 		{{CompatVersionUnknown}} +

{{CompatVersionUnknown}} {{ property_prefix("-moz") }}

+ 		{{ CompatNo() }}{{CompatVersionUnknown}}10.1
Unprefixed support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoDesktop(50)}}{{ CompatNo() }}{{CompatVersionUnknown}}10.1
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidEdgeFirefox Mobile (Gecko)Firefox OSIE PhoneOpera MobileSafari Mobile
Basic support{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+
+ +

Voir aussi

+ + diff --git a/files/fr/webapi/power_management/index.html b/files/fr/webapi/power_management/index.html new file mode 100644 index 0000000000..71767d3fb1 --- /dev/null +++ b/files/fr/webapi/power_management/index.html @@ -0,0 +1,123 @@ +--- +title: Gestion de l'énergie +slug: WebAPI/Power_Management +tags: + - B2G + - Firefox OS + - Non Standard + - Power Management + - WebAPI +translation_of: Archive/B2G_OS/API/Power_Management_API +--- +

{{ non-standard_header() }}

+

{{ B2GOnlyHeader2('certified') }}

+

Résumé

+

L'API de gestion de l'énergie, propose des outils pour gérer la consommation énergétique de l'appareil.

+

Gestion de l'énergie

+

L'API : Power Management , permet d'agir directement sur la consommation d'énergie (écran, processeur, etc...).
+ L'interface principale pour gérer l'alimentation est accessible
+ via {{domxref("window.navigator.mozPower","navigator.mozPower")}} qui est une instance de l'interface {{domxref("PowerManager")}}.

+

Opérations d'alimentation de base

+

L'interface {{domxref("PowerManager")}} permet de gérer la consommation énergétique d'un appareil grâce à de simples opérations.

+

Opérations globales d'alimentation

+

Il est possible d'éteindre l'appareil avec la méthode {{domxref("PowerManager.powerOff()","powerOff()")}} ou de le redémarrer via la méthode {{domxref("PowerManager.reboot()","reboot()")}}.

+
// Redémarre l'appareil.
+navigator.mozPower.reboot();
+// Eteint l'appareil.
+navigator.mozPower.powerOff();
+

Opérations d'alimentation de l'écran

+

L'écran peut être éteint ou rallumé avec la propriété {{domxref("PowerManager.screenEnabled","screenEnabled")}} en lecture-écriture.

+

Mais il est aussi possible d'agir sur l'écran de manière plus précise, en changeant par exemple la luminosité avec la propriété {{domxref("PowerManager.screenBrightness","screenBrightness")}} en lecture-écriture. Cette propriété définit, sur une échelle de 0 à 1, quel est le niveau de luminosité du rétro-éclairage de l'écran (0 étant la luminosité minimale et 1 la luminosité maximale).

+
// Il est inutile de changer la luminosité si
+// l'écran est éteint.
+if (navigator.mozPower.screenEnabled) {
+  navigator.mozPower.screenBrightness = 0.5;
+}
+

Opération sur la consommation du processeur

+

Même s'il n'est pas possible d'éteindre directement le processeur, il est cependant possible de dire s'il peut être arrêté ou, si l'écran est hors tension. Cela peut être défini avec la propriété : {{domxref("PowerManager.cpuSleepAllowed","cpuSleepAllowed")}}.
+ Elle détermine si le processeur se mettra en veille une fois que l'écran a été éteint (true) ou si le processeur continuera de fonctionner normalement (false), auquel cas l'appareil ne passera pas en veille.

+

Opérations d'alimentation avancées

+

L'énergie peut être mieux gérée lorsque l'application en charge de l'énergie est capable de recevoir des informations quant aux besoins énergétiques des applications tierces. La lecture d'une vidéo, par exemple, sera plus agréable si l'écran ne s'éteint pas automatiquement après quelques secondes de lecture.

+

Inhibiteur de mise en veille

+

Toute application peut faire une requête d'inhibition de la mise en veille.
+ Une requête d'inhibition de mise en veille est une façon d’empêcher l'appareil de mettre en veille ses ressources matérielles (écran, processeur, son etc...).  Cette requête peut être appelée grâce à la méthode {{domxref("window.navigator.requestWakeLock","navigator.requestWakeLock()")}} .

+

L'inhibition de la mise en veille est requise pour des ressources spécifiques qui pourraient être indisponibles pour diverses raisons.
+ Par exemple, sur un appareil mobile, le gestionnaire d'énergie peut décider d'éteindre l'écran après une période d'inactivité pour économiser de l'énergie.

+

L'application qui gère une ressource vérifie la disponibilité de la mise en veille de la ressource associée, avant de la désactiver. Une page peut ainsi empêcher que l'économiseur d'écran s'active ou que l'écran s'éteigne.

+

Par défaut, Firefox OS autorise l'écran, le processeur, le wifi, à se mettre en veille. Néanmoins, toute application peut manipuler une ressource matérielle et définir sa propre politique de mise en veille pour cette ressource. Le gestionnaire de ressource peut décider par exemple d'ignorer la requête d’inhibition de mise en veille de l'écran demandée par des applications en arrière plan.

+
var lock = navigator.requestWakeLock('screen');
+

La méthode {{domxref("window.navigator.requestWakeLock","requestWakeLock")}} retourne un objet contenant une propriété topic représentant, le nom de la ressource spécifique verrouilée ainsi qu'une methode unlock() qui peut être utiliser pour annuler manuellement l’inhibition. Notons que si l'application est close (réellement close et pas seulement en arrière plan) toutes les inhibitions seront libérées automatiquement.

+

Gérer un inhibiteur de mise en veille

+

Les applications certifiées, sont capables de gérer le blocage de mise en veille et d'être notifiées changements sur l'état de ce verrouillage. Toute application désirant gérer l'énergie doit en fait écouter tout changement de l'état du blocage de veille de l'écran et du processeur. Ceci peut être réalisé à l'aide de la méthode {{domxref("PowerManager.addWakeLockListener()")}}.
+ Il est également possible d’arrêter d'écouter les requêtes de verrouillage via la méthode {{domxref("PowerManager.removeWakeLockListener()","")}}.

+

La méthode {{domxref("PowerManager.addWakeLockListener()","addWakeLockListener")}} prends en paramètre une fonction de rappel (callback) acceptant deux paramètres : une première chaine de caractères représentant une ressource à gérer (dans notre cas l'écran, le processeur ou le wifi) et une seconde chaine de caractères représentant l'état du blocage de veille pour la ressoure concernée.

+

Le verrou de la mise en veille peut avoir trois états :

+
+
+ unlocked
+
+ Personne ne détient le verrou pour bloquer la veille de la ressource donnée
+
+ locked-foreground
+
+ Au moins une application détient le verrou et est visible.
+
+ locked-background
+
+ Au moins une application détient le verrou, cependant aucune d'entre elle n'est visible.
+
+
// Utilisé pour garder une trace du
+// dernier changement d'état de WakeLock.
+var screenTimeout,
+
+// Une référence sur le gestionnaire d'énergie.
+    power = window.navigator.mozPower,
+
+// Ici l'action pour gérer l'état du WakeLock.
+    powerAction = {
+  // Si il n'y a aucun WakeLock, on va suspendre l'appareil.
+  // * Éteindre l'écran
+  // * Permettre au processeur de se mettre en veille.
+    unlocked: function suspendDevice() {
+    power.cpuSleepAllowed = true;
+    power.screenEnabled   = false;
+  },
+
+  // Si il y a un WakeLock mais les application qui le requièrent
+  // sont toutes en arrière plan, on éteint juste l'écran.
+  'locked-background': function shutOffOnlyScreen() {
+    power.cpuSleepAllowed = false;
+    power.screenEnabled   = false;
+  },
+
+  // En fin s'il n'y a pas d'application active, requérant un WakeLock,
+  // et bien il n'y a rien à faire!
+ }
+
+function screenLockListener(topic, state) {
+  // Si la ressource désignée par le WakeLock n'est pas l'écran ne rien faire.
+  if ('screen' !== topic) { return; }
+
+  // Chaque fois que l'état de WakeLock change,
+  // on arrête toute opération de gestion d'énergie en cours.
+  window.clearTimeout(screenTimeout);
+
+  // Si il y a une action définie pour l'état donnée.
+  if (powerAction[state]) {
+    // On retard l'action de 3s.
+    screenTimeout = window.setTimeout(powerAction[state], 3000);
+  }
+}
+// On s'assure que notre application de gestion de l'énergie écoute,
+// tout les changements sur l'état de WakeLock d'une ressource donnée.
+power.addWakeLockListener(cpuLockListener);
+power.addWakeLockListener(screenLockListener);
+

 

+

Spécification

+

Cette API ne fait partie d'aucune spécification actuellement.

+

Voir aussi

+ diff --git a/files/fr/webapi/proximity/index.html b/files/fr/webapi/proximity/index.html new file mode 100644 index 0000000000..e5b3d1e199 --- /dev/null +++ b/files/fr/webapi/proximity/index.html @@ -0,0 +1,120 @@ +--- +title: Proximity +slug: WebAPI/Proximity +tags: + - WebAPI +translation_of: Web/API/Proximity_Events +--- +

{{ SeeCompatTable }}

+

Résumé

+

Les événements de proximité permettent, simplement, de savoir lorsqu'un utilisateur est près de l'appareil. Ces événements permettent de réagir par rapport à cette proximité, par exemple en éteignant l'écran lorsqu'un utilisateur est en train de passer un appel téléphonique et que l'appareil est près de l'oreille.

+
+

Note : Bien entendu, il faut un capteur de proximité pour que cette API fonctionne, ceux-ci sont généralement disponibles sur les appareils mobile. Les appareils ne disposant pas d'un tel capteur pourront supporter de tels événements, ils seront en revanche incapables de les déclencher.

+
+

Événements de proximité

+

Lorsque le capteur de l'appareil détecte un changement entre l'appareil et l'objet, il informe le navigateur de ce changement en lui envoyant une notification. Lorsque le navigateur reçoit une notification comme celle-ci, il déclenche un événement {{domxref("DeviceProximityEvent")}} à chaque fois qu'il y a un changement et un événement  {{domxref("UserProximityEvent")}} dans le cas où un changement plus brutal se produit.

+

Cet événement peut être capturé en utilisant un objet au niveau window en utilisant la méthode {{domxref("EventTarget.addEventListener","addEventListener")}} (en utilisant les noms d'événements {{event("deviceproximity")}} ou {{event("userproximity")}}) ou en attachant un gestionnaire d'événement à la propriété {{domxref("window.ondeviceproximity")}} ou à la propriété {{domxref("window.onuserproximity")}}.

+

Une fois qu'il a été capturé, l'événement donne accès à différentes informations :

+ +

Exemple

+
window.addEventListener('userproximity', function(event) {
+  if (event.near) {
+    // extinction de l'écran
+    navigator.mozPower.screenEnabled = false;
+  } else {
+    // allumage de l'écran
+    navigator.mozPower.screenEnabled = true;
+  }
+});
+

Spécifications

+ + + + + + + + + + + + + + + +
SpécificationStatutCommentaires
{{ SpecName('Proximity Events', '', 'Proximity Events') }}{{ Spec2('Proximity Events') }}Spécification initiale
+

Compatibilité des navigateurs

+

{{ CompatibilityTable() }}

+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
FonctionnalitéChromeFirefox (Gecko)Internet ExplorerOperaSafari
{{domxref("DeviceProximityEvent")}}{{CompatNo()}}{{CompatVersionUnknown()}}{{CompatNo()}}{{CompatNo()}}{{CompatNo()}}
{{domxref("UserProximityEvent")}}{{CompatNo()}}{{CompatVersionUnknown()}}{{CompatNo()}}{{CompatNo()}}{{CompatNo()}}
+
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FonctionnalitéAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
{{domxref("DeviceProximityEvent")}}{{CompatNo()}}{{CompatNo()}}{{ CompatGeckoMobile("15.0") }}{{CompatNo()}}{{CompatNo()}}{{CompatNo()}}
{{domxref("UserProximityEvent")}}{{CompatNo()}}{{CompatNo()}}{{CompatVersionUnknown()}}{{CompatNo()}}{{CompatNo()}}{{CompatNo()}}
+
+

Voir aussi

+ diff --git "a/files/fr/webapi/utiliser_les_\303\251v\303\251n\303\251ments_de_luminosit\303\251/index.html" "b/files/fr/webapi/utiliser_les_\303\251v\303\251n\303\251ments_de_luminosit\303\251/index.html" new file mode 100644 index 0000000000..4f30f285d0 --- /dev/null +++ "b/files/fr/webapi/utiliser_les_\303\251v\303\251n\303\251ments_de_luminosit\303\251/index.html" @@ -0,0 +1,98 @@ +--- +title: Utiliser les événements de luminosité +slug: WebAPI/Utiliser_les_événéments_de_luminosité +tags: + - WebAPI +translation_of: Web/API/Ambient_Light_Events +--- +

{{SeeCompatTable }}

+

Résumé

+

Les événements concernant la lumière environnante permettent à une application de percevoir simplement les changements de luminosité dans l'environnement de l'appareil. L'application peut donc ainsi réagir aux changements de luminosité : par exemple changer le contraste de l'interface ou changer l'exposition lors de la prise d'une photo.

+

Les événements liés à la lumière

+

Lorsque le capteur de lumière détecte un changement de luminosité, il envoie une notification au navigateur. Lorsque le navigateur reçoit une notification, il déclenche un événement {{domxref("DeviceLightEvent")}} qui fournit des informations sur la valeur exacte de l'intensité lumineuse.

+

Cet événement peut être capturé au niveau de l'objet window en utilisant la méthode {{domxref("EventTarget.addEventListener","addEventListener")}} (en utilisant le nom d'événement {{event("devicelight")}}) ou en attachant le gestionnaire d'événément à la propriété {{domxref("window.ondevicelight")}}.

+

Une fois qu'il a été capturé, l'événement permet un accès à la valeur de l'intensité lumineuse, exprimée en lux avec la propriété {{domxref("DeviceLightEvent.value")}}.

+

Exemple

+
window.addEventListener('devicelight', function(event) {
+  var html = document.getElementsByTagName('html')[0];
+
+  if (event.value < 50) {
+    html.classList.add('darklight');
+    html.classList.remove('brightlight');
+  } else {
+    html.classList.add('brightlight');
+    html.classList.remove('darklight');
+  }
+});
+

Spécifications

+ + + + + + + + + + + + + + + +
SpécificationStatutCommentaires
{{ SpecName('AmbientLight', '', 'Ambient Light Events') }}{{ Spec2('AmbientLight') }}Spécification initiale
+

Compatibilité des navigateurs

+

{{ CompatibilityTable() }}

+
+ + + + + + + + + + + + + + + + + + + +
FonctionnalitéChromeFirefox (Gecko)Internet ExplorerOperaSafari
{{domxref("DeviceLightEvent")}}{{CompatNo()}}{{CompatGeckoDesktop("22.0")}} (Mac OS X seulement){{CompatNo()}}{{CompatNo()}}{{CompatNo()}}
+
+
+ + + + + + + + + + + + + + + + + + + + + +
FonctionnalitéAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
{{domxref("DeviceLightEvent")}}{{CompatNo()}}{{CompatNo()}}{{CompatGeckoMobile("15.0")}}{{CompatNo()}}{{CompatNo()}}{{CompatNo()}}
+
+

Notes relatives à Gecko

+

L'événement {{event("devicelight")}} est implémenté et activé par défaut via un paramètre dans Firefox Mobile pour Android (15.0) et dans Firefox OS (B2G). Une implémentation pour un navigateur de bureau sur Mac OS X est également disponible à partir de Gecko 22.0 {{geckoRelease("22.0")}}. Le support pour Windows 7 est en cours de progression (voir {{bug(754199)}}).

+

Voir aussi

+ diff --git a/files/fr/webapi/websms/index.html b/files/fr/webapi/websms/index.html new file mode 100644 index 0000000000..66bf727f00 --- /dev/null +++ b/files/fr/webapi/websms/index.html @@ -0,0 +1,62 @@ +--- +title: WebSMS +slug: WebAPI/WebSMS +tags: + - WebAPI +translation_of: Archive/B2G_OS/API/Mobile_Messaging_API +--- +

L'API WebSMS permet à du contenu web de créer, envoyer ou recevoir des SMS (Short Message Services).

+

Cette API est disponible en utilisant {{ domxref("window.navigator.mozSms") }} qui renvoie un objet {{ domxref("SmsManager") }}. Voir ci-après pour une liste complète des interfaces :

+

Interfaces DOM

+ +

Interfaces

+ +

Exemple de code et introduction à WebSMS

+ +

Compatibilité des navigateurs

+

Pour des raisons évidentes, cette API est surtout destinée aux navigateurs mobiles.

+ + + + + + + + + + + + + + + + + + + +
FonctionnalitéAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Support simple{{ CompatNo() }}{{ CompatGeckoMobile("12.0") }}{{ CompatNo() }}{{ CompatNo() }}{{ CompatNo() }}
+

 

+

Réglages et disponibilité

+ +

Voir aussi

+ -- cgit v1.2.3-54-g00ecf