Add included services

components/net/bluetooth_thread.rs

@@ -22,6 +22,7 @@ const ADAPTER_ERROR: &'static str = "No adapter found";
 const DEVICE_ERROR: &'static str = "No device found";
 const DEVICE_MATCH_ERROR: &'static str = "No device found, that matches the given options";
 const PRIMARY_SERVICE_ERROR: &'static str = "No primary service found";
+const INCLUDED_SERVICE_ERROR: &'static str = "No included service found";
 const CHARACTERISTIC_ERROR: &'static str = "No characteristic found";
 const DESCRIPTOR_ERROR: &'static str = "No descriptor found";
 const VALUE_ERROR: &'static str = "No characteristic or descriptor found with that id";
@@ -149,6 +150,12 @@ impl BluetoothManager {
                 BluetoothMethodMsg::GetPrimaryServices(device_id, uuid, sender) => {
                     self.get_primary_services(device_id, uuid, sender)
                 },
+                BluetoothMethodMsg::GetIncludedService(service_id, uuid, sender) => {
+                    self.get_included_service(service_id, uuid, sender)
+                },
+                BluetoothMethodMsg::GetIncludedServices(service_id, uuid, sender) => {
+                    self.get_included_services(service_id, uuid, sender)
+                },
                 BluetoothMethodMsg::GetCharacteristic(service_id, uuid, sender) => {
                     self.get_characteristic(service_id, uuid, sender)
                 },
@@ -478,6 +485,66 @@ impl BluetoothManager {
         let _ = sender.send(Ok(services_vec));
     }
 
+    fn get_included_service(&mut self,
+                            service_id: String,
+                            uuid: String,
+                            sender: IpcSender<BluetoothResult<BluetoothServiceMsg>>) {
+        let mut adapter = match self.get_or_create_adapter() {
+            Some(a) => a,
+            None => return drop(sender.send(Err(String::from(ADAPTER_ERROR)))),
+        };
+        let primary_service = match self.get_gatt_service(&mut adapter, &service_id) {
+            Some(s) => s,
+            None => return drop(sender.send(Err(String::from(PRIMARY_SERVICE_ERROR)))),
+        };
+        let services = primary_service.get_includes().unwrap_or(vec!());
+        for service in services {
+            if let Ok(service_uuid) = service.get_uuid() {
+                if uuid == service_uuid {
+                    return drop(sender.send(Ok(BluetoothServiceMsg {
+                                                   uuid: uuid,
+                                                   is_primary: service.is_primary().unwrap_or(false),
+                                                   instance_id: service.get_object_path(),
+                                               })));
+                }
+            }
+        }
+        return drop(sender.send(Err(String::from(INCLUDED_SERVICE_ERROR))));
+    }
+
+    fn get_included_services(&mut self,
+                             service_id: String,
+                             uuid: Option<String>,
+                             sender: IpcSender<BluetoothResult<BluetoothServicesMsg>>) {
+        let mut adapter = match self.get_or_create_adapter() {
+            Some(a) => a,
+            None => return drop(sender.send(Err(String::from(ADAPTER_ERROR)))),
+        };
+        let primary_service = match self.get_gatt_service(&mut adapter, &service_id) {
+            Some(s) => s,
+            None => return drop(sender.send(Err(String::from(PRIMARY_SERVICE_ERROR)))),
+        };
+        let services = primary_service.get_includes().unwrap_or(vec!());
+        let mut services_vec = vec!();
+        for service in services {
+            if let Ok(service_uuid) = service.get_uuid() {
+                services_vec.push(BluetoothServiceMsg {
+                                      uuid: service_uuid,
+                                      is_primary: service.is_primary().unwrap_or(false),
+                                      instance_id: service.get_object_path(),
+                                  });
+            }
+        }
+        if let Some(uuid) = uuid {
+            services_vec.retain(|ref s| s.uuid == uuid);
+        }
+        if services_vec.is_empty() {
+            return drop(sender.send(Err(String::from(INCLUDED_SERVICE_ERROR))));
+        }
+
+        let _ = sender.send(Ok(services_vec));
+    }
+
     fn get_characteristic(&mut self,
                           service_id: String,
                           uuid: String,

components/net_traits/bluetooth_thread.rs

@@ -60,6 +60,8 @@ pub enum BluetoothMethodMsg {
     GATTServerDisconnect(String, IpcSender<BluetoothResult<bool>>),
     GetPrimaryService(String, String, IpcSender<BluetoothResult<BluetoothServiceMsg>>),
     GetPrimaryServices(String, Option<String>, IpcSender<BluetoothResult<BluetoothServicesMsg>>),
+    GetIncludedService(String, String, IpcSender<BluetoothResult<BluetoothServiceMsg>>),
+    GetIncludedServices(String, Option<String>, IpcSender<BluetoothResult<BluetoothServicesMsg>>),
     GetCharacteristic(String, String, IpcSender<BluetoothResult<BluetoothCharacteristicMsg>>),
     GetCharacteristics(String, Option<String>, IpcSender<BluetoothResult<BluetoothCharacteristicsMsg>>),
     GetDescriptor(String, String, IpcSender<BluetoothResult<BluetoothDescriptorMsg>>),

components/script/dom/bluetoothremotegattservice.rs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDeviceMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTServiceMethods;
 use dom::bindings::error::Error::Type;
@@ -12,7 +13,7 @@ use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bluetoothcharacteristicproperties::BluetoothCharacteristicProperties;
 use dom::bluetoothdevice::BluetoothDevice;
 use dom::bluetoothremotegattcharacteristic::BluetoothRemoteGATTCharacteristic;
-use dom::bluetoothuuid::{BluetoothCharacteristicUUID, BluetoothUUID};
+use dom::bluetoothuuid::{BluetoothCharacteristicUUID, BluetoothServiceUUID, BluetoothUUID};
 use ipc_channel::ipc::{self, IpcSender};
 use net_traits::bluetooth_thread::BluetoothMethodMsg;
 use util::str::DOMString;
@@ -155,4 +156,59 @@ impl BluetoothRemoteGATTServiceMethods for BluetoothRemoteGATTService {
             },
         }
     }
+
+    // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattservice-getincludedservice
+    fn GetIncludedService(&self,
+                          service: BluetoothServiceUUID)
+                          -> Fallible<Root<BluetoothRemoteGATTService>> {
+        let uuid = try!(BluetoothUUID::GetService(self.global().r(), service)).to_string();
+        let (sender, receiver) = ipc::channel().unwrap();
+        self.get_bluetooth_thread().send(
+            BluetoothMethodMsg::GetIncludedService(self.get_instance_id(),
+                                                   uuid,
+                                                   sender)).unwrap();
+        let service = receiver.recv().unwrap();
+        match service {
+            Ok(service) => {
+                Ok(BluetoothRemoteGATTService::new(self.global().r(),
+                                                   &self.device.get(),
+                                                   DOMString::from(service.uuid),
+                                                   service.is_primary,
+                                                   service.instance_id))
+            },
+            Err(error) => {
+                Err(Type(error))
+            },
+        }
+    }
+
+    // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattservice-getincludedservices
+    fn GetIncludedServices(&self,
+                          service: Option<BluetoothServiceUUID>)
+                          -> Fallible<Vec<Root<BluetoothRemoteGATTService>>> {
+        let mut uuid: Option<String> = None;
+        if let Some(s) = service {
+            uuid = Some(try!(BluetoothUUID::GetService(self.global().r(), s)).to_string())
+        };
+        let (sender, receiver) = ipc::channel().unwrap();
+        self.get_bluetooth_thread().send(
+            BluetoothMethodMsg::GetIncludedServices(self.get_instance_id(),
+                                                    uuid,
+                                                    sender)).unwrap();
+        let services_vec = receiver.recv().unwrap();
+        match services_vec {
+            Ok(service_vec) => {
+                Ok(service_vec.into_iter()
+                              .map(|service| BluetoothRemoteGATTService::new(self.global().r(),
+                                                                             &self.device.get(),
+                                                                             DOMString::from(service.uuid),
+                                                                             service.is_primary,
+                                                                             service.instance_id))
+                              .collect())
+            },
+            Err(error) => {
+                Err(Type(error))
+            },
+        }
+    }
 }

components/script/dom/webidls/BluetoothRemoteGATTService.webidl

@@ -17,6 +17,10 @@ interface BluetoothRemoteGATTService {
     //Promise<BluetoothRemoteGATTCharacteristic>getCharacteristic(BluetoothCharacteristicUUID characteristic);
     //Promise<sequence<BluetoothRemoteGATTCharacteristic>>
     //getCharacteristics(optional BluetoothCharacteristicUUID characteristic);
+    [Throws]
+    BluetoothRemoteGATTService getIncludedService(BluetoothServiceUUID service);
+    [Throws]
+    sequence<BluetoothRemoteGATTService> getIncludedServices(optional BluetoothServiceUUID service);
     //Promise<BluetoothRemoteGATTService>getIncludedService(BluetoothServiceUUID service);
     //Promise<sequence<BluetoothRemoteGATTService>>getIncludedServices(optional BluetoothServiceUUID service);
 };

components/servo/Cargo.lock

@@ -164,7 +164,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "blurz"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "dbus 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -446,9 +446,9 @@ dependencies = [
 [[package]]
 name = "device"
 version = "0.0.1"
-source = "git+https://github.com/servo/devices#cac0952154f65b416acef273a6d1099421ce113e"
+source = "git+https://github.com/servo/devices#3c39846a019eeed939eb7090096631254e6b5efc"
 dependencies = [
- "blurz 0.1.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "blurz 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]