वेब के लिए सेंसर

डिवाइस पर मौजूद सेंसर, जैसे कि एक्सलरोमीटर, जाइरोस्कोप, और मैग्नेटोमीटर का ऐक्सेस पाने के लिए, जेनेरिक सेंसर एपीआई का इस्तेमाल करें.

Alex Shalamov

Mikhail Pozdnyakov

Thomas Steiner

फ़िलहाल, सेंसर डेटा का इस्तेमाल कई प्लैटफ़ॉर्म पर काम करने वाले ऐप्लिकेशन में किया जाता है. इससे, बेहतर गेमिंग, फ़िटनेस ट्रैकिंग, और ऑगमेंटेड या वर्चुअल रिएलिटी जैसे इस्तेमाल के उदाहरणों को चालू किया जा सकता है. क्या यह सुरक्षित नहीं होगा किसी खास प्लैटफ़ॉर्म और वेब ऐप्लिकेशन के बीच का अंतर क्या है? वेब के लिए, Generic Sensor API डालें!

Generic Sensor API क्या है?

जेनेरिक सेंसर एपीआई ऐसे इंटरफ़ेस का सेट है जो खोज के नतीजों में, सेंसर डिवाइस को वेब प्लैटफ़ॉर्म पर ले जाते हैं. एपीआई में बेस Sensor इंटरफ़ेस और टॉप पर बनाई गई कंक्रीट सेंसर क्लास का एक सेट होता है. बेस इंटरफ़ेस होने से, खास सेंसर क्लास के लिए लागू करने और स्पेसिफ़िकेशन की प्रोसेस को आसान बनाता है. उदाहरण के लिए, इन बातों पर ध्यान दें Gyroscope क्लास. यह बहुत छोटा है! मुख्य फ़ंक्शन, बेस इंटरफ़ेस से तय होता है. Gyroscope, सिर्फ़ कोणीय वेग को दिखाने वाले तीन एट्रिब्यूट के साथ इसे बढ़ाता है.

कुछ सेंसर क्लास, असल हार्डवेयर सेंसर से इंटरफ़ेस करती हैं. उदाहरण के लिए, एक्सलरोमीटर या जाइरोस्कोप क्लास. इन्हें लो-लेवल सेंसर कहा जाता है. अन्य सेंसर, जिन्हें यह कहा जाता है फ़्यूजन सेंसर, कई लो लेवल से डेटा मर्ज करें का इस्तेमाल करता है. उदाहरण के लिए, AbsoluteOrientation सेंसर, एक्सलरोमीटर, जाइरोस्कोप, और मैग्नेटोमीटर से मिले डेटा के आधार पर, इस्तेमाल के लिए तैयार चार-बाय-चार रोटेशन मैट्रिक उपलब्ध कराता है.

आपको लग सकता है कि वेब प्लैटफ़ॉर्म पहले से ही सेंसर डेटा उपलब्ध कराता है और आप बिलकुल सही हैं! इसके लिए इंस्टेंस, DeviceMotion और DeviceOrientation किसी गतिविधि की वजह से, मोशन सेंसर का डेटा बिना अनुमति के सार्वजनिक हो जाता है. हमें नए एपीआई की ज़रूरत क्यों है?

मौजूदा इंटरफ़ेस की तुलना में, Generic Sensor API के कई फ़ायदे हैं:

• Generic Sensor API एक सेंसर फ़्रेमवर्क है. इसे नई सेंसर क्लास के साथ आसानी से बढ़ाया जा सकता है. साथ ही, इनमें से हर क्लास में सामान्य इंटरफ़ेस रहेगा. एक सेंसर टाइप के लिए लिखा गया क्लाइंट कोड का उपयोग बहुत कम संशोधन के साथ एक अन्य के लिए किया जा सकता है!
• सेंसर को कॉन्फ़िगर किया जा सकता है. उदाहरण के लिए, अपने हिसाब से सैंपलिंग की फ़्रीक्वेंसी सेट की जा सकती है ज़रूरत के हिसाब से काम करते हैं.
• प्लैटफ़ॉर्म पर सेंसर उपलब्ध है या नहीं, यह पता लगाया जा सकता है.
• सेंसर रीडिंग में ज़्यादा सटीक टाइमस्टैंप होते हैं. इससे आपके ऐप्लिकेशन में मौजूद अन्य गतिविधियों के साथ बेहतर तरीके से सिंक किया जा सकता है.
• सेंसर डेटा मॉडल और कोऑर्डिनेट सिस्टम को साफ़ तौर पर बताया गया है. इससे ब्राउज़र वेंडर, एक-दूसरे के साथ काम करने वाले समाधान लागू कर सकते हैं.
• सामान्य सेंसर पर आधारित इंटरफ़ेस, डीओएम से बंधे नहीं होते. इसका मतलब है कि ये न तो navigator और न ही window ऑब्जेक्ट होते हैं. इससे आने वाले समय में, सेवा वर्कर्स में एपीआई का इस्तेमाल करने या एम्बेड किए गए डिवाइसों जैसे हेडलेस JavaScript रनटाइम में इसे लागू करने के अवसर मिलते हैं.
• जेनेरिक सेंसर के लिए सुरक्षा और निजता से जुड़े पहलू सबसे ज़्यादा अहम होते हैं एपीआई और पुराने सेंसर एपीआई की तुलना में बेहतर सुरक्षा उपलब्ध कराता है. इस इंटिग्रेशन के साथ इंटिग्रेट किया गया है अनुमतियां एपीआई पर टैप करें.
• स्क्रीन कोऑर्डिनेट के साथ अपने-आप सिंक होने की सुविधा Accelerometer, Gyroscope, LinearAccelerationSensor, और AbsoluteOrientationSensor, RelativeOrientationSensor और Magnetometer.

उपलब्ध सामान्य सेंसर एपीआई

लिखने के समय, ऐसे कई सेंसर मौजूद होते हैं जिनके साथ एक्सपेरिमेंट किया जा सकता है.

मोशन सेंसर:

• Accelerometer
• Gyroscope
• LinearAccelerationSensor
• AbsoluteOrientationSensor
• RelativeOrientationSensor
• GravitySensor

पर्यावरण सेंसर:

• AmbientLightSensor (Chromium में #enable-generic-sensor-extra-classes फ़्लैग के पीछे.)
• Magnetometer (Chromium में #enable-generic-sensor-extra-classes फ़्लैग के पीछे.)

सुविधा की पहचान

हार्डवेयर एपीआई की सुविधा का पता लगाना मुश्किल है, क्योंकि आपको यह पता लगाना होगा कि ब्राउज़र, उस इंटरफ़ेस के साथ काम करता है या नहीं और डिवाइस में उससे जुड़ा सेंसर है या नहीं. यह जांचना आसान है कि ब्राउज़र किसी इंटरफ़ेस के साथ काम करता है या नहीं. (Accelerometer को इनमें से किसी से बदलें अन्य इंटरफ़ेस जिनका उल्लेख ऊपर किया गया है.)

if ('Accelerometer' in window) {
  // The `Accelerometer` interface is supported by the browser.
  // Does the device have an accelerometer, though?
}

सुविधा की पहचान करने वाले असल नतीजे पाने के लिए, आपको सेंसर से भी कनेक्ट करना होगा. इस उदाहरण में, ऐसा करने का तरीका बताया गया है.

let accelerometer = null;
try {
  accelerometer = new Accelerometer({ frequency: 10 });
  accelerometer.onerror = (event) => {
    // Handle runtime errors.
    if (event.error.name === 'NotAllowedError') {
      console.log('Permission to access sensor was denied.');
    } else if (event.error.name === 'NotReadableError') {
      console.log('Cannot connect to the sensor.');
    }
  };
  accelerometer.onreading = (e) => {
    console.log(e);
  };
  accelerometer.start();
} catch (error) {
  // Handle construction errors.
  if (error.name === 'SecurityError') {
    console.log('Sensor construction was blocked by the Permissions Policy.');
  } else if (error.name === 'ReferenceError') {
    console.log('Sensor is not supported by the User Agent.');
  } else {
    throw error;
  }
}

Polyfill

जो ब्राउज़र जेनेरिक सेंसर एपीआई के साथ काम नहीं करते उनके लिए, polyfill की सुविधा उपलब्ध है. पॉलीफ़िल की मदद से, सिर्फ़ काम के सेंसर लागू किए जा सकते हैं.

// Import the objects you need.
import { Gyroscope, AbsoluteOrientationSensor } from './src/motion-sensors.js';

// And they're ready for use!
const gyroscope = new Gyroscope({ frequency: 15 });
const orientation = new AbsoluteOrientationSensor({ frequency: 60 });

ये सभी सेंसर क्या हैं? मैं इनका इस्तेमाल कैसे करूं?

सेंसर एक ऐसा क्षेत्र है जिसके बारे में कम शब्दों में जानकारी देनी पड़ सकती है. अगर आपको सेंसर के बारे में पता है, तो सीधे कोडिंग सेक्शन पर जाएं. आइए, एक-दूसरे के साथ काम करने वाले करते हैं.

एक्सलरोमीटर और लीनियर ऐक्सेलरेशन सेंसर

Accelerometer सेंसर तीन ऐक्सिस (X, Y, और Z) पर सेंसर को होस्ट करने वाले डिवाइस के त्वरण को मापता है. यह सेंसर इनर्शियल सेंसर, इसका मतलब है कि जब डिवाइस लीनियर फ़्री फ़ॉल में होता है, तो कुल त्वरण, 0 मी/से² होगा और जब कोई डिवाइस टेबल पर सीधे लेटा होगा, तो रफ़्तार ऊपर की दिशा में (Z ऐक्सिस), पृथ्वी के गुरुत्वाकर्षण के बराबर होगा, जैसे कि g ≈ +9.8 m/s² यह डिवाइस को ऊपर की ओर धकेलने वाली टेबल के बल को माप रहा है. अगर आप डिवाइस को दाईं ओर, X ऐक्सिस पर त्वरण धनात्मक या ऋणात्मक होगा, अगर डिवाइस दाईं ओर.

एक्सलरोमीटर का इस्तेमाल इन कामों के लिए किया जा सकता है: कदमों की गिनती, मोशन सेंसिंग या आसान डिवाइस स्क्रीन की दिशा. अक्सर, एक्सलरोमीटर माप को अन्य स्रोतों से डेटा के साथ मिलाया जाता है फ़्यूजन सेंसर बनाते हैं, जैसे कि ओरिएंटेशन सेंसर.

LinearAccelerationSensor, सेंसर को होस्ट करने वाले डिवाइस पर लागू होने वाले त्वरण को मेज़र करता है. इसमें गुरुत्वाकर्षण का योगदान शामिल नहीं होता. जब कोई डिवाइस आराम में हो, जैसे कि टेबल पर सीधा लेटा हुआ हो, तो सेंसर मापेगा तीन ऐक्सिस पर ≈ 0 m/s² त्वरण.

गुरुत्वाकर्षण सेंसर

उपयोगकर्ता, Accelerometer और LinearAccelerometer की रीडिंग की मैन्युअल जांच करके, गुरुत्वाकर्षण सेंसर की रीडिंग के करीब की रीडिंग मैन्युअल तरीके से पा सकते हैं. हालांकि, यह तरीका मुश्किल हो सकता है और यह उन सेंसर से मिली वैल्यू की सटीक होने पर निर्भर करता है. Android जैसे प्लैटफ़ॉर्म यह काम कर सकते हैं आप ऑपरेटिंग सिस्टम के हिस्से के रूप में गुरुत्वाकर्षण रीडिंग उपलब्ध करा सकते हैं, जो हिसाब लगाने के लिए, और उपयोगकर्ता के हार्डवेयर के आधार पर ज़्यादा सटीक वैल्यू दें. साथ ही, इन वैल्यू का इस्तेमाल आसानी से किया जा सके की शर्तें पढ़ें. कॉन्टेंट बनाने GravitySensor, इफ़ेक्ट दिखाता है गुरुत्वाकर्षण की वजह से डिवाइस के X, Y, और Z ऐक्सिस पर त्वरण का.

जाइरोस्कोप

Gyroscope सेंसर, डिवाइस के लोकल X, Y, और Z ऐक्सिस के आस-पास, रेडियन प्रति सेकंड में ऐंगल वेलोसिटी को मेज़र करता है. ज़्यादातर उपभोक्ता डिवाइसों में, मैकेनिकल (MEMS) घिरौल होते हैं. ये इनर्शियल सेंसर होते हैं, जो इनर्शियल कोरिओलिस फ़ोर्स के आधार पर घुमाव की दर को मेज़र करते हैं. एमईएमएस (माइक्रो इलेक्ट्रॉनिक मैकेनिकल सिस्टम) वाले gyroscope में, ड्रिफ़्ट (डिवाइस के रैपिड मूवमेंट की वजह से, उसके आंकड़े में होने वाला बदलाव) की समस्या आ सकती है. यह समस्या, सेंसर की गुरुत्वाकर्षण संवेदनशीलता की वजह से होती है. इससे सेंसर के अंदरूनी मैकेनिकल सिस्टम में बदलाव होता है. गायरोस्कोप, ज़्यादा फ़्रीक्वेंसी पर ऑसीलेट करते हैं. जैसे, किलोहर्ट्ज़ (kHz) का 10 सेकंड, और इसलिए, हो सकता है कि दूसरे सेंसर की तुलना में ज़्यादा बिजली खर्च हो.

ओरिएंटेशन सेंसर

कॉन्टेंट बनाने AbsoluteOrientationSensor एक फ़्यूजन सेंसर है जो पृथ्वी के निर्देशांक सिस्टम के संबंध में किसी डिवाइस के रोटेशन को मापता है. हालांकि, RelativeOrientationSensor किसी स्टेशनरी के संबंध में मोशन सेंसर होस्ट करने वाले डिवाइस के रोटेशन का प्रतिनिधित्व करने वाला डेटा देता है रेफ़रंस कोऑर्डिनेट सिस्टम का इस्तेमाल करना.

सभी आधुनिक 3D JavaScript फ़्रेमवर्क, क्वाटर्नियन के साथ काम करते हैं और रोटेशन को दर्शाने के लिए रोटेशन मैट्रिक्स; हालांकि, यदि आप सीधे WebGL का उपयोग करते है, तो OrientationSensor में आसानी से दोनों quaternion प्रॉपर्टी और एक populateMatrix() तरीका. यहां कुछ स्निपेट दिए गए हैं:

three.js

let torusGeometry = new THREE.TorusGeometry(7, 1.6, 4, 3, 6.3);
let material = new THREE.MeshBasicMaterial({ color: 0x0071c5 });
let torus = new THREE.Mesh(torusGeometry, material);
scene.add(torus);

// Update mesh rotation using quaternion.
const sensorAbs = new AbsoluteOrientationSensor();
sensorAbs.onreading = () => torus.quaternion.fromArray(sensorAbs.quaternion);
sensorAbs.start();

// Update mesh rotation using rotation matrix.
const sensorRel = new RelativeOrientationSensor();
let rotationMatrix = new Float32Array(16);
sensor_rel.onreading = () => {
  sensorRel.populateMatrix(rotationMatrix);
  torus.matrix.fromArray(rotationMatrix);
};
sensorRel.start();

BABYLON

const mesh = new BABYLON.Mesh.CreateCylinder('mesh', 0.9, 0.3, 0.6, 9, 1, scene);
const sensorRel = new RelativeOrientationSensor({ frequency: 30 });
sensorRel.onreading = () => mesh.rotationQuaternion.FromArray(sensorRel.quaternion);
sensorRel.start();

WebGL

// Initialize sensor and update model matrix when new reading is available.
let modMatrix = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
const sensorAbs = new AbsoluteOrientationSensor({ frequency: 60 });
sensorAbs.onreading = () => sensorAbs.populateMatrix(modMatrix);
sensorAbs.start();

// Somewhere in rendering code, update vertex shader attribute for the model
gl.uniformMatrix4fv(modMatrixAttr, false, modMatrix);

ओरिएंटेशन सेंसर की मदद से, इमर्सिव गेमिंग, ऑगमेंटेड और वर्चुअल रिएलिटी जैसी कई सुविधाओं का इस्तेमाल किया जा सकता है.

मोशन सेंसर, बेहतर इस्तेमाल के उदाहरण, और इसकी ज़रूरी शर्तों के बारे में ज़्यादा जानने के लिए, यहां जाएं मोशन सेंसर के बारे में जानकारी देने वाला दस्तावेज़.

स्क्रीन के निर्देशांक के साथ सिंक करना

डिफ़ॉल्ट रूप से, स्पेशल सेंसर की रीडिंग का डेटा यह ऐसे लोकल निर्देशांक सिस्टम में मौजूद होता है जो डिवाइस से जुड़ा होता है और स्क्रीन ओरिएंटेशन के बिना जोड़ें.

हालांकि, गेम या ऑगमेंटेड और वर्चुअल रिएलिटी जैसे इस्तेमाल के कई मामलों में सेंसर रीडिंग को निर्देशांक सिस्टम में हल किया जाता है, जो इसके बजाय स्क्रीन ओरिएंटेशन से जुड़ा होता है.

पहले, सेंसर रीडिंग को स्क्रीन कोऑर्डिनेट पर फिर से मैप करने की सुविधा JavaScript में लागू करनी पड़ती थी. यह तरीका अकुशल है और इसकी वजह से वेब की जटिलता भी काफ़ी बढ़ जाती है ऐप्लिकेशन कोड; वेब ऐप्लिकेशन को स्क्रीन ओरिएंटेशन में हुए बदलावों को देखना होगा और निर्देशांक पूरे करने होंगे सेंसर की रीडिंग के लिए रूपांतरण, जो कि ओयलर कोणों के लिए करना कोई साधारण चीज़ नहीं है या क्वाटर्नियन.

जेनरिक सेंसर एपीआई, बहुत आसान और भरोसेमंद समाधान उपलब्ध कराता है! स्थानीय निर्देशांक सिस्टम यह है सभी तय स्पेशल सेंसर क्लास के लिए कॉन्फ़िगर किया जा सकता है: Accelerometer, Gyroscope, LinearAccelerationSensor, AbsoluteOrientationSensor, RelativeOrientationSensor, और Magnetometer. सेंसर ऑब्जेक्ट कंस्ट्रक्टर को referenceFrame विकल्प पास करने से, उपयोगकर्ता तय करता है कि दिखाए गए रीडिंग का समाधान device या स्क्रीन निर्देशांक.

// Sensor readings are resolved in the Device coordinate system by default.
// Alternatively, could be RelativeOrientationSensor({referenceFrame: "device"}).
const sensorRelDevice = new RelativeOrientationSensor();

// Sensor readings are resolved in the Screen coordinate system. No manual remapping is required!
const sensorRelScreen = new RelativeOrientationSensor({ referenceFrame: 'screen' });

आइए कोडिंग करते हैं!

जेनेरिक सेंसर एपीआई को इस्तेमाल करना बहुत आसान है! सेंसर इंटरफ़ेस में, सेंसर की स्थिति को कंट्रोल करने के लिए start() और stop() तरीके हैं. साथ ही, सेंसर के चालू होने, गड़बड़ियों, और नई रीडिंग के बारे में सूचनाएं पाने के लिए कई इवेंट हैंडलर हैं. कंक्रीट सेंसर क्लास आम तौर पर, रीडिंग एट्रिब्यूट को बेस में जोड़ती हैं क्लास.

डेवलपमेंट एनवायरमेंट

डेवलपमेंट के दौरान, localhost के ज़रिए सेंसर इस्तेमाल किए जा सकेंगे. अगर मोबाइल डिवाइसों के लिए ऐप्लिकेशन डेवलप किया जा रहा है, तो अपने लोकल सर्वर के लिए पोर्ट फ़ॉरवर्डिंग सेट अप करें. इसके बाद, ऐप्लिकेशन को इस्तेमाल किया जा सकता है!

कोड तैयार होने के बाद, उसे एचटीटीपीएस के साथ काम करने वाले सर्वर पर डिप्लॉय करें. GitHub Pages, एचटीटीपीएस पर दिखाए जाते हैं. इसलिए, यह आपके डेमो शेयर करने के लिए बेहतरीन प्लैटफ़ॉर्म है.

3D मॉडल रोटेशन

इस आसान उदाहरण में, हम किसी 3D मॉडल के रोटेशन क्वार्टरनियन में बदलाव करने के लिए, एब्सोल्यूट ओरिएंटेशन सेंसर के डेटा का इस्तेमाल करते हैं. model, three.js के Object3D क्लास का इंस्टेंस है, जिसमें quaternion प्रॉपर्टी है. फ़ोन के ओरिएंटेशन के डेमो में दिया गया यह कोड स्निपेट, 3D मॉडल को घुमाने के लिए, एब्सोल्यूट ओरिएंटेशन सेंसर के इस्तेमाल का तरीका दिखाता है.

function initSensor() {
  sensor = new AbsoluteOrientationSensor({ frequency: 60 });
  sensor.onreading = () => model.quaternion.fromArray(sensor.quaternion);
  sensor.onerror = (event) => {
    if (event.error.name == 'NotReadableError') {
      console.log('Sensor is not available.');
    }
  };
  sensor.start();
}

डिवाइस का ओरिएंटेशन, WebGL सीन में 3D model रोटेशन में दिखेगा.

Punchmeter

यहां दिया गया कोड स्निपेट, पंचमीटर के डेमो से लिया गया है. इसमें दिखाया गया है कि किसी डिवाइस के शुरू में स्थिर होने के आधार पर, उसके सबसे ज़्यादा वेग का हिसाब लगाने के लिए, लीनियर एक्सेलेरेशन सेंसर का इस्तेमाल कैसे किया जा सकता है.

this.maxSpeed = 0;
this.vx = 0;
this.ax = 0;
this.t = 0;

/* … */

this.accel.onreading = () => {
  let dt = (this.accel.timestamp - this.t) * 0.001; // In seconds.
  this.vx += ((this.accel.x + this.ax) / 2) * dt;

  let speed = Math.abs(this.vx);

  if (this.maxSpeed < speed) {
    this.maxSpeed = speed;
  }

  this.t = this.accel.timestamp;
  this.ax = this.accel.x;
};

मौजूदा वेग का हिसाब, त्वरण फ़ंक्शन के इंटिग्रल के अनुमान के तौर पर लगाया जाता है.

Chrome DevTools की मदद से डीबग करना और सेंसर को बदलना

कुछ मामलों में, Generic Sensor API का इस्तेमाल करने के लिए, आपको किसी फ़िज़िकल डिवाइस की ज़रूरत नहीं होती. Chrome DevTools में, डिवाइस के ओरिएंटेशन को सिम्युलेट करने के लिए बेहतरीन सुविधाएं मौजूद हैं.

निजता और सुरक्षा

सेंसर रीडिंग, संवेदनशील जानकारी होती है. इस पर नुकसान पहुंचाने वाले वेब पेजों के ज़रिए कई तरह के हमले हो सकते हैं. सामान्य सेंसर एपीआई को लागू करने पर, सुरक्षा और निजता से जुड़े संभावित जोखिमों को कम करने के लिए कुछ सीमाएं लागू की जाती हैं. उन डेवलपर को इन सीमाओं का ध्यान रखना चाहिए जो इसका इस्तेमाल करना चाहते हैं: एपीआई के बारे में ज़्यादा जानकारी देते हैं. आइए, इन चीज़ों के बारे में थोड़ा जानते हैं.

सिर्फ़ एचटीटीपीएस

Generic Sensor API एक बेहतरीन सुविधा है. इसलिए, ब्राउज़र इसे सिर्फ़ सुरक्षित कॉन्टेक्स्ट में इस्तेमाल करने की अनुमति देता है. इसका मतलब है कि जेनरिक सेंसर एपीआई का इस्तेमाल करने के लिए, आपको अपने पेज को एचटीटीपीएस के ज़रिए ऐक्सेस करना होगा. डेवलपमेंट के दौरान http://localhost से ऐसा किया जा सकता है. हालांकि, प्रोडक्शन के लिए आपको आपके सर्वर पर एचटीटीपीएस होना ज़रूरी है. सबसे सही तरीकों के बारे में जानने के लिए, सुरक्षित और सुरक्षित कलेक्शन देखें और दिशा-निर्देशों का पालन करें.

अनुमतियों की नीति का इंटिग्रेशन

Generic Sensor API में अनुमतियों की नीति का इंटिग्रेशन, किसी फ़्रेम के लिए सेंसर डेटा के ऐक्सेस को कंट्रोल करता है.

डिफ़ॉल्ट रूप से, Sensor ऑब्जेक्ट सिर्फ़ किसी मेन फ़्रेम या सेम ऑरिजिन वाले सबफ़्रेम में बनाए जा सकते हैं. इस तरह, क्रॉस-ऑरिजिन iframe को सेंसर डेटा को बिना अनुमति के पढ़ने से रोका जाता है. यह डिफ़ॉल्ट व्यवहार को सक्रिय रूप से सक्षम या अक्षम करके संशोधित किया जा सकता है. नीति से कंट्रोल होने वाली सुविधाएं शामिल न करें.

नीचे दिए गए स्निपेट में, क्रॉस-ऑरिजिन iframe को ऐक्सेलेरोमीटर डेटा का ऐक्सेस देने के बारे में बताया गया है. इसका मतलब है कि अब वहां Accelerometer या LinearAccelerationSensor ऑब्जेक्ट बनाए जा सकते हैं.

<iframe src="https://third-party.com" allow="accelerometer" />

सेंसर रीडिंग की डिलीवरी निलंबित की जा सकती है

सेंसर रीडिंग को सिर्फ़ दिखने वाले वेब पेज से ऐक्सेस किया जा सकता है. इसका मतलब है कि जब उपयोगकर्ता उससे इंटरैक्ट कर रहा हो. इसके अलावा, सेंसर डेटा को पैरंट फ़्रेम में नहीं जोड़ा जाएगा, अगर उपयोगकर्ता क्रॉस-ऑरिजिन सबफ़्रेम पर फ़ोकस में बदलाव करता है. इससे पैरंट फ़्रेम, उपयोगकर्ता के इनपुट का अनुमान नहीं लगा पाता.

आगे क्या करना है?

आने वाले समय में, कुछ खास सेंसर क्लास को लागू किया जाएगा. जैसे, ऐंबियंट लाइट सेंसर या प्रॉक्सिमिटी सेंसर; हालांकि, उस विलुप्त होने की क्षमता के कारण जेनेरिक सेंसर फ़्रेमवर्क सेंसर प्रकार.

आने वाले समय में, Generic Sensor API को बेहतर बनाना भी एक अहम काम है. फ़िलहाल, Generic Sensor स्पेसिफ़िकेशन को उम्मीदवार के तौर पर सुझाया गया है. इसका मतलब है कि इसमें सुधार करने और डेवलपर की ज़रूरत के हिसाब से नई सुविधाएं जोड़ने के लिए अब भी समय है.

आपके पास मदद करने का विकल्प है!

सेंसर की खास बातों को सुझाव के लिए चुना गया मैच्योरिटी लेवल पर पहुंचाया गया है. इसलिए, वेब और ब्राउज़र डेवलपर के सुझावों का बहुत स्वागत है. हमें बताएं कि कौनसी सुविधाएं जोड़ी जा सकती हैं या मौजूदा एपीआई में क्या बदलाव करना है.

कृपया खास जानकारी से जुड़ी समस्याओं की शिकायत भी करें Chrome को लागू करने में गड़बड़ियों के तौर पर सेव करता है.

संसाधन

• डेमो प्रोजेक्ट: https://intel.github.io/generic-sensor-demos/
• सामान्य सेंसर एपीआई स्पेसिफ़िकेशन: https://w3c.github.io/sensors/
• स्पेसिफ़िकेशन से जुड़ी समस्याएं: https://github.com/w3c/sensors/issues
• W3C के वर्किंग ग्रुप की मेलिंग सूची: public-device-apis@w3.org
• Chrome की सुविधा का स्टेटस: https://www.chromestatus.com/feature/5698781827825664
• लागू करने से जुड़ी गड़बड़ियां: http://crbug.com?q=component:Blink>Sensor

आभार

इस लेख की समीक्षा जो मेडली और केस बेस्केस ने की है. इन्होंने हीरो इमेज दी है मिस्को को, विकिमीडिया कॉमंस.