Esta página forma parte de la documentación de la plataforma de las Apps de Chrome, que dejó de estar disponible en 2020. Todavía se admite para los clientes de Enterprise y Education en ChromeOS hasta enero de 2025. Obtén más información sobre cómo migrar tu app.

Se usó la API de Cloud Translation para traducir esta página.

Bluetooth

En este documento, se describe cómo usar el Bluetooth, el enchufe Bluetooth y el Bluetooth bajo API de energía para comunicarse con dispositivos Bluetooth y de bajo consumo.

Para obtener información general sobre Bluetooth, consulta las especificaciones de Bluetooth oficiales.

Requisitos del manifiesto

Para las Apps de Chrome que usan Bluetooth, agrega la entrada Bluetooth al manifiesto y especifica, si adecuados, los UUID de los perfiles, protocolos o servicios que desea implementar junto con si quieres implementarlas con el socket o las APIs de bajo consumo.

Por ejemplo, para una implementación de socket:

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

Y para una implementación de bajo consumo:

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

Para acceder únicamente al estado del adaptador, descubrir dispositivos cercanos y obtener información básica sobre ellos, solo se requiere la entrada en sí:

"bluetooth": {}

Información del adaptador

Cómo obtener el estado del adaptador

Para obtener el estado del adaptador Bluetooth, usa el método bluetooth.getAdapterState:

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

Notificaciones de Adapter

El evento bluetooth.onAdapterStateChanged se envía cada vez que cambia el estado del adaptador. Esto puede usarse, por ejemplo, para determinar cuándo se enciende o se apaga la radio del adaptador.

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

Información del dispositivo

Cómo mostrar una lista de los dispositivos conocidos

Si quieres obtener la lista de los dispositivos que reconoce el adaptador Bluetooth, usa bluetooth.getDevices. método:

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

Se devuelven todos los dispositivos, incluidos los vinculados y los detectados recientemente. No comenzar a descubrir dispositivos nuevos (consulta Cómo descubrir dispositivos cercanos).

Recepción de notificaciones del dispositivo

En lugar de llamar repetidamente a bluetooth.getDevices, puedes usar el bluetooth.onDeviceAdded, bluetooth.onDeviceChanged y bluetooth.onDeviceRemoved para recibir notificaciones.

El evento bluetooth.onDeviceAdded se envía cada vez que el adaptador detecta un dispositivo. hace una conexión con el adaptador:

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

Al agregar un objeto de escucha para este evento, no se inicia el descubrimiento de dispositivos (consulta Cómo descubrir dispositivos cercanos dispositivos).

Los cambios en los dispositivos, incluidos aquellos detectados anteriormente que se vincularon, son notificados por el Evento bluetooth.onDeviceChanged:

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

Por último, se envía el evento bluetooth.onDeviceRemoved cada vez que un dispositivo vinculado se quita de el sistema o no se ha visto recientemente un dispositivo detectado:

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

Detectando dispositivos cercanos

Para comenzar a descubrir dispositivos cercanos, usa el método bluetooth.startDiscovery. El descubrimiento puede requiere una gran cantidad de recursos, por lo que deberías llamar a bluetooth.stopDiscovery cuando hayas terminado.

Debes llamar a bluetooth.startDiscovery cada vez que tu app necesite detectar dispositivos cercanos. No hagas la llamada condicional en la propiedad discovering de bluetooth.AdapterState. El llamada se realizará de forma correcta incluso si otra app detecta dispositivos cercanos, y garantizará que el adaptador continúa realizando descubrimientos después de que se detiene la otra app.

La información sobre cada dispositivo recién descubierto se recibe a través de bluetooth.onDeviceAdded. para cada evento. Para los dispositivos que ya se detectaron recientemente o que se vincularon anteriormente o conectado, no se enviará el evento. En su lugar, debes llamar a bluetooth.getDevices para obtener la información actual y usar el evento bluetooth.onDeviceChanged para recibir notificaciones en esa información como resultado del descubrimiento.

Ejemplo:

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

Si el usuario apaga la radio Bluetooth, todas las sesiones de detección finalizarán y no se reanudarán automáticamente cuando se enciende la radio. Si esto es importante para tu aplicación, debes ver la bluetooth.onAdapterStateChanged. Si la propiedad discovering cambia a false, entonces la app deberá volver a llamar a bluetooth.startDiscovery para reanudar la reproducción. Ten cuidado con las y la naturaleza del descubrimiento de uso intensivo de recursos.

Cómo identificar dispositivos

Se proporcionan varias opciones diferentes para identificar los dispositivos devueltos por bluetooth.getDevices y los eventos relacionados

Si el dispositivo admite la especificación de ID de dispositivo Bluetooth, se agregarán varias propiedades al el objeto Device que contiene los campos definidos por esa especificación. Ejemplo:

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

La especificación de ID de dispositivo suele ser suficiente para identificar un modelo en particular y hasta revisión de un dispositivo de un proveedor. Cuando no está presente, debes confiar en la información sobre el la clase o el tipo del dispositivo, opcionalmente combinado con el prefijo del fabricante en el address.

La mayoría de los dispositivos Bluetooth proporcionan información sobre la clase de dispositivo como un campo de bits interpretado de acuerdo con el documento Números asignados de banda base. Este campo de bits está disponible en deviceClass propiedad.

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

Analizar el campo puede ser complejo, por lo que Chrome se encarga de los tipos de dispositivo más comunes por ti y Configura el campo type. Cuando esta opción no esté disponible o no sea suficiente para tus necesidades, deberás analizar deviceClass por tu cuenta

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

Cómo usar RFCOMM y L2CAP

Las Apps de Chrome pueden establecer conexiones con cualquier dispositivo que admita los servicios RFCOMM o L2CAP. Esto incluye la mayoría de los dispositivos Bluetooth clásicos del mercado.

Conexión a un tomacorriente

Para establecer una conexión con un dispositivo, necesitas tres cosas. Un socket para realizar la conexión con bluetoothSocket.create; la dirección del dispositivo al que deseas conectarte y el UUID del servicio en sí.

Antes de realizar la conexión, debes verificar que el adaptador reconozca el dispositivo mediante bluetooth.getDevice o las APIs de detección de dispositivos.

La información necesaria para establecer la conexión subyacente, incluido si el servidor RFCOMM o Se debe usar el protocolo L2CAP y qué canal o PSM se obtiene con la detección de SDP en la dispositivo.

Ejemplo:

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

Mantén un controlador para socketId para poder enviar datos (bluetoothSocket.send) más adelante. zócalo.

Recibe y envía a un socket

La recepción de datos y el envío a un socket usa objetos ArrayBuffer. Para obtener más información sobre ArrayBuffers, consulta la descripción general, los arrays escritos en JavaScript y el instructivo How to convert ArrayBuffer desde y hacia una cadena.

Para enviar datos que tienes en arrayBuffer, usa 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")
  }
})

A diferencia del método de envío de datos, los datos se reciben en un (bluetoothSocket.onReceive. Los sockets se crean sin pausar (consulta bluetoothSocket.setPaused) por lo que el objeto de escucha de este evento generalmente se agrega entre bluetoothSocket.create y bluetoothSocket.connect

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

Recepción de errores y desconexión del socket

Para recibir notificaciones sobre errores de socket, incluida la desconexión, agrega un objeto de escucha al bluetoothSocket.onReceiveError.

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

Desconectarse de un enchufe

Para colgar la conexión y desconectar el enchufe, usa bluetoothSocket.disconnect.

chrome.bluetoothSocket.disconnect(socketId);

Servicios de publicación

Además de realizar conexiones salientes con los dispositivos, las Apps de Chrome pueden publicar servicios que se puedan en cualquier dispositivo compatible con RFCOMM o L2CAP.

Escucha en un socket

Se admiten dos tipos de servicios publicados. RFCOMM es el más utilizado y abarca las la mayoría de los dispositivos y perfiles:

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

L2CAP es la otra app y abarca otros tipos de dispositivos y usos específicos de proveedores, como el firmware la carga de datos.

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

En ambos casos, se puede pasar un bluetoothSocket.ListenOptions opcional para asignar un elemento por canal o PSM. La devolución de llamada indica un error mediante chrome.runtime.lastError y éxito de lo contrario. Mantén un handle para socketId para que luego puedas aceptar conexiones. (bluetoothSocket.onAccept) de este socket.

Acepta conexiones de clientes

Las conexiones de cliente se aceptan y pasan a tu aplicación a través del 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);
});

Deja de aceptar conexiones de clientes

Para dejar de aceptar conexiones de clientes y anular la publicación del servicio, usa bluetoothSocket.disconnect.

chrome.bluetoothSocket.disconnect(serverSocketId);

Cómo interactuar con dispositivos de bajo consumo

Bluetooth de bajo consumo o (Bluetooth Smart) es una tecnología inalámbrica destinada a reducir la energía consumo de energía. La API de Bluetooth Low Energy permite que las aplicaciones implementen la función central en una conexión de LE a un periférico. Las siguientes secciones describen cómo descubrir, conectarse y interactuar con periféricos Bluetooth de bajo consumo.

Detección de periféricos y conexión a ellos

Al igual que con los dispositivos Bluetooth tradicionales, los periféricos de LE pueden descubrirse a través de los métodos descritos en Cómo descubrir dispositivos cercanos . Un dispositivo LE se hace visible enviando paquetes de datos denominado "Datos de publicidad" y se dice que el dispositivo está en modo publicitario. Los datos de publicidad puede contener UUID de servicios disponibles en el dispositivo. Si están presentes, estos UUIDs y se puede acceder con la propiedad uuids del objeto bluetooth.Device correspondiente.

Una vez descubierto, se puede conectar un dispositivo LE llamando a bluetoothLowEnergy.connect para que la aplicación puede interactuar con sus servicios:

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

Una vez conectado, la propiedad connected del objeto bluetooth.Device correspondiente tienen el valor true. La llamada a bluetoothLowEnergy.connect establece una reclamación por parte del aplicación en la conexión física al dispositivo. Puede existir una conexión física con el dispositivo sin llamar a bluetoothLowEnergy.connect (por ejemplo, debido a otra aplicación). En en este caso, si bien tu app aún puede interactuar con los servicios del dispositivo, debería llama siempre a bluetoothLowEnergy.connect para evitar que otra aplicación desconecte el un vínculo físico.

Cuando la aplicación ya no necesite estar conectada, puede eliminar su reclamo sobre la conexión si Llamando a bluetoothLowEnergy.disconnect:

chrome.bluetoothLowEnergy.disconnect(deviceAddress);

Ten en cuenta que esto no destruirá necesariamente el enlace físico al dispositivo, ya que puede haber otros aplicaciones que tienen conexiones activas con el dispositivo. A veces, el dispositivo puede cambiar desconectado debido a razones que están fuera del control de la aplicación (por ejemplo, si el dispositivo desaparece o el usuario lo desconecta de manera explícita mediante las utilidades del sistema operativo). Tu aplicación debería observar el evento bluetooth.onDeviceChanged para recibir notificaciones de los cambios a la conexión y vuelve a conectarte si es necesario.

Una vez conectado, el dispositivo que ejecuta Chrome tendrá la función central, mientras que la se dice que el dispositivo remoto tiene la función periférico. En este punto, tu aplicación puede interactuar con los servicios en el dispositivo a través de los métodos que se describen en la siguiente sección. Nota: El Actualmente, las APIs no admiten que funcionen como periféricos de bajo consumo. las apps solo pueden implementar el rol central.

Servicios, características y descriptores

Bluetooth de bajo consumo se basa en un protocolo de solicitud-respuesta simple denominado protocolo de atributos. (ATT). Con ATT, un dispositivo central interactúa con los atributos en un dispositivo periférico. mediante un perfil de Bluetooth especial llamado Perfil de atributo genérico (GATT). GATT define los siguientes conceptos de alto nivel:

Servicio: un servicio GATT representa un conjunto de datos y los comportamientos asociados para lograr un función específica de un dispositivo. Por ejemplo, un monitor de frecuencia cardíaca suele tener al menos una "Servicio de frecuencia cardíaca". La información sobre un servicio GATT se incluye en un bluetoothLowEnergy.Service.
Característica: Una característica GATT es un elemento de datos básico que se usa para construir un servicio GATT. que contenga un valor junto con propiedades que definan cómo se puede acceder a ese valor. Por ejemplo: el "Servicio de frecuencia cardíaca" tiene la "Medición de frecuencia cardíaca" de atributos, que se usa para obtener el valor de la frecuencia cardíaca del usuario. La información sobre una característica GATT se incluye en un bluetoothLowEnergy.Characteristic.
Descriptor: un descriptor de característica GATT contiene más información sobre una característica. La información sobre un descriptor de característica GATT se incluye en un bluetoothLowEnergy.Descriptor.

La API de Bluetooth Low Energy permite que las aplicaciones encuentren información sobre la conexión de un dispositivo servicios, características y descriptores llamando a bluetoothLowEnergy.getServices, bluetoothLowEnergy.getCharacteristics y bluetoothLowEnergy.getDescriptors. Las apps pueden filtrar servicios, características y descriptores comparando su campo uuid con el UUID GATT deseado:

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

A cada servicio, característica y descriptor al que se puede acceder a través de la API se le asigna un único identificador de instancia, que se puede obtener con el campo instanceId. Este ID de instancia puede ser que se usa para identificar un objeto GATT y realizar operaciones específicas en él:

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

Eventos de servicio

Una vez que se conecta un dispositivo, Chrome descubre sus servicios. A medida que se descubre cada servicio la aplicación recibirá el valor bluetoothLowEnergy.onServiceAdded y Eventos 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 descubre todas las características y los descriptores de un servicio de forma asíncrona y envía la bluetoothLowEnergy.onServiceAdded una vez que se completó la detección. Si la conexión con un periférico, Chrome quita todos los servicios relacionados y envía la bluetoothLowEnergy.onServiceRemoved.

Algunos periféricos pueden modificar sus servicios, p.ej., las características de un servicio pueden cambiar servicios pueden agregarse y eliminarse por completo. Chrome notifica a las aplicaciones sobre estos cambios mediante el bluetoothLowEnergy.onServiceChanged, bluetoothLowEnergy.onServiceAdded y eventos bluetoothLowEnergy.onServiceRemoved.

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

    updateMyService(service);
  });

Lee y escribe el valor de una característica

Una característica GATT codifica un aspecto de su servicio. Una app central lee, actúa y modifica el estado del servicio de un periférico al operar según el valor de una característica. La característica es una secuencia de bytes y su significado se define en la especificación de alto nivel que define una característica en particular. Por ejemplo, el valor de la característica de medición de la frecuencia cardíaca codifica la frecuencia cardíaca del usuario y la cantidad total de calorías quemadas, mientras que el Body Sensor La función de ubicación codifica en qué parte del cuerpo debe usarse el sensor de frecuencia cardíaca.

Chrome proporciona el método bluetoothLowEnergy.readCharacteristicValue para leer el valor de un característica:

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

Algunas características admiten escritura, especialmente aquellas que se comportan como "puntos de control", donde el valor tiene efectos secundarios. Por ejemplo, la característica Punto de control de frecuencia cardíaca se usa para lo siguiente: Indicarle a un sensor de frecuencia cardíaca que restablezca el recuento de calorías totales quemadas y solo admite operaciones de escritura. Para para lograrlo, Chrome proporciona el método 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.
});

Los descriptores de características se comportan de la misma manera y pueden leerse o escribirse. Chrome proporciona los valores bluetoothLowEnergy.readDescriptorValue y bluetoothLowEnergy.writeDescriptorValue para leer y escribir el valor de un descriptor.

Para verificar si una característica admite operaciones de lectura o escritura, una aplicación puede verificar el properties. de un objeto bluetoothLowEnergy.Characteristic. Si bien este campo no contiene información sobre los requisitos de seguridad para acceder a un valor, describe qué valor operativa que la característica admite en general.

Administra las notificaciones de valores

Algunas características dan a conocer su valor mediante notificaciones o indicaciones. Por ejemplo, el La característica de medición del ritmo cardíaco no se puede leer ni escribir, pero envía actualizaciones sobre su el valor actual a intervalos regulares. Las aplicaciones pueden escuchar estas notificaciones utilizando el bluetoothLowEnergy.onCharacteristicValueChanged.

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

    var bytes = new Uint8Array(chrc.value);

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

Incluso si una característica admite notificaciones/indicaciones, estas no están habilitadas de forma predeterminada. Los aplicación debe llamar a bluetoothLowEnergy.startCharacteristicNotifications y bluetoothLowEnergy.stopCharacteristicNotifications para iniciar o dejar de recibir la Evento 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);
  }

Una vez que se inicien las notificaciones, la aplicación recibirá bluetoothLowEnergy.onCharacteristicValueChanged cada vez que se activa una notificación o indicación que se reciben de la característica. Si la característica admite operaciones de lectura, este evento también enviado después de una llamada exitosa a bluetoothLowEnergy.readCharacteristicValue. Esto permite que las apps para unificar el flujo de control de una actualización de valor activada a través de una solicitud de lectura y notificaciones:

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

Si una característica admite notificaciones, su campo properties contendrá el elemento propiedad "notify" o "indicate".

NOTA: Si una característica admite notificaciones/indicaciones, tendrá el Configuración de características" descriptor para habilitar o inhabilitar notificaciones. Chrome no permite para escribir en este descriptor. En su lugar, las aplicaciones deben utilizar la bluetoothLowEnergy.startCharacteristicNotifications y Métodos bluetoothLowEnergy.stopCharacteristicNotifications para controlar el comportamiento de las notificaciones.