ब्लूटूथ

अहम जानकारी: Chrome सभी प्लैटफ़ॉर्म पर, 'Chrome ऐप्स' के साथ काम करने की सुविधा बंद कर देगा. Chrome ब्राउज़र और Chrome वेब स्टोर एक्सटेंशन को सपोर्ट करते रहेंगे. एलान पढ़ें और अपने ऐप्लिकेशन को माइग्रेट करने के बारे में ज़्यादा जानें.

इस दस्तावेज़ में बताया गया है कि ब्लूटूथ और ब्लूटूथ स्मार्ट डिवाइसों से संपर्क करने के लिए, ब्लूटूथ, ब्लूटूथ सॉकेट, और ब्लूटूथ Low Energy एपीआई का इस्तेमाल कैसे किया जाता है.

ब्लूटूथ के बारे में जानकारी पाने के लिए, ब्लूटूथ की आधिकारिक विशेषताएं देखें.

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

मेनिफ़ेस्ट से जुड़ी ज़रूरी शर्तें

ब्लूटूथ का इस्तेमाल करने वाले Chrome ऐप्स के लिए, मेनिफ़ेस्ट में ब्लूटूथ एंट्री जोड़ें. साथ ही, अगर सही लगे, तो उन प्रोफ़ाइलों, प्रोटोकॉल या सेवाओं के यूयूआईडी की जानकारी दें जिन्हें आपको लागू करना है. साथ ही, यह भी बताएं कि इन्हें सॉकेट और/या लो एनर्जी एपीआई की मदद से लागू करना है या नहीं.

उदाहरण के लिए, सॉकेट लागू करने के लिए:

"bluetooth": {
  "uuids": [ "1105", "1106" ],
  "socket": true
}

कम ऊर्जा का इस्तेमाल करने के लिए:

"bluetooth": {
  "uuids": [ "180D", "1809", "180F" ],
  "low_energy": true
}

केवल एडैप्टर की स्थिति ऐक्सेस करने, आस-पास मौजूद डिवाइसों को खोजने, और डिवाइसों के बारे में बुनियादी जानकारी पाने के लिए, सिर्फ़ एंट्री की ज़रूरत होती है:

"bluetooth": {}

अडैप्टर की जानकारी

अडैप्टर की स्थिति पता की जा रही है

ब्लूटूथ अडैप्टर की स्थिति जानने के लिए, bluetooth.getAdapterState तरीके का इस्तेमाल करें:

chrome.bluetooth.getAdapterState(function(adapter) {
  console.log("Adapter " + adapter.address + ": " + adapter.name);
});

अडैप्टर से जुड़ी सूचनाएं

अडैप्टर की स्थिति बदलने पर, bluetooth.onAdapterStateChanged इवेंट भेजा जाता है. उदाहरण के लिए, इसका इस्तेमाल यह पता लगाने के लिए किया जा सकता है कि अडैप्टर रेडियो कब चालू या बंद होता है.

var powered = false;
chrome.bluetooth.getAdapterState(function(adapter) {
  powered = adapter.powered;
});

chrome.bluetooth.onAdapterStateChanged.addListener(
  function(adapter) {
    if (adapter.powered != powered) {
      powered = adapter.powered;
      if (powered) {
        console.log("Adapter radio is on");
      } else {
        console.log("Adapter radio is off");
      }
    }
  });

डिवाइस की जानकारी

पहले से मालूम डिवाइसों की सूची बनाना

ब्लूटूथ अडैप्टर के साथ काम करने वाले डिवाइसों की सूची देखने के लिए, bluetooth.getDevices तरीके का इस्तेमाल करें:

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    console.log(devices[i].address);
  }
});

सभी डिवाइस लौटा दिए जाते हैं. इनमें, जोड़े गए वे डिवाइस और हाल ही में खोजे गए डिवाइस भी शामिल हैं. इससे नए डिवाइस नहीं खोजे जाएंगे. ज़्यादा जानकारी के लिए, आस-पास मौजूद डिवाइसों को खोजना लेख पढ़ें.

डिवाइस पर सूचनाएं मिल रही हैं

सूचनाएं पाने के लिए, बार-बार bluetooth.getDevices को कॉल करने के बजाय, bluetooth.onDeviceAdded, bluetooth.onDeviceChanged और bluetooth.onDeviceRemoved इवेंट का इस्तेमाल कर सकते हैं.

जब भी अडैप्टर किसी डिवाइस को खोजता है या अडैप्टर से कोई डिवाइस जोड़ता है, तो bluetooth.onDeviceAdded इवेंट को भेजा जाता है:

chrome.bluetooth.onDeviceAdded.addListener(function(device) {
  console.log(device.address);
});

इस इवेंट के लिए लिसनर जोड़ने से, डिवाइसों को खोजना शुरू नहीं होता. आस-पास मौजूद डिवाइसों को खोजना लेख पढ़ें.

डिवाइसों में होने वाले बदलावों की सूचना bluetooth.onDeviceChanged इवेंट की मदद से दी जाती है. इस इवेंट में, पहले खोजे गए डिवाइस भी शामिल होते हैं:

chrome.bluetooth.onDeviceChanged.addListener(function(device) {
  console.log(device.address);
});

आखिर में, जब भी सिस्टम से जोड़े गए किसी डिवाइस को हटाया जाता है या खोजे गए किसी डिवाइस को हाल ही में नहीं देखा जाता है, तो bluetooth.onDeviceRemoved इवेंट को तब भेजा जाता है:

chrome.bluetooth.onDeviceRemoved.addListener(function(device) {
  console.log(device.address);
});

आस-पास मौजूद डिवाइसों को खोजा जा रहा है

आस-पास मौजूद डिवाइसों को खोजने के लिए, bluetooth.startDiscovery तरीके का इस्तेमाल करें. खोजने में बहुत ज़्यादा संसाधन लग सकते हैं, इसलिए काम पूरा हो जाने पर आपको bluetooth.stopDiscovery को कॉल करना चाहिए.

जब भी आपके ऐप्लिकेशन को आस-पास मौजूद डिवाइसों को खोजने की ज़रूरत हो, तब आपको bluetooth.startDiscovery पर कॉल करना चाहिए. bluetooth.AdapterState की discovering प्रॉपर्टी पर कॉल कंडीशनल न करें. अगर कोई दूसरा ऐप्लिकेशन आस-पास मौजूद डिवाइस खोज रहा हो, तब भी कॉल सफल होगा. साथ ही, यह पक्का करेगा कि दूसरे ऐप्लिकेशन के बंद होने के बाद भी अडैप्टर उसकी खोज करना जारी रखे.

खोजे गए हर नए डिवाइस की जानकारी, bluetooth.onDeviceAdded इवेंट का इस्तेमाल करके मिलती है. ऐसे डिवाइसों के लिए इवेंट नहीं भेजा जाएगा जिन्हें हाल ही में पहले ही खोजा जा चुका है या जिन्हें पहले ही जोड़ा गया या कनेक्ट किया जा चुका है. इसके बजाय, मौजूदा जानकारी पाने के लिए आपको bluetooth.getDevices को कॉल करना चाहिए. साथ ही, उसे खोजे जाने की वजह से उस जानकारी में हुए बदलावों की सूचना पाने के लिए, bluetooth.onDeviceChanged इवेंट का इस्तेमाल करना चाहिए.

उदाहरण:

var device_names = {};
var updateDeviceName = function(device) {
  device_names[device.address] = device.name;
};
var removeDeviceName = function(device) {
  delete device_names[device.address];
}

// Add listeners to receive newly found devices and updates
// to the previously known devices.
chrome.bluetooth.onDeviceAdded.addListener(updateDeviceName);
chrome.bluetooth.onDeviceChanged.addListener(updateDeviceName);
chrome.bluetooth.onDeviceRemoved.addListener(removeDeviceName);

// With the listeners in place, get the list of devices found in
// previous discovery sessions, or any currently active ones,
// along with paired devices.
chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    updateDeviceName(devices[i]);
  }
});

// Now begin the discovery process.
chrome.bluetooth.startDiscovery(function() {
  // Stop discovery after 30 seconds.
  setTimeout(function() {
    chrome.bluetooth.stopDiscovery(function() {});
  }, 30000);
});

अगर उपयोगकर्ता ब्लूटूथ रेडियो बंद कर देता है, तो सभी खोज सेशन बंद हो जाएंगे और रेडियो चालू करने पर अपने-आप फिर से शुरू नहीं होंगे. अगर आपके ऐप्लिकेशन के लिए यह ज़रूरी है, तो आपको bluetooth.onAdapterStateChanged इवेंट देखना चाहिए. अगर discovering प्रॉपर्टी का मालिकाना हक false में बदल जाता है, तो ऐप्लिकेशन को फिर से शुरू करने के लिए bluetooth.startDiscovery को फिर से कॉल करना होगा. ऐसे संसाधनों को लेकर सावधान रहें जिनके बारे में पता करना बहुत ज़रूरी है.

डिवाइस की पहचान करना

bluetooth.getDevices और उससे जुड़े इवेंट की मदद से लौटाए गए डिवाइस की पहचान करने के लिए, कई अलग-अलग विकल्प उपलब्ध कराए गए हैं.

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

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    if (devices[0].vendorIdSource != undefined) {
      console.log(devices[0].address + ' = ' +
                  devices[0].vendorIdSource + ':' +
                  devices[0].vendorId.toString(16) + ':' +
                  devices[0].productId.toString(16) + ':' +
                  devices[0].deviceId.toString(16));
    }
  }
});

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

ज़्यादातर ब्लूटूथ डिवाइस, बेसबैंड असाइंड नंबर्स दस्तावेज़ के हिसाब से बिट फ़ील्ड के रूप में जानकारी देने वाले डिवाइस की क्लास की जानकारी देते हैं. यह बिट-फ़ील्ड, deviceClass प्रॉपर्टी में उपलब्ध है.

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    if (devices[0].vendorIdSource != undefined) {
      console.log(devices[0].address + ' = ' +
                  devices[0].deviceClass.toString(16));
    }
  }
});

फ़ील्ड को पार्स करना मुश्किल हो सकता है. इसलिए, आम तौर पर इस्तेमाल होने वाले डिवाइसों के लिए Chrome इसे आपके लिए मैनेज करता है और type फ़ील्ड को सेट करता है. अगर यह सुविधा उपलब्ध नहीं है या आपके काम की नहीं है, तो आपको deviceClass को खुद पार्स करना होगा.

chrome.bluetooth.getDevices(function(devices) {
  for (var i = 0; i < devices.length; i++) {
    if (devices[0].vendorIdSource != undefined) {
      console.log(devices[0].address + ' = ' + devices[0].type);
    }
  }
});

RFCOMM और L2CAP का इस्तेमाल करना

Chrome ऐप्लिकेशन, ऐसे किसी भी डिवाइस से कनेक्ट कर सकते हैं जिस पर RFCOMM या L2CAP सेवाएं काम करती हैं. इसमें बाज़ार में मौजूद ज़्यादातर क्लासिक ब्लूटूथ डिवाइस शामिल हैं.

सॉकेट से कनेक्ट करना

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

कनेक्ट करने से पहले, आपको यह पुष्टि कर लेनी चाहिए कि अडैप्टर को डिवाइस के बारे में पता है या नहीं. इसके लिए, bluetooth.getDevice या डिवाइस डिस्कवरी एपीआई का इस्तेमाल करें.

बुनियादी कनेक्शन बनाने के लिए ज़रूरी जानकारी. इसमें यह जानकारी शामिल होती है कि क्या RFCOMM या L2CAP प्रोटोकॉल का इस्तेमाल किया जाना चाहिए और डिवाइस पर SDP डिस्कवरी का इस्तेमाल करके, किस चैनल या PSM को लिया जाना चाहिए.

उदाहरण:

var uuid = '1105';
var onConnectedCallback = function() {
  if (chrome.runtime.lastError) {
    console.log("Connection failed: " + chrome.runtime.lastError.message);
  } else {
    // Profile implementation here.
  }
};

chrome.bluetoothSocket.create(function(createInfo) {
  chrome.bluetoothSocket.connect(createInfo.socketId,
    device.address, uuid, onConnectedCallback);
});

shortcutsId के लिए एक हैंडल रखें, ताकि आप बाद में इस सॉकेट पर डेटा (bluetoothSocket.send) भेज सकें.

सॉकेट से मिल रहा है और उस पर भेजा जा रहा है

किसी सॉकेट से डेटा पाने और उसे किसी सॉकेट में भेजने में, ArrayBuffer ऑब्जेक्ट का इस्तेमाल होता है. ArrayBuffers के बारे में जानने के लिए खास जानकारी, JavaScript से टाइप की गई अरे, और ट्यूटोरियल देखें. इसके अलावा, अरे को स्ट्रिंग से और स्ट्रिंग में बदलने का तरीका भी देखें.

arrayBuffer में मौजूद डेटा भेजने के लिए, bluetoothSocket.send का इस्तेमाल करें:

chrome.bluetoothSocket.send(socketId, arrayBuffer, function(bytes_sent) {
  if (chrome.runtime.lastError) {
    console.log("Send failed: " + chrome.runtime.lastError.message);
  } else {
    console.log("Sent " + bytes_sent + " bytes")
  }
})

डेटा भेजने के तरीके के उलट, डेटा को एक इवेंट (bluetoothSocket.onReceive) में पाया जाता है. सॉकेट, फिर से चालू किए जाते हैं (bluetoothSocket.setPaused देखें), ताकि इस इवेंट के लिए लिसनर को आम तौर पर bluetoothSocket.create और bluetoothSocket.connect के बीच जोड़ा जा सके.

chrome.bluetoothSocket.onRecieve.addListener(function(receiveInfo) {
  if (receiveInfo.socketId != socketId)
    return;
  // receiveInfo.data is an ArrayBuffer.
});

सॉकेट से जुड़ी गड़बड़ियां और डिसकनेक्ट हो रहे हैं

डिसकनेक्ट करने और सॉकेट की गड़बड़ियों की सूचना पाने के लिए, bluetoothSocket.onReceiveError इवेंट में एक लिसनर जोड़ें.

chrome.bluetoothSocket.onReceiveError.addListener(function(errorInfo) {
  // Cause is in errorInfo.error.
  console.log(errorInfo.errorMessage);
});

सॉकेट से डिसकनेक्ट किया जा रहा है

कनेक्शन बंद करने और सॉकेट डिसकनेक्ट करने के लिए, bluetoothSocket.disconnect का इस्तेमाल करें.

chrome.bluetoothSocket.disconnect(socketId);

पब्लिश करने से जुड़ी सेवाएं

डिवाइसों से आउटबाउंड कनेक्शन बनाने के अलावा, Chrome Apps ऐसी सेवाओं को भी पब्लिश कर सकता है जिनका इस्तेमाल RFCOMM या L2CAP का इस्तेमाल करने वाले किसी भी डिवाइस पर किया जा सकता है.

सॉकेट पर सुनना

पब्लिश की जा चुकी सेवाएं दो तरह की होती हैं. आम तौर पर, RFCOMM का इस्तेमाल सबसे ज़्यादा किया जाता है. साथ ही, इनमें कई तरह के डिवाइस और प्रोफ़ाइलें शामिल होती हैं:

var uuid = '1105';
chrome.bluetoothSocket.create(function(createInfo) {
  chrome.bluetoothSocket.listenUsingRfcomm(createInfo.socketId,
    uuid, onListenCallback);
});

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

var uuid = '0b87367c-f188-47cd-bc20-a5f4f70973c6';
chrome.bluetoothSocket.create(function(createInfo) {
  chrome.bluetoothSocket.listenUsingL2cap(createInfo.socketId,
    uuid, onListenCallback);
});

दोनों मामलों में, किसी खास चैनल या PSM को बांटने के लिए, एक वैकल्पिक bluetoothSocket.ListenOptions पास किया जा सकता है. कॉलबैक chrome.runtime.lastError के ज़रिए गड़बड़ी दिखाता है और अगर ऐसा नहीं है, तो यह बताता है कि गड़बड़ी ठीक हो गई है. shortcutsId का हैंडल रखें, ताकि आप बाद में इस सॉकेट से कनेक्शन (bluetoothSocket.onAccept) स्वीकार कर सकें.

क्लाइंट कनेक्शन स्वीकार करना

क्लाइंट कनेक्शन स्वीकार किए जाते हैं और उन्हें bluetoothSocket.onAccept इवेंट के ज़रिए आपके ऐप्लिकेशन को भेजा जाता है.

chrome.bluetoothSocket.onAccept.addListener(function(acceptInfo) {
  if (info.socketId != serverSocketId)
    return;

  // Say hello...
  chrome.bluetoothSocket.send(acceptInfo.clientSocketId,
    data, onSendCallback);

  // Accepted sockets are initially paused,
  // set the onReceive listener first.
  chrome.bluetoothSocket.onReceive.addListener(onReceive);
  chrome.bluetoothSocket.setPaused(false);
});

क्लाइंट कनेक्शन स्वीकार करना बंद करें

क्लाइंट कनेक्शन स्वीकार करना बंद करने और सेवा को अनपब्लिश करने के लिए, bluetoothSocket.disconnect का इस्तेमाल करें.

chrome.bluetoothSocket.disconnect(serverSocketId);

कम ऊर्जा वाले डिवाइसों से इंटरैक्ट करना

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

सहायक डिवाइस (जैसे, कीबोर्ड, माउस, मॉनिटर, वेबकैम वगैरह) खोजना और उनसे कनेक्ट करना

पारंपरिक ब्लूटूथ डिवाइसों की तरह, LE सहायक डिवाइस (जैसे, कीबोर्ड, माउस, मॉनिटर, वेबकैम वगैरह) खोजने के लिए, आस-पास मौजूद डिवाइसों को खोजने का तरीका बताया गया है . LE डिवाइस, "विज्ञापन डेटा" नाम के डेटा पैकेट भेजकर खुद को खोजे जाने लायक बनाता है. डिवाइस को विज्ञापन मोड में कहा जाता है. विज्ञापन डेटा में डिवाइस पर उपलब्ध सेवाओं के यूयूआईडी शामिल हो सकते हैं. मौजूद होने पर, इन यूयूआईडी को इससे जुड़े bluetooth.Device ऑब्जेक्ट की uuids प्रॉपर्टी का इस्तेमाल करके ऐक्सेस किया जा सकेगा.

पता चलने के बाद, LE डिवाइस को bluetoothLowEnergy.connect पर कॉल करके कनेक्ट किया जा सकता है. इससे ऐप्लिकेशन, इसकी सेवाओं का इस्तेमाल कर पाएगा:

chrome.bluetooth.onDeviceAdded.addListener(function(device) {
  var uuid = '0000180d-0000-1000-8000-00805f9b34fb';
  if (!device.uuids || device.uuids.indexOf(uuid) < 0)
    return;

  // The device has a service with the desired UUID.
  chrome.bluetoothLowEnergy.connect(device.address, function () {
    if (chrome.runtime.lastError) {
      console.log('Failed to connect: ' + chrome.runtime.lastError.message);
      return;
    }

    // Connected! Do stuff...
    ...
  });
});

कनेक्ट होने के बाद, इससे जुड़े bluetooth.Device ऑब्जेक्ट की connected प्रॉपर्टी की वैल्यू true होगी. bluetoothLowEnergy.connect पर कॉल करने से ऐप्लिकेशन का डिवाइस के फ़िज़िकल कनेक्शन से दावा किया जाता है. डिवाइस के साथ एक फ़िज़िकल कनेक्शन कभी भी bluetoothLowEnergy.connect को कॉल किए बिना मौजूद रह सकता है (उदाहरण के लिए, किसी दूसरे ऐप्लिकेशन की वजह से). इस स्थिति में, आपका ऐप्लिकेशन अब भी डिवाइस की सेवाओं से इंटरैक्ट कर सकता है, लेकिन इसे हमेशा bluetoothLowEnergy.connect को कॉल करना चाहिए, ताकि किसी दूसरे ऐप्लिकेशन को फ़िज़िकल लिंक को डिसकनेक्ट करने से रोका जा सके.

जब आपके ऐप्लिकेशन को कनेक्ट करने की ज़रूरत न हो, तब यह bluetoothLowEnergy.disconnect को कॉल करके कनेक्शन पर अपना दावा हटा सकता है:

chrome.bluetoothLowEnergy.disconnect(deviceAddress);

ध्यान दें कि इससे डिवाइस का फ़िज़िकल लिंक खत्म नहीं होगा, क्योंकि ऐसे दूसरे ऐप्लिकेशन भी हो सकते हैं जिनके डिवाइस से ऐक्टिव कनेक्शन होते हैं. कभी-कभी डिवाइस, ऐसी वजहों से डिसकनेक्ट हो सकता है जो ऐप्लिकेशन के कंट्रोल से बाहर होती हैं (उदाहरण के लिए, अगर डिवाइस खो जाता है या ऑपरेटिंग सिस्टम की सुविधाओं के ज़रिए उपयोगकर्ता के ज़रिए साफ़ तौर पर डिसकनेक्ट हो जाता है). कनेक्शन में हुए बदलावों की सूचना पाने और ज़रूरी होने पर फिर से कनेक्ट करने के लिए, आपके ऐप्लिकेशन को bluetooth.onDeviceChanged इवेंट को देखना चाहिए.

कनेक्ट होने के बाद, Chrome चलाने वाला डिवाइस तथाकथित सेंट्रल रोल में होगा, जबकि रिमोट डिवाइस को पैरिफ़रल रोल में माना जाता है. ऐसा होने पर, आपका ऐप्लिकेशन नीचे दिए गए तरीकों का इस्तेमाल करके डिवाइस पर मौजूद सेवाओं के साथ इंटरैक्ट कर सकता है. ध्यान दें: फ़िलहाल, एपीआई, एलई सहायक डिवाइस (जैसे, कीबोर्ड, माउस, मॉनिटर, वेबकैम वगैरह) के तौर पर काम नहीं करते. इनमें, ऐप्लिकेशन सिर्फ़ मुख्य भूमिका को लागू कर सकते हैं.

सेवाएं, विशेषताएं, और जानकारी

ब्लूटूथ की कम एनर्जी, अनुरोध की प्रतिक्रिया के आसान प्रोटोकॉल पर आधारित होती है. इस प्रोटोकॉल को एट्रिब्यूट प्रोटोकॉल (ATT) कहा जाता है. ATT का इस्तेमाल करके, एक सेंट्रल डिवाइस अपने सहायक डिवाइस (जैसे, कीबोर्ड, माउस, मॉनिटर, वेबकैम वगैरह) पर एट्रिब्यूट से इंटरैक्ट करता है. इसके लिए, वह जेनरिक एट्रिब्यूट प्रोफ़ाइल (GATT) नाम की एक खास ब्लूटूथ प्रोफ़ाइल के मुताबिक काम करता है. GATT के बारे में इन हाई लेवल कॉन्सेप्ट के बारे में बताता है:

• सेवा: GATT सेवा, किसी डिवाइस के किसी खास फ़ंक्शन को पूरा करने के लिए, डेटा का कलेक्शन और उससे जुड़े व्यवहार दिखाती है. उदाहरण के लिए, आम तौर पर धड़कन की दर मापने वाले मॉनिटर में कम से कम एक "धड़कन की दर बताने वाली सेवा" होगी. GATT सेवा के बारे में जानकारी, bluetoothLowEnergy.Service ऑब्जेक्ट में मौजूद है.
• खासियत: GATT की विशेषता, GATT सेवा को बनाने के लिए इस्तेमाल किया जाने वाला बेसिक डेटा एलिमेंट है. इसमें एक वैल्यू और ऐसी प्रॉपर्टी होती हैं जो यह तय करती हैं कि उस वैल्यू को कैसे ऐक्सेस किया जा सकता है. उदाहरण के लिए, "धड़कन की दर की सेवा" में "धड़कन की दर मापने" की विशेषता होती है. इसका इस्तेमाल, उपयोगकर्ता की धड़कन की दर की वैल्यू पाने के लिए किया जाता है. GATT की विशेषता के बारे में जानकारी, bluetoothLowEnergy.Characteristic ऑब्जेक्ट में मौजूद होती है.
• ब्यौरा देने वाला: GATT की विशेषता के ब्यौरे में विशेषता के बारे में ज़्यादा जानकारी होती है. GATT की विशेषता के बारे में बताने वाली जानकारी, bluetoothLowEnergy.Descriptor ऑब्जेक्ट में मौजूद है.

ब्लूटूथ Low Energy API की मदद से, ऐप्लिकेशन किसी डिवाइस की सेवाओं, विशेषताओं, और डिस्क्रिप्टर के बारे में जानकारी खोज सकते हैं. ऐसा करने के लिए, bluetoothLowEnergy.getServices, bluetoothLowEnergy.getCharacteristics, और bluetoothLowEnergy.getDescriptors को कॉल करें. ऐप्लिकेशन सेवाओं, विशेषताओं, और जानकारी देने वालों के हिसाब से फ़िल्टर कर सकते हैं. ऐसा करने के लिए, उनके uuid फ़ील्ड की तुलना अपनी पसंद के GATT UUID से कर सकते हैं:

chrome.bluetoothLowEnergy.getServices(deviceAddress, function(services) {
  ...
  for (var i = 0; i < services.length; i++) {
    if (services[i].uuid == HEART_RATE_SERVICE_UUID) {
      heartRateService = services[i];
      break;
    }
  }
  ...
});

एपीआई से ऐक्सेस की जा सकने वाली हर सेवा, विशेषता, और डिस्क्रिप्टर को एक यूनीक इंस्टेंस आइडेंटिफ़ायर असाइन किया जाता है. इसे instanceId फ़ील्ड का इस्तेमाल करके हासिल किया जा सकता है. इस इंस्टेंस आईडी का इस्तेमाल, GATT ऑब्जेक्ट की पहचान करने और उस पर खास कार्रवाइयां करने के लिए किया जा सकता है:

chrome.bluetoothLowEnergy.getCharacteristics(heartRateService.instanceId,
                                             function(chracteristics) {
  ...
  for (var i = 0; i < characteristics.length; i++) {
    if (characteristics[i].uuid == HEART_RATE_MEASUREMENT_UUID) {
      measurementChar = characteristics[i];
      break;
    }
  }
  ...
  chrome.bluetoothLowEnergy.getDescriptors(measurementChar.instanceId,
                                           function(descriptors) {
    ...
  });
});

सेवा से जुड़े इवेंट

डिवाइस के कनेक्ट हो जाने के बाद, Chrome अपनी सेवाएं खोजेगा. हर सेवा का पता चलने और उसे हटाने पर, ऐप्लिकेशन को bluetoothLowEnergy.onServiceAdded और bluetoothLowEnergy.onServiceRemoved के इवेंट दिखाए जाएंगे:

  var initializeService = function(service) {
    if (!service) {
      console.log('No service selected!');
      // Reset UI, etc.
      ...
      return;
    }

    myService = service;

    // Get all the characteristics and descriptors and bootstrap the app.
    ...
  };

  chrome.bluetoothLowEnergy.onServiceAdded.addListener(function(service) {
    if (service.uuid == MY_SERVICE_UUID)
      initializeService(service);
  });

  chrome.bluetoothLowEnergy.onServiceRemoved.addListener(function(service) {
    if (service.instanceId == myService.instanceId)
      initializeService(null);
  });

Chrome, किसी सेवा की सभी विशेषताओं और डिस्क्रिप्टर को एसिंक्रोनस तरीके से खोजता है. साथ ही, पता लगाने की प्रोसेस पूरी हो जाने पर bluetoothLowEnergy.onServiceAdded इवेंट को भेजता है. अगर किसी सहायक डिवाइस (जैसे, कीबोर्ड, माउस, मॉनिटर, वेबकैम वगैरह) से कनेक्शन खत्म हो जाता है, तो Chrome सभी संबंधित सेवाएं हटा देता है और bluetoothLowEnergy.onServiceRemoved इवेंट भेज देता है.

कुछ सहायक डिवाइस (जैसे, कीबोर्ड, माउस, मॉनिटर, वेबकैम वगैरह) अपनी सेवाओं में बदलाव कर सकते हैं. उदाहरण के लिए, किसी सेवा की विशेषताएं बदल सकती हैं या सेवाएं पूरी तरह से जोड़ी या हटाई जा सकती हैं. Chrome, इन बदलावों के बारे में ऐप्लिकेशन को सूचना देने के लिए, bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded, और bluetoothLowEnergy.onServiceRemoved इवेंट इस्तेमाल करता है.

  chrome.bluetoothLowEnergy.onServiceChanged.addListener(function(service) {
    if (service.instanceId != myService.instanceId)
      return;

    updateMyService(service);
  });

किसी विशेषता के मान को पढ़ना और लिखना

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

किसी खासियत की वैल्यू पढ़ने के लिए, Chrome bluetoothLowEnergy.readCharacteristicValue तरीका इस्तेमाल करता है:

chrome.bluetoothLowEnergy.readCharacteristicValue(chrc.instanceId,
                                                  function(result) {
  if (chrome.runtime.lastError) {
    console.log('Failed to read value: ' + chrome.runtime.lastError.message);
    return;
  }

  var bytes = new Uint8Array(result.value);

  // Do stuff with the bytes.
  ...
});

कुछ विशेषताएं रिकॉर्ड की जा सकती हैं, खास तौर पर वे जो "कंट्रोल पॉइंट" की तरह काम करती हैं, जहां वैल्यू लिखने के खराब नतीजे होते हैं. उदाहरण के लिए, धड़कन की दर कंट्रोल पॉइंट की सुविधा का इस्तेमाल, धड़कन की दर का पता लगाने वाले सेंसर को यह बताने के लिए किया जाता है कि खर्च की गई कुल कैलोरी का डेटा रीसेट किया जा सके और सिर्फ़ लिखने के लिए इसका इस्तेमाल किया जा सके. ऐसा करने के लिए, Chrome bluetoothLowEnergy.writeCharacteristicValue तरीका इस्तेमाल करता है:

var myBytes = new Uint8Array([ ... ]);
chrome.bluetoothLowEnergy.writeCharacteristicValue(chrc.instanceId,
                                                   myBytes.buffer,
                                                   function() {
  if (chrome.runtime.lastError) {
    console.log('Failed to write value: ' +
                chrome.runtime.lastError.message);
    return;
  }

  // Value is written now.
});

खासियत बताने वाले डिस्क्रिप्टर एक ही तरह से काम करते हैं. साथ ही, वे आसानी से पढ़े जा सकते हैं और/या उनमें लिखा जा सकता है. Chrome, किसी डिस्क्रिप्टर की वैल्यू को पढ़ने और लिखने के लिए, bluetoothLowEnergy.readDescriptorValue और bluetoothLowEnergy.writeDescriptorValue के तरीके उपलब्ध कराता है.

यह जानने के लिए कि किसी एट्रिब्यूट में रीड या राइटिंग की सुविधा काम करती है या नहीं, कोई ऐप्लिकेशन bluetoothLowEnergy.Characteristic ऑब्जेक्ट के properties फ़ील्ड की जांच कर सकता है. इस फ़ील्ड में, किसी वैल्यू को ऐक्सेस करने के लिए सुरक्षा से जुड़ी ज़रूरी शर्तों की जानकारी नहीं होती. हालांकि, इससे यह पता चलता है कि सामान्य तौर पर, यह सुविधा किस वैल्यू के लिए काम करती है.

वैल्यू से जुड़ी सूचनाएं मैनेज करना

कुछ विशेषताएं, सूचनाओं या संकेतों का इस्तेमाल करके इन फ़ायदों के बारे में बताती हैं. उदाहरण के लिए, धड़कन की दर मापने की विशेषता को पढ़ा या लिखा नहीं जा सकता. हालांकि, इसकी मौजूदा वैल्यू को नियमित अंतराल पर अपडेट किया जाता है. ऐप्लिकेशन इन सूचनाओं को bluetoothLowEnergy.onCharacteristicValueChanged इवेंट का इस्तेमाल करके सुन सकते हैं.

  chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
      function(chrc) {
    if (chrc.instanceId != myCharId)
      return;

    var bytes = new Uint8Array(chrc.value);

    // Do stuff with the bytes.
    ...
  });

भले ही, किसी विशेषता में सूचनाएं/निर्देश काम करते हों, तब भी वे डिफ़ॉल्ट रूप से चालू नहीं होती हैं. किसी ऐप्लिकेशन को bluetoothLowEnergy.onCharacteristicValueChanged के इवेंट को शुरू या बंद करने के लिए, bluetoothLowEnergy.startCharacteristicNotifications और bluetoothLowEnergy.stopCharacteristicNotifications के तरीकों का इस्तेमाल करने का इस्तेमाल किया जाना चाहिए.

  // Start receiving characteristic value notifications.
  var notifying = false;
  chrome.bluetoothLowEnergy.startCharacteristicNotifications(chrc.instanceId,
                                                             function() {
    if (chrome.runtime.lastError) {
      console.log('Failed to enable notifications: ' +
                  chrome.runtime.lastError.message);
      return;
    }

    notifying = true;
  });

  ...

  // No longer interested in notifications from this characteristic.
  if (notifying) {
    chrome.bluetoothLowEnergy.stopCharacteristicNotifications(
        chrc.instanceId);
  }

सूचनाएं मिलने की प्रोसेस शुरू होने के बाद, जब भी सुविधा से कोई सूचना या संकेत मिलेगा, ऐप्लिकेशन को bluetoothLowEnergy.onCharacteristicValueChanged इस्तेमाल किया जाएगा. अगर एट्रिब्यूट में रीड की सुविधा काम करती है, तो यह इवेंट भी bluetoothLowEnergy.readCharacteristicValue को कॉल किए जाने के बाद भेजा जाएगा. इसकी मदद से ऐप्लिकेशन, वैल्यू के उस अपडेट के कंट्रोल फ़्लो को एक साथ कर पाते हैं जिसे पढ़ने का अनुरोध और सूचनाएं मिलने पर ट्रिगर होता है:

  chrome.bluetoothLowEnergy.onCharacteristicValueChanged.addListener(
      function(chrc) {
    // Process the value.
    ...
  });

  chrome.bluetoothLowEnergy.startCharacteristicNotifications(chrc.instanceId,
                                                             function() {
    // Notifications started. Read the initial value.
    chrome.bluetoothLowEnergy.readCharacteristicValue(chrc.instanceId,
                                                      function(result) {
      ...
      // No need to do anything here since onCharacteristicValueChanged
      // will handle it.
    });
  });

अगर किसी विशेषता में सूचनाएं पाने की सुविधा उपलब्ध है, तो उसके properties फ़ील्ड में "notify" या "indicate" प्रॉपर्टी मौजूद होगी.

ध्यान दें: अगर कोई विशेषता सूचनाओं/संकेतों के साथ काम करती है, तो सूचनाओं को चालू/बंद करने के लिए उसमें "क्लाइंट खास बात वाला कॉन्फ़िगरेशन" डिस्क्रिप्टर होगा. Chrome, ऐप्लिकेशन को इस डिस्क्रिप्टर में लिखने की अनुमति नहीं देता है. इसके बजाय, ऐप्लिकेशन को सूचना के व्यवहार को कंट्रोल करने के लिए, bluetoothLowEnergy.startCharacteristicNotifications और bluetoothLowEnergy.stopCharacteristicNotifications के तरीकों का इस्तेमाल करना चाहिए.