arc: bluetooth: Implement set discoverable state

components/arc/bluetooth/arc_bluetooth_bridge.cc

 // Copyright 2016 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.
 
 #include "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <bluetooth/bluetooth.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 166 matching lines @@
 bool IsGattOffsetValid(int offset) {
   return 0 <= offset && offset < kMaxGattAttributeLength;
 }
 
 // This is needed because Android only support UUID 16 bits in advertising data.
 uint16_t GetUUID16(const BluetoothUUID& uuid) {
   // Convert xxxxyyyy-xxxx-xxxx-xxxx-xxxxxxxxxxxx to int16 yyyy
   return std::stoi(uuid.canonical_value().substr(4, 4), nullptr, 16);
 }
 
+mojo::Array<arc::mojom::BluetoothPropertyPtr> GetDiscoveryTimeoutProperty(
+    uint32_t timeout) {
+  arc::mojom::BluetoothPropertyPtr property =
+      arc::mojom::BluetoothProperty::New();
+  property->set_discovery_timeout(timeout);
+  mojo::Array<arc::mojom::BluetoothPropertyPtr> properties;
+  properties.push_back(std::move(property));
+  return properties;
+}
+
 }  // namespace
 
 namespace arc {
 
 ArcBluetoothBridge::ArcBluetoothBridge(ArcBridgeService* bridge_service)
     : ArcService(bridge_service), binding_(this), weak_factory_(this) {
   if (BluetoothAdapterFactory::IsBluetoothAdapterAvailable()) {
     VLOG(1) << "Registering bluetooth adapter.";
     BluetoothAdapterFactory::GetAdapter(base::Bind(
         &ArcBluetoothBridge::OnAdapterInitialized, weak_factory_.GetWeakPtr()));
@@ skipping 414 matching lines @@
   if (!HasBluetoothInstance())
     return;
 
   mojo::Array<mojom::BluetoothPropertyPtr> properties =
       GetAdapterProperties(type);
 
   arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
       mojom::BluetoothStatus::SUCCESS, std::move(properties));
 }
 
+void ArcBluetoothBridge::OnSetDiscoverable(bool discoverable,
+                                           bool success,
+                                           uint32_t timeout) {
+  DCHECK(CalledOnValidThread());
+
+  if (success && discoverable && timeout > 0) {
+    discoverable_off_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromSeconds(timeout),
+        base::Bind(&ArcBluetoothBridge::SetDiscoverable,
+                   weak_factory_.GetWeakPtr(), false, 0));
+  }
+
+  if (!HasBluetoothInstance())
+    return;
+
+  if (success) {
+    arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+        mojom::BluetoothStatus::SUCCESS, GetDiscoveryTimeoutProperty(timeout));
+  } else {
+    arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+        mojom::BluetoothStatus::FAIL,
+        mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0));
+  }
+}
+
+// Set discoverable state to on / off.
+// In case of turning on, start timer to turn it back off in |timeout| seconds.
+void ArcBluetoothBridge::SetDiscoverable(bool discoverable, uint32_t timeout) {
+  DCHECK(bluetooth_adapter_);
+  DCHECK(CalledOnValidThread());
+  DCHECK(!discoverable || timeout == 0);
+
+  bool currently_discoverable = bluetooth_adapter_->IsDiscoverable();
+
+  if (!discoverable && !currently_discoverable)
+    return;
+
+  if (discoverable && currently_discoverable) {
+    if (base::TimeDelta::FromSeconds(timeout) >
+        discoverable_off_timer_.GetCurrentDelay()) {
+      // Restart discoverable_off_timer_ if new timeout is greater
+      OnSetDiscoverable(true, true, timeout);
+    } else if (HasBluetoothInstance()) {
+      // Just send message to Android if new timeout is lower.
+      arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+          mojom::BluetoothStatus::SUCCESS,
+          GetDiscoveryTimeoutProperty(timeout));
+    }
+    return;
+  }
+
+  bluetooth_adapter_->SetDiscoverable(
+      discoverable,
+      base::Bind(&ArcBluetoothBridge::OnSetDiscoverable,
+                 weak_factory_.GetWeakPtr(), discoverable, true, timeout),
+      base::Bind(&ArcBluetoothBridge::OnSetDiscoverable,
+                 weak_factory_.GetWeakPtr(), discoverable, false, timeout));
+}
+
 void ArcBluetoothBridge::SetAdapterProperty(
     mojom::BluetoothPropertyPtr property) {
   DCHECK(bluetooth_adapter_);
   if (!HasBluetoothInstance())
     return;
 
-  // TODO(smbarber): Implement SetAdapterProperty
-  arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
-      mojom::BluetoothStatus::FAIL,
-      mojo::Array<mojom::BluetoothPropertyPtr>::New(0));
+  if (property->is_discovery_timeout()) {
+    uint32_t discovery_timeout = property->get_discovery_timeout();
+    if (discovery_timeout > 0) {
+      SetDiscoverable(true, discovery_timeout);
+    } else {
+      arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+          mojom::BluetoothStatus::PARM_INVALID,
+          mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0));
+    }
+  } else {
+    // TODO(puthik) Implement other case.
+    arc_bridge_service()->bluetooth()->instance()->OnAdapterProperties(
+        mojom::BluetoothStatus::UNSUPPORTED,
+        mojo::Array<arc::mojom::BluetoothPropertyPtr>::New(0));
+  }
 }
 
 void ArcBluetoothBridge::GetRemoteDeviceProperty(
     mojom::BluetoothAddressPtr remote_addr,
     mojom::BluetoothPropertyType type) {
   DCHECK(bluetooth_adapter_);
   if (!HasBluetoothInstance())
     return;
 
   std::string addr_str = remote_addr->To<std::string>();
@@ skipping 1111 matching lines @@
   LOG(WARNING) << "Bluetooth instance is too old (version " << version
                << ") need version " << version_need;
   return false;
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc