ब्लूटूथ

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

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

ब्लूटूथ के बारे में बैकग्राउंड की जानकारी के लिए, आधिकारिक ब्लूटूथ से जुड़ी खास बातें देखें.

ध्यान दें: 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 या डिवाइस खोज API.

अंतर्निहित कनेक्शन स्थापित करने के लिए आवश्यक जानकारी, जिसमें यह भी शामिल है कि क्या RFCOMM या L2CAP प्रोटोकॉल का इस्तेमाल किया जाना चाहिए. साथ ही, यह भी बताएं कि एसडीपी डिस्कवरी की मदद से किस चैनल या पीएसएम को डिवाइस.

उदाहरण:

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);
});

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

से प्राप्त कर रहा है और सॉकेट पर भेज रहा है

सॉकेट से डेटा पाने और उसे भेजने के लिए, ArrayBuffer ऑब्जेक्ट का इस्तेमाल किया जाता है. अरेबफ़र के बारे में जानने के लिए, 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 ऐप्स ऐसी सेवाएं प्रकाशित कर सकता है जो RFCOMM या L2CAP की सुविधा वाले किसी भी डिवाइस में इस्तेमाल किया जा सकता है.

सॉकेट में बैठकर सुना जा रहा है

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

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);
});

दोनों मामलों में, एक वैकल्पिक bluetoothSocket.ListenOptions दिया जा सकता है: चैनल या पीएसएम का इस्तेमाल करें. कॉलबैक, chrome.runtime.lastError के ज़रिए हुई गड़बड़ी और सक्सेस के बारे में बताता है नहीं तो. सॉकेट आईडी का हैंडल रखें, ताकि आप बाद में कनेक्शन स्वीकार कर सकें (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 सहायक डिवाइसों का पता लगाने के लिए, यहां बताए गए तरीके इस्तेमाल किए जा सकते हैं आस-पास के डिवाइसों को खोजने में . एक एलई डिवाइस, डेटा पैकेट भेजकर खुद को खोजे जाने लायक बनाता है जिसे "विज्ञापन डेटा" कहते हैं और डिवाइस को विज्ञापन मोड में बताया गया हो. विज्ञापन का डेटा डिवाइस पर उपलब्ध सेवाओं के यूयूआईडी शामिल हो सकते हैं. अगर ये यूयूआईडी मौजूद हैं, तो इसे 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 चल रहा है उसे सेंट्रल रोल कहा जाता है, जबकि रिमोट डिवाइस को सहायक डिवाइस की भूमिका में माना जाता है. इस समय, आपका ऐप्लिकेशन डिवाइस पर सेवाएं पाने के लिए, नीचे दिए गए तरीकों का इस्तेमाल करें. ध्यान दें: फ़िलहाल, एपीआई किसी LE सहायक डिवाइस के तौर पर काम नहीं करते; ऐप्लिकेशन, सिर्फ़ मुख्य भूमिका को लागू कर सकते हैं.

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

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

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

ब्लूटूथ कम ऊर्जा एपीआई, ऐप्लिकेशन को डिवाइस के बारे में जानकारी ढूंढने देता है सेवाओं, विशेषताओं, और डिस्क्रिप्टर के बारे में जानने के लिए, 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 किसी डिस्क्रिप्टर की वैल्यू को पढ़ने और लिखने के तरीके.

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

वैल्यू की सूचनाओं को मैनेज करना

कुछ विशेषताएं, सूचनाओं या संकेतों का इस्तेमाल करके उनकी अहमियत के बारे में बताती हैं. उदाहरण के लिए धड़कन की दर मापने की विशेषता पढ़ने लायक या लिखने लायक नहीं है. हालांकि, यह नियमित अंतरालों पर मौजूदा वैल्यू. ऐप्लिकेशन इन सूचनाओं को सुनने के लिए इसका इस्तेमाल कर सकते हैं: 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.startCharacteristicNotifications पर कॉल करना चाहिए और bluetoothLowEnergy.stopCharacteristicNotifications इसे पाने की सुविधा चालू या बंद करने के तरीक़े bluetoothLowEnergy.onCharacteristicValueChanged इवेंट.

  // 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 के तरीके.