chrome.bluetoothLowEnergy: Introduce connect and disconnect methods.

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.cc

 // 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.
 
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/utils.h"
 #include "chrome/common/extensions/api/bluetooth/bluetooth_manifest_data.h"
 #include "chrome/common/extensions/api/bluetooth_low_energy.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/permissions/permissions_data.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 
 namespace apibtle = extensions::api::bluetooth_low_energy;
 
 namespace extensions {
 
 namespace {
 
 const char kErrorAdapterNotInitialized[] =
     "Could not initialize Bluetooth adapter";
+const char kErrorAlreadyConnected[] = "Already connected";
+const char kErrorNotConnected[] = "Not connected";
 const char kErrorNotFound[] = "Instance not found";
 const char kErrorOperationFailed[] = "Operation failed";
 const char kErrorPermissionDenied[] = "Permission denied";
 const char kErrorPlatformNotSupported[] =
     "This operation is not supported on the current platform";
 
 // Returns the correct error string based on error status |status|. This is used
 // to set the value of |chrome.runtime.lastError.message| and should not be
 // passed |BluetoothLowEnergyEventRouter::kStatusSuccess|.
 std::string StatusToString(BluetoothLowEnergyEventRouter::Status status) {
   switch (status) {
     case BluetoothLowEnergyEventRouter::kStatusErrorPermissionDenied:
       return kErrorPermissionDenied;
     case BluetoothLowEnergyEventRouter::kStatusErrorNotFound:
       return kErrorNotFound;
+    case BluetoothLowEnergyEventRouter::kStatusErrorAlreadyConnected:
+      return kErrorAlreadyConnected;
+    case BluetoothLowEnergyEventRouter::kStatusErrorNotConnected:
+      return kErrorNotConnected;
     case BluetoothLowEnergyEventRouter::kStatusSuccess:
       NOTREACHED();
       break;
     default:
       return kErrorOperationFailed;
   }
   return "";
 }
 
 extensions::BluetoothLowEnergyEventRouter* GetEventRouter(
@@ skipping 65 matching lines @@
   if (!event_router->InitializeAdapterAndInvokeCallback(base::Bind(
           &DoWorkCallback,
           base::Bind(&BluetoothLowEnergyExtensionFunction::DoWork, this)))) {
     SetError(kErrorAdapterNotInitialized);
     return false;
   }
 
   return true;
 }
 
+bool BluetoothLowEnergyConnectFunction::DoWork() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BluetoothLowEnergyEventRouter* event_router =
+      GetEventRouter(browser_context());
+
+  // The adapter must be initialized at this point, but return an error instead
+  // of asserting.
+  if (!event_router->HasAdapter()) {
+    SetError(kErrorAdapterNotInitialized);
+    SendResponse(false);
+    return false;
+  }
+
+  scoped_ptr<apibtle::Connect::Params> params(
+      apibtle::Connect::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
+
+  bool persistent = false;  // Not persistent by default.
+  apibtle::ConnectProperties* properties = params.get()->properties.get();
+  if (properties)
+    persistent = properties->persistent;
+
+  event_router->Connect(
+      persistent,
+      GetExtension(),
+      params->device_address,
+      base::Bind(&BluetoothLowEnergyConnectFunction::SuccessCallback, this),
+      base::Bind(&BluetoothLowEnergyConnectFunction::ErrorCallback, this));
+
+  return true;
+}
+
+void BluetoothLowEnergyConnectFunction::SuccessCallback() {
+  SendResponse(true);
+}
+
+void BluetoothLowEnergyConnectFunction::ErrorCallback(
+    BluetoothLowEnergyEventRouter::Status status) {
+  SetError(StatusToString(status));
+  SendResponse(false);
+}
+
+bool BluetoothLowEnergyDisconnectFunction::DoWork() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BluetoothLowEnergyEventRouter* event_router =
+      GetEventRouter(browser_context());
+
+  // The adapter must be initialized at this point, but return an error instead
+  // of asserting.
+  if (!event_router->HasAdapter()) {
+    SetError(kErrorAdapterNotInitialized);
+    SendResponse(false);
+    return false;
+  }
+
+  scoped_ptr<apibtle::Disconnect::Params> params(
+      apibtle::Disconnect::Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
+
+  event_router->Disconnect(
+      GetExtension(),
+      params->device_address,
+      base::Bind(&BluetoothLowEnergyDisconnectFunction::SuccessCallback, this),
+      base::Bind(&BluetoothLowEnergyDisconnectFunction::ErrorCallback, this));
+
+  return true;
+}
+
+void BluetoothLowEnergyDisconnectFunction::SuccessCallback() {
+  SendResponse(true);
+}
+
+void BluetoothLowEnergyDisconnectFunction::ErrorCallback(
+    BluetoothLowEnergyEventRouter::Status status) {
+  SetError(StatusToString(status));
+  SendResponse(false);
+}
+
 bool BluetoothLowEnergyGetServiceFunction::DoWork() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
@@ skipping 256 matching lines @@
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   scoped_ptr<apibtle::ReadCharacteristicValue::Params> params(
       apibtle::ReadCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->characteristic_id;
-  BluetoothLowEnergyEventRouter::Status status =
-      event_router->ReadCharacteristicValue(
-          GetExtension(),
-          instance_id_,
-          base::Bind(&BluetoothLowEnergyReadCharacteristicValueFunction::
-                         SuccessCallback,
-                     this),
-          base::Bind(
-              &BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback,
-              this));
-  if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
-  }
+  event_router->ReadCharacteristicValue(
+      GetExtension(),
+      instance_id_,
+      base::Bind(
+          &BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback,
+          this),
+      base::Bind(
+          &BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback,
+          this));
 
   return true;
 }
 
 void BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback() {
   // Obtain info on the characteristic and see whether or not the characteristic
   // is still around.
   apibtle::Characteristic characteristic;
   BluetoothLowEnergyEventRouter::Status status =
       GetEventRouter(browser_context())
@@ skipping 29 matching lines @@
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   scoped_ptr<apibtle::WriteCharacteristicValue::Params> params(
       apibtle::WriteCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8> value(params->value.begin(), params->value.end());
-
-  BluetoothLowEnergyEventRouter::Status status =
-      event_router->WriteCharacteristicValue(
-          GetExtension(),
-          params->characteristic_id,
-          value,
-          base::Bind(&BluetoothLowEnergyWriteCharacteristicValueFunction::
-                         SuccessCallback,
-                     this),
-          base::Bind(&BluetoothLowEnergyWriteCharacteristicValueFunction::
-                         ErrorCallback,
-                     this));
-  if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
-  }
+  event_router->WriteCharacteristicValue(
+      GetExtension(),
+      params->characteristic_id,
+      value,
+      base::Bind(
+          &BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback,
+          this),
+      base::Bind(
+          &BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback,
+          this));
 
   return true;
 }
 
 void BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback() {
   results_ = apibtle::WriteCharacteristicValue::Results::Create();
   SendResponse(true);
 }
 
 void BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback(
@@ skipping 14 matching lines @@
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   scoped_ptr<apibtle::ReadDescriptorValue::Params> params(
       apibtle::ReadDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->descriptor_id;
-  BluetoothLowEnergyEventRouter::Status status =
-      event_router->ReadDescriptorValue(
-          GetExtension(),
-          instance_id_,
-          base::Bind(
-              &BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback,
-              this),
-          base::Bind(
-              &BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback,
-              this));
-  if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
-  }
+  event_router->ReadDescriptorValue(
+      GetExtension(),
+      instance_id_,
+      base::Bind(
+          &BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback,
+          this),
+      base::Bind(&BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback,
+                 this));
 
   return true;
 }
 
 void BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback() {
   // Obtain info on the descriptor and see whether or not the descriptor is
   // still around.
   apibtle::Descriptor descriptor;
   BluetoothLowEnergyEventRouter::Status status =
       GetEventRouter(browser_context())
@@ skipping 29 matching lines @@
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
   scoped_ptr<apibtle::WriteDescriptorValue::Params> params(
       apibtle::WriteDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8> value(params->value.begin(), params->value.end());
-
-  BluetoothLowEnergyEventRouter::Status status =
-      event_router->WriteDescriptorValue(
-          GetExtension(),
-          params->descriptor_id,
-          value,
-          base::Bind(
-              &BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback,
-              this),
-          base::Bind(
-              &BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback,
-              this));
-  if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
-    SetError(StatusToString(status));
-    SendResponse(false);
-    return false;
-  }
+  event_router->WriteDescriptorValue(
+      GetExtension(),
+      params->descriptor_id,
+      value,
+      base::Bind(
+          &BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback,
+          this),
+      base::Bind(&BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback,
+                 this));
 
   return true;
 }
 
 void BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback() {
   results_ = apibtle::WriteDescriptorValue::Results::Create();
   SendResponse(true);
 }
 
 void BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback(
     BluetoothLowEnergyEventRouter::Status status) {
   SetError(StatusToString(status));
   SendResponse(false);
 }
 
 }  // namespace api
 }  // namespace extensions