API Bindings for GATT server functionality.

chrome/common/extensions/api/bluetooth_low_energy.idl

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // The <code>chrome.bluetoothLowEnergy</code> API is used to communicate with
 // Bluetooth Smart (Low Energy) devices using the
 // <a href="https://developer.bluetooth.org/TechnologyOverview/Pages/GATT.aspx">
 // Generic Attribute Profile (GATT)</a>.
 namespace bluetoothLowEnergy {
   // Values representing the possible properties of a characteristic.
   enum CharacteristicProperty {broadcast, read, writeWithoutResponse, write,
                                notify, indicate, authenticatedSignedWrites,
                                extendedProperties, reliableWrite,
                                writableAuxiliaries};
 
   // Type of advertisement. If 'broadcast' is chosen, the sent advertisement
   // type will be ADV_NONCONN_IND and the device will broadcast with a random
   // MAC Address. If set to 'peripheral', the advertisement type will be
   // ADV_IND or ADV_SCAN_IND and the device will broadcast with real Bluetooth
   // Adapter's MAC Address.
   enum AdvertisementType {broadcast, peripheral};
 
+  // Result of a register or unregister service call.
+  enum ServiceResult {
+    // The service operation was successful.
+    success,
+    // The service that is being registered is already regsitered.
+    alreadyRegistered,
+    // The service that is being unregistered is not regsitered.
+    notRegistered
+  };
+
+  // Represents a bluetooth central device that is connected to the local GATT
+  // server.
+  dictionary Device {
+    // The address of the device, in the format 'XX:XX:XX:XX:XX:XX'.
+    DOMString address;
+
+    // The human-readable name of the device.
+    DOMString? name;
+
+    // The class of the device, a bit-field defined by
+    // http://www.bluetooth.org/en-us/specification/assigned-numbers/baseband.
+    long? deviceClass;
+  };
+
   // Represents a peripheral's Bluetooth GATT Service, a collection of
   // characteristics and relationships to other services that encapsulate
   // the behavior of part of a device.
   dictionary Service {
     // The UUID of the service, e.g. 0000180d-0000-1000-8000-00805f9b34fb.
     DOMString uuid;
 
     // Indicates whether the type of this service is primary or secondary.
     boolean isPrimary;
 
-    // Indicates whether this service represents a local service hosted by the
-    // application and available to other peripherals, or a remote service
-    // hosted and received from a remote peripheral.
-    [nodoc] boolean isLocal;
-
     // Returns the identifier assigned to this service. Use the instance ID to
     // distinguish between services from a peripheral with the same UUID and
     // to make function calls that take in a service identifier. Present, if
     // this instance represents a remote service.
     DOMString? instanceId;
 
     // The device address of the remote peripheral that the GATT service belongs
     // to. Present, if this instance represents a remote service.
     DOMString? deviceAddress;
   };
 
   // Represents a GATT characteristic, which is a basic data element that
   // provides further information about a peripheral's service.
   dictionary Characteristic {
     // The UUID of the characteristic, e.g.
     // 00002a37-0000-1000-8000-00805f9b34fb.
     DOMString uuid;
 
-    // Indicates whether this characteristic represents a local characteristic
-    // hosted by the application and available to other peripherals, or a remote
-    // characteristic hosted and received from a remote peripheral.
-    [nodoc] boolean isLocal;
-
     // The GATT service this characteristic belongs to.
-    Service service;
+    Service? service;
 
     // The properties of this characteristic.
     CharacteristicProperty[] properties;
 
     // Returns the identifier assigned to this characteristic. Use the instance
     // ID to distinguish between characteristics from a peripheral with the same
     // UUID and to make function calls that take in a characteristic identifier.
     // Present, if this instance represents a remote characteristic.
     DOMString? instanceId;
 
     // The currently cached characteristic value. This value gets updated when
     // the value of the characteristic is read or updated via a notification
     // or indication.
     ArrayBuffer? value;
   };
 
   // Represents a GATT characteristic descriptor, which provides further
   // information about a characteristic's value.
   dictionary Descriptor {
     // The UUID of the characteristic descriptor, e.g.
     // 00002902-0000-1000-8000-00805f9b34fb.
     DOMString uuid;
 
-    // Indicates whether this descriptor represents a local descriptor
-    // hosted by the application and available to other peripherals, or a remote
-    // descriptor hosted and received from a remote peripheral.
-    [nodoc] boolean isLocal;
-
     // The GATT characteristic this descriptor belongs to.
-    Characteristic characteristic;
+    Characteristic? characteristic;
 
     // Returns the identifier assigned to this descriptor. Use the instance ID
     // to distinguish between descriptors from a peripheral with the same UUID
     // and to make function calls that take in a descriptor identifier. Present,
     // if this instance represents a remote characteristic.
     DOMString? instanceId;
 
     // The currently cached descriptor value. This value gets updated when
     // the value of the descriptor is read.
     ArrayBuffer? value;
@@ skipping 48 matching lines @@
     // List of UUIDs to include in the "Solicit UUIDs" field of the Advertising
     // Data. These UUIDs can be of the 16bit, 32bit or 128 formats.
     DOMString[]? solicitUuids;
 
     // List of service data to be included in "Service Data" fields of the advertising
     // data.
     ServiceData[]? serviceData;
   };
 
   callback CharacteristicCallback = void(Characteristic result);
+  callback CreateCharacteristicCallback = void(DOMString characteristicId);
   callback CharacteristicsCallback = void(Characteristic[] result);
   callback DescriptorCallback = void(Descriptor result);
+  callback CreateDescriptorCallback = void(DOMString descriptorId);
   callback DescriptorsCallback = void(Descriptor[] result);
   callback ResultCallback = void();
   callback ServiceCallback = void(Service result);
+  callback CreateServiceCallback = void(DOMString serviceId);
   callback ServicesCallback = void(Service[] result);
+  callback ServiceResultCallback = void(ServiceResult result);
   callback RegisterAdvertisementCallback = void (long advertisementId);
+  callback ValueCallback = void(ArrayBuffer value);
 
   // These functions all report failures via chrome.runtime.lastError.
   interface Functions {
     // Establishes a connection between the application and the device with the
     // given address. A device may be already connected and its GATT services
     // available without calling <code>connect</code>, however, an app that
     // wants to access GATT services of a device should call this function to
     // make sure that a connection to the device is maintained. If the device
     // is not connected, all GATT services of the device will be discovered
     // after a successful call to <code>connect</code>.
@@ skipping 11 matching lines @@
     // |deviceAddress| : The Bluetooth address of the remote device.
     // |callback| : Called when the disconnect request has completed.
     static void disconnect(DOMString deviceAddress,
                            optional ResultCallback callback);
 
     // Get the GATT service with the given instance ID.
     // |serviceId| : The instance ID of the requested GATT service.
     // |callback| : Called with the requested Service object.
     static void getService(DOMString serviceId, ServiceCallback callback);
 
+    // Create a locally hosted GATT service. This service can be registered
+    // to be available on a local GATT server.
+    // |service| : The service to create.
+    // |callback| : Called with the created services's unique ID.
+    static void createService(Service service, CreateServiceCallback callback);
+
     // Get all the GATT services that were discovered on the remote device with
     // the given device address.
     // |deviceAddress| : The Bluetooth address of the remote device whose GATT
     // services should be returned.
     // |callback| : Called with the list of requested Service objects.
     static void getServices(DOMString deviceAddress, ServicesCallback callback);
 
     // Get the GATT characteristic with the given instance ID that belongs to
     // the given GATT service, if the characteristic exists.
     // |characteristicId| : The instance ID of the requested GATT
     // characteristic.
     // |callback| : Called with the requested Characteristic object.
     static void getCharacteristic(DOMString characteristicId,
                                   CharacteristicCallback callback);
 
+    // Create a locally hosted GATT characteristic. This characteristic must
+    // be hosted under a valid service. If the service ID is not valid, the
+    // lastError will be set.
+    // |characteristic| : The characteristic to create.
+    // |serviceId| : ID of the service to create this characteristic for.
+    // |callback| : Called with the created characteristic's unique ID.
+    static void createCharacteristic(Characteristic characteristic,
+                                        DOMString serviceId,
+                                        CreateCharacteristicCallback callback);
+
     // Get a list of all discovered GATT characteristics that belong to the
     // given service.
     // |serviceId| : The instance ID of the GATT service whose characteristics
     // should be returned.
     // |callback| : Called with the list of characteristics that belong to the
     // given service.
     static void getCharacteristics(DOMString serviceId,
                                    CharacteristicsCallback callback);
 
     // Get a list of GATT services that are included by the given service.
     // |serviceId| : The instance ID of the GATT service whose included
     // services should be returned.
     // |callback| : Called with the list of GATT services included from the
     // given service.
     static void getIncludedServices(DOMString serviceId,
                                     ServicesCallback callback);
 
     // Get the GATT characteristic descriptor with the given instance ID.
     // |descriptorId| : The instance ID of the requested GATT characteristic
     // descriptor.
     // |callback| : Called with the requested Descriptor object.
     static void getDescriptor(DOMString descriptorId,
                               DescriptorCallback callback);
 
+    // Create a locally hosted GATT descriptor. This descriptor must
+    // be hosted under a valid characteristic. If the characteristic ID is not
+    // valid, the lastError will be set.
+    // |descriptor| : The descriptor to create.
+    // |characteristicId| : ID of the characteristic to create this descriptor
+    // for.
+    // |callback| : Called with the created descriptor's unique ID.
+    static void createDescriptor(Descriptor descriptor,
+                                    DOMString characteristicId,
+                                    CreateDescriptorCallback callback);
+
     // Get a list of GATT characteristic descriptors that belong to the given
     // characteristic.
     // |characteristicId| : The instance ID of the GATT characteristic whose
     // descriptors should be returned.
     // |callback| : Called with the list of descriptors that belong to the given
     // characteristic.
     static void getDescriptors(DOMString characteristicId,
                                DescriptorsCallback callback);
 
     // Retrieve the value of a specified characteristic from a remote
@@ skipping 52 matching lines @@
     // peripheral.
     // |descriptorId| : The instance ID of the GATT characteristic descriptor
     // whose value should be written to.
     // |value| : The value that should be sent to the remote descriptor as part
     // of the write request.
     // |callback| : Called when the write request has completed.
     static void writeDescriptorValue(DOMString descriptorId,
                                      ArrayBuffer value,
                                      ResultCallback callback);
 
+    // Register the given service with the local GATT server. If the service
+    // ID is invalid, the lastError will be set.
+    // |serviceId| : Unique ID of a created service.
+    // |callback| : Callback with the result of the register operation.
+    static void registerService(DOMString serviceId,
+        ServiceResultCallback callback);
+
+    // Unregister the given service with the local GATT server. If the service
+    // ID is invalid, the lastError will be set.
+    // |serviceId| : Unique ID of a current registered service.
+    // |callback| : Callback with the result of the register operation.
+    static void unregisterService(DOMString serviceId,
+        ServiceResultCallback callback);
+
     // Create an advertisement and register it for advertising. To call this
     // function, the app must have the bluetooth:low_energy and
     // bluetooth:peripheral permissions set to true. Additionally this API
     // is only available to auto launched apps in Kiosk Mode of by setting
     // the 'enable-ble-advertising-in-apps' flag.
     // See https://developer.chrome.com/apps/manifest/bluetooth
     // Note: On some hardware, central and peripheral modes at the same time is
     // supported but on hardware that doesn't support this, making this call
     // will switch the device to peripheral mode. In the case of hardware which
     // does not support both central and peripheral mode, attempting to use the
@@ skipping 40 matching lines @@
     // |characteristic| : The GATT characteristic whose value has changed.
     static void onCharacteristicValueChanged(Characteristic characteristic);
 
     // Fired when the value of a remote GATT characteristic descriptor changes,
     // usually as a result of a read request. This event exists
     // mostly for convenience and will always be sent after a successful
     // call to $(ref:readDescriptorValue).
     // |descriptor| : The GATT characteristic descriptor whose value has
     // changed.
     static void onDescriptorValueChanged(Descriptor descriptor);
+
+    // Fired when a connected central device requests to read the value of a
+    // characteristic registered on the local GATT server.
+    // Calling both the valueCallback and errorCallback will have undefined
+    // results. Calling neither will cause a timeout and the device may
+    // disconnect.
+    // |device| : The bluetooth device that is requesting this read.
+    // |characteristic| : The GATT characteristic whose value is requested.
+    // |valueCallback| : Callback to call with the value.
+    // |errorCallback| : Callback to call if the read failed.
+    static void onCharacteristicReadRequest(
+        Device device, Characteristic characteristic,
+        ValueCallback valueCallback, ResultCallback errorCallback);
+
+    // Fired when a connected central device requests to write the value of a
+    // characteristic registered on the local GATT server.
+    // Calling both the successCallback and errorCallback will have undefined
+    // results. Calling neither will cause a timeout and the device may
+    // disconnect.
+    // |device| : The bluetooth device that is requesting this write.
+    // |characteristic| : The GATT characteristic whose value is being written.
+    // |successCallback| : Callback to call if the write was successful.
+    // |errorCallback| : Callback to call if the write failed.
+    static void onCharacteristicWriteRequest(
+        Device device, Characteristic characteristic, ArrayBuffer value,
+        ResultCallback successCallback, ResultCallback errorCallback);
+
+    // Fired when a connected central device requests to read the value of a
+    // descriptor registered on the local GATT server.
+    // Calling both the valueCallback and errorCallback will have undefined
+    // results. Calling neither will cause a timeout and the device may
+    // disconnect.
+    // |device| : The bluetooth device that is requesting this read.
+    // |descriptor| : The GATT descriptor whose value is requested.
+    // |valueCallback| : Callback to call with the value.
+    // |errorCallback| : Callback to call if the read failed.
+    static void onDescriptorReadRequest(
+        Device device, Descriptor descriptor, ValueCallback valueCallback,
+        ResultCallback errorCallback);
+
+    // Fired when a connected central device requests to write the value of a
+    // descriptor registered on the local GATT server.
+    // Calling both the successCallback and errorCallback will have undefined
+    // results. Calling neither will cause a timeout and the device may
+    // disconnect.
+    // |device| : The bluetooth device that is requesting this write.
+    // |descriptor| : The GATT descriptor whose value is being written.
+    // |successCallback| : Callback to call if the write was successful.
+    // |errorCallback| : Callback to call if the write failed.
+    static void onDescriptorWriteRequest(
+        Device device, Descriptor descriptor, ArrayBuffer value,
+        ResultCallback successCallback, ResultCallback errorCallback);
+
   };
 };