extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_api.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
   6
   7 #include "base/bind.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/strings/stringprintf.h"
  10 #include "content/public/browser/browser_thread.h"
  11 #include "extensions/browser/api/bluetooth_low_energy/utils.h"
  12 #include "extensions/browser/event_router.h"
  13 #include "extensions/common/api/bluetooth/bluetooth_manifest_data.h"
  14 #include "extensions/common/api/bluetooth_low_energy.h"
  15 #include "extensions/common/permissions/permissions_data.h"
  16
  17 using content::BrowserContext;
  18 using content::BrowserThread;
  19
  20 namespace apibtle = extensions::core_api::bluetooth_low_energy;
  21
  22 namespace extensions {
  23
  24 namespace {
  25
  26 const char kErrorAdapterNotInitialized[] =
  27     "Could not initialize Bluetooth adapter";
  28 const char kErrorAlreadyConnected[] = "Already connected";
  29 const char kErrorAlreadyNotifying[] = "Already notifying";
  30 const char kErrorAuthenticationFailed[] = "Authentication failed";
  31 const char kErrorCanceled[] = "Request canceled";
  32 const char kErrorGattNotSupported[] = "Operation not supported by this service";
  33 const char kErrorHigherSecurity[] = "Higher security needed";
  34 const char kErrorInProgress[] = "In progress";
  35 const char kErrorInsufficientAuthorization[] = "Insufficient authorization";
  36 const char kErrorInvalidLength[] = "Invalid attribute value length";
  37 const char kErrorNotConnected[] = "Not connected";
  38 const char kErrorNotFound[] = "Instance not found";
  39 const char kErrorNotNotifying[] = "Not notifying";
  40 const char kErrorOperationFailed[] = "Operation failed";
  41 const char kErrorPermissionDenied[] = "Permission denied";
  42 const char kErrorPlatformNotSupported[] =
  43     "This operation is not supported on the current platform";
  44 const char kErrorTimeout[] = "Operation timed out";
  45 const char kErrorUnsupportedDevice[] =
  46     "This device is not supported on the current platform";
  47
  48 // Returns the correct error string based on error status |status|. This is used
  49 // to set the value of |chrome.runtime.lastError.message| and should not be
  50 // passed |BluetoothLowEnergyEventRouter::kStatusSuccess|.
  51 std::string StatusToString(BluetoothLowEnergyEventRouter::Status status) {
  52   switch (status) {
  53     case BluetoothLowEnergyEventRouter::kStatusErrorPermissionDenied:
  54       return kErrorPermissionDenied;
  55     case BluetoothLowEnergyEventRouter::kStatusErrorNotFound:
  56       return kErrorNotFound;
  57     case BluetoothLowEnergyEventRouter::kStatusErrorAlreadyConnected:
  58       return kErrorAlreadyConnected;
  59     case BluetoothLowEnergyEventRouter::kStatusErrorAlreadyNotifying:
  60       return kErrorAlreadyNotifying;
  61     case BluetoothLowEnergyEventRouter::kStatusErrorNotConnected:
  62       return kErrorNotConnected;
  63     case BluetoothLowEnergyEventRouter::kStatusErrorInsufficientAuthorization:
  64       return kErrorInsufficientAuthorization;
  65     case BluetoothLowEnergyEventRouter::kStatusErrorNotNotifying:
  66       return kErrorNotNotifying;
  67     case BluetoothLowEnergyEventRouter::kStatusErrorInProgress:
  68       return kErrorInProgress;
  69     case BluetoothLowEnergyEventRouter::kStatusErrorAuthenticationFailed:
  70       return kErrorAuthenticationFailed;
  71     case BluetoothLowEnergyEventRouter::kStatusErrorHigherSecurity:
  72       return kErrorHigherSecurity;
  73     case BluetoothLowEnergyEventRouter::kStatusErrorCanceled:
  74       return kErrorCanceled;
  75     case BluetoothLowEnergyEventRouter::kStatusErrorTimeout:
  76       return kErrorTimeout;
  77     case BluetoothLowEnergyEventRouter::kStatusErrorUnsupportedDevice:
  78       return kErrorUnsupportedDevice;
  79     case BluetoothLowEnergyEventRouter::kStatusErrorInvalidLength:
  80       return kErrorInvalidLength;
  81     case BluetoothLowEnergyEventRouter::kStatusErrorGattNotSupported:
  82       return kErrorGattNotSupported;
  83     case BluetoothLowEnergyEventRouter::kStatusSuccess:
  84       NOTREACHED();
  85       break;
  86     default:
  87       return kErrorOperationFailed;
  88   }
  89   return "";
  90 }
  91
  92 extensions::BluetoothLowEnergyEventRouter* GetEventRouter(
  93     BrowserContext* context) {
  94   DCHECK_CURRENTLY_ON(BrowserThread::UI);
  95   return extensions::BluetoothLowEnergyAPI::Get(context)->event_router();
  96 }
  97
  98 void DoWorkCallback(const base::Callback<bool()>& callback) {
  99   DCHECK(!callback.is_null());
 100   callback.Run();
 101 }
 102
 103 }  // namespace
 104
 105
 106 static base::LazyInstance<BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI> >
 107     g_factory = LAZY_INSTANCE_INITIALIZER;
 108
 109 // static
 110 BrowserContextKeyedAPIFactory<BluetoothLowEnergyAPI>*
 111 BluetoothLowEnergyAPI::GetFactoryInstance() {
 112   return g_factory.Pointer();
 113 }
 114
 115 // static
 116 BluetoothLowEnergyAPI* BluetoothLowEnergyAPI::Get(BrowserContext* context) {
 117   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 118   return GetFactoryInstance()->Get(context);
 119 }
 120
 121 BluetoothLowEnergyAPI::BluetoothLowEnergyAPI(BrowserContext* context)
 122     : event_router_(new BluetoothLowEnergyEventRouter(context)) {
 123   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 124 }
 125
 126 BluetoothLowEnergyAPI::~BluetoothLowEnergyAPI() {
 127 }
 128
 129 void BluetoothLowEnergyAPI::Shutdown() {
 130   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 131 }
 132
 133 namespace core_api {
 134
 135 BluetoothLowEnergyExtensionFunction::BluetoothLowEnergyExtensionFunction() {
 136 }
 137
 138 BluetoothLowEnergyExtensionFunction::~BluetoothLowEnergyExtensionFunction() {
 139 }
 140
 141 bool BluetoothLowEnergyExtensionFunction::RunAsync() {
 142   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 143
 144   if (!BluetoothManifestData::CheckLowEnergyPermitted(extension())) {
 145     error_ = kErrorPermissionDenied;
 146     return false;
 147   }
 148
 149   BluetoothLowEnergyEventRouter* event_router =
 150       GetEventRouter(browser_context());
 151   if (!event_router->IsBluetoothSupported()) {
 152     SetError(kErrorPlatformNotSupported);
 153     return false;
 154   }
 155
 156   // It is safe to pass |this| here as ExtensionFunction is refcounted.
 157   if (!event_router->InitializeAdapterAndInvokeCallback(base::Bind(
 158           &DoWorkCallback,
 159           base::Bind(&BluetoothLowEnergyExtensionFunction::DoWork, this)))) {
 160     SetError(kErrorAdapterNotInitialized);
 161     return false;
 162   }
 163
 164   return true;
 165 }
 166
 167 bool BluetoothLowEnergyConnectFunction::DoWork() {
 168   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 169
 170   BluetoothLowEnergyEventRouter* event_router =
 171       GetEventRouter(browser_context());
 172
 173   // The adapter must be initialized at this point, but return an error instead
 174   // of asserting.
 175   if (!event_router->HasAdapter()) {
 176     SetError(kErrorAdapterNotInitialized);
 177     SendResponse(false);
 178     return false;
 179   }
 180
 181   scoped_ptr<apibtle::Connect::Params> params(
 182       apibtle::Connect::Params::Create(*args_));
 183   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 184
 185   bool persistent = false;  // Not persistent by default.
 186   apibtle::ConnectProperties* properties = params.get()->properties.get();
 187   if (properties)
 188     persistent = properties->persistent;
 189
 190   event_router->Connect(
 191       persistent,
 192       extension(),
 193       params->device_address,
 194       base::Bind(&BluetoothLowEnergyConnectFunction::SuccessCallback, this),
 195       base::Bind(&BluetoothLowEnergyConnectFunction::ErrorCallback, this));
 196
 197   return true;
 198 }
 199
 200 void BluetoothLowEnergyConnectFunction::SuccessCallback() {
 201   SendResponse(true);
 202 }
 203
 204 void BluetoothLowEnergyConnectFunction::ErrorCallback(
 205     BluetoothLowEnergyEventRouter::Status status) {
 206   SetError(StatusToString(status));
 207   SendResponse(false);
 208 }
 209
 210 bool BluetoothLowEnergyDisconnectFunction::DoWork() {
 211   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 212
 213   BluetoothLowEnergyEventRouter* event_router =
 214       GetEventRouter(browser_context());
 215
 216   // The adapter must be initialized at this point, but return an error instead
 217   // of asserting.
 218   if (!event_router->HasAdapter()) {
 219     SetError(kErrorAdapterNotInitialized);
 220     SendResponse(false);
 221     return false;
 222   }
 223
 224   scoped_ptr<apibtle::Disconnect::Params> params(
 225       apibtle::Disconnect::Params::Create(*args_));
 226   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 227
 228   event_router->Disconnect(
 229       extension(),
 230       params->device_address,
 231       base::Bind(&BluetoothLowEnergyDisconnectFunction::SuccessCallback, this),
 232       base::Bind(&BluetoothLowEnergyDisconnectFunction::ErrorCallback, this));
 233
 234   return true;
 235 }
 236
 237 void BluetoothLowEnergyDisconnectFunction::SuccessCallback() {
 238   SendResponse(true);
 239 }
 240
 241 void BluetoothLowEnergyDisconnectFunction::ErrorCallback(
 242     BluetoothLowEnergyEventRouter::Status status) {
 243   SetError(StatusToString(status));
 244   SendResponse(false);
 245 }
 246
 247 bool BluetoothLowEnergyGetServiceFunction::DoWork() {
 248   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 249
 250   BluetoothLowEnergyEventRouter* event_router =
 251       GetEventRouter(browser_context());
 252
 253   // The adapter must be initialized at this point, but return an error instead
 254   // of asserting.
 255   if (!event_router->HasAdapter()) {
 256     SetError(kErrorAdapterNotInitialized);
 257     SendResponse(false);
 258     return false;
 259   }
 260
 261   scoped_ptr<apibtle::GetService::Params> params(
 262       apibtle::GetService::Params::Create(*args_));
 263   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 264
 265   apibtle::Service service;
 266   BluetoothLowEnergyEventRouter::Status status =
 267       event_router->GetService(params->service_id, &service);
 268   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 269     SetError(StatusToString(status));
 270     SendResponse(false);
 271     return false;
 272   }
 273
 274   results_ = apibtle::GetService::Results::Create(service);
 275   SendResponse(true);
 276
 277   return true;
 278 }
 279
 280 bool BluetoothLowEnergyGetServicesFunction::DoWork() {
 281   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 282
 283   BluetoothLowEnergyEventRouter* event_router =
 284       GetEventRouter(browser_context());
 285
 286   // The adapter must be initialized at this point, but return an error instead
 287   // of asserting.
 288   if (!event_router->HasAdapter()) {
 289     SetError(kErrorAdapterNotInitialized);
 290     SendResponse(false);
 291     return false;
 292   }
 293
 294   scoped_ptr<apibtle::GetServices::Params> params(
 295       apibtle::GetServices::Params::Create(*args_));
 296   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 297
 298   BluetoothLowEnergyEventRouter::ServiceList service_list;
 299   if (!event_router->GetServices(params->device_address, &service_list)) {
 300     SetError(kErrorNotFound);
 301     SendResponse(false);
 302     return false;
 303   }
 304
 305   results_ = apibtle::GetServices::Results::Create(service_list);
 306   SendResponse(true);
 307
 308   return true;
 309 }
 310
 311 bool BluetoothLowEnergyGetCharacteristicFunction::DoWork() {
 312   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 313
 314   BluetoothLowEnergyEventRouter* event_router =
 315       GetEventRouter(browser_context());
 316
 317   // The adapter must be initialized at this point, but return an error instead
 318   // of asserting.
 319   if (!event_router->HasAdapter()) {
 320     SetError(kErrorAdapterNotInitialized);
 321     SendResponse(false);
 322     return false;
 323   }
 324
 325   scoped_ptr<apibtle::GetCharacteristic::Params> params(
 326       apibtle::GetCharacteristic::Params::Create(*args_));
 327   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 328
 329   apibtle::Characteristic characteristic;
 330   BluetoothLowEnergyEventRouter::Status status =
 331       event_router->GetCharacteristic(
 332           extension(), params->characteristic_id, &characteristic);
 333   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 334     SetError(StatusToString(status));
 335     SendResponse(false);
 336     return false;
 337   }
 338
 339   // Manually construct the result instead of using
 340   // apibtle::GetCharacteristic::Result::Create as it doesn't convert lists of
 341   // enums correctly.
 342   SetResult(apibtle::CharacteristicToValue(&characteristic).release());
 343   SendResponse(true);
 344
 345   return true;
 346 }
 347
 348 bool BluetoothLowEnergyGetCharacteristicsFunction::DoWork() {
 349   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 350
 351   BluetoothLowEnergyEventRouter* event_router =
 352       GetEventRouter(browser_context());
 353
 354   // The adapter must be initialized at this point, but return an error instead
 355   // of asserting.
 356   if (!event_router->HasAdapter()) {
 357     SetError(kErrorAdapterNotInitialized);
 358     SendResponse(false);
 359     return false;
 360   }
 361
 362   scoped_ptr<apibtle::GetCharacteristics::Params> params(
 363       apibtle::GetCharacteristics::Params::Create(*args_));
 364   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 365
 366   BluetoothLowEnergyEventRouter::CharacteristicList characteristic_list;
 367   BluetoothLowEnergyEventRouter::Status status =
 368       event_router->GetCharacteristics(
 369           extension(), params->service_id, &characteristic_list);
 370   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 371     SetError(StatusToString(status));
 372     SendResponse(false);
 373     return false;
 374   }
 375
 376   // Manually construct the result instead of using
 377   // apibtle::GetCharacteristics::Result::Create as it doesn't convert lists of
 378   // enums correctly.
 379   scoped_ptr<base::ListValue> result(new base::ListValue());
 380   for (BluetoothLowEnergyEventRouter::CharacteristicList::iterator iter =
 381            characteristic_list.begin();
 382        iter != characteristic_list.end();
 383        ++iter)
 384     result->Append(apibtle::CharacteristicToValue(iter->get()).release());
 385
 386   SetResult(result.release());
 387   SendResponse(true);
 388
 389   return true;
 390 }
 391
 392 bool BluetoothLowEnergyGetIncludedServicesFunction::DoWork() {
 393   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 394
 395   BluetoothLowEnergyEventRouter* event_router =
 396       GetEventRouter(browser_context());
 397
 398   // The adapter must be initialized at this point, but return an error instead
 399   // of asserting.
 400   if (!event_router->HasAdapter()) {
 401     SetError(kErrorAdapterNotInitialized);
 402     SendResponse(false);
 403     return false;
 404   }
 405
 406   scoped_ptr<apibtle::GetIncludedServices::Params> params(
 407       apibtle::GetIncludedServices::Params::Create(*args_));
 408   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 409
 410   BluetoothLowEnergyEventRouter::ServiceList service_list;
 411   BluetoothLowEnergyEventRouter::Status status =
 412       event_router->GetIncludedServices(params->service_id, &service_list);
 413   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 414     SetError(StatusToString(status));
 415     SendResponse(false);
 416     return false;
 417   }
 418
 419   results_ = apibtle::GetIncludedServices::Results::Create(service_list);
 420   SendResponse(true);
 421
 422   return true;
 423 }
 424
 425 bool BluetoothLowEnergyGetDescriptorFunction::DoWork() {
 426   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 427
 428   BluetoothLowEnergyEventRouter* event_router =
 429       GetEventRouter(browser_context());
 430
 431   // The adapter must be initialized at this point, but return an error instead
 432   // of asserting.
 433   if (!event_router->HasAdapter()) {
 434     SetError(kErrorAdapterNotInitialized);
 435     SendResponse(false);
 436     return false;
 437   }
 438
 439   scoped_ptr<apibtle::GetDescriptor::Params> params(
 440       apibtle::GetDescriptor::Params::Create(*args_));
 441   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 442
 443   apibtle::Descriptor descriptor;
 444   BluetoothLowEnergyEventRouter::Status status = event_router->GetDescriptor(
 445       extension(), params->descriptor_id, &descriptor);
 446   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 447     SetError(StatusToString(status));
 448     SendResponse(false);
 449     return false;
 450   }
 451
 452   // Manually construct the result instead of using
 453   // apibtle::GetDescriptor::Result::Create as it doesn't convert lists of enums
 454   // correctly.
 455   SetResult(apibtle::DescriptorToValue(&descriptor).release());
 456   SendResponse(true);
 457
 458   return true;
 459 }
 460
 461 bool BluetoothLowEnergyGetDescriptorsFunction::DoWork() {
 462   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 463
 464   BluetoothLowEnergyEventRouter* event_router =
 465       GetEventRouter(browser_context());
 466
 467   // The adapter must be initialized at this point, but return an error instead
 468   // of asserting.
 469   if (!event_router->HasAdapter()) {
 470     SetError(kErrorAdapterNotInitialized);
 471     SendResponse(false);
 472     return false;
 473   }
 474
 475   scoped_ptr<apibtle::GetDescriptors::Params> params(
 476       apibtle::GetDescriptors::Params::Create(*args_));
 477   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 478
 479   BluetoothLowEnergyEventRouter::DescriptorList descriptor_list;
 480   BluetoothLowEnergyEventRouter::Status status = event_router->GetDescriptors(
 481       extension(), params->characteristic_id, &descriptor_list);
 482   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 483     SetError(StatusToString(status));
 484     SendResponse(false);
 485     return false;
 486   }
 487
 488   // Manually construct the result instead of using
 489   // apibtle::GetDescriptors::Result::Create as it doesn't convert lists of
 490   // enums correctly.
 491   scoped_ptr<base::ListValue> result(new base::ListValue());
 492   for (BluetoothLowEnergyEventRouter::DescriptorList::iterator iter =
 493            descriptor_list.begin();
 494        iter != descriptor_list.end();
 495        ++iter)
 496     result->Append(apibtle::DescriptorToValue(iter->get()).release());
 497
 498   SetResult(result.release());
 499   SendResponse(true);
 500
 501   return true;
 502 }
 503
 504 bool BluetoothLowEnergyReadCharacteristicValueFunction::DoWork() {
 505   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 506
 507   BluetoothLowEnergyEventRouter* event_router =
 508       GetEventRouter(browser_context());
 509
 510   // The adapter must be initialized at this point, but return an error instead
 511   // of asserting.
 512   if (!event_router->HasAdapter()) {
 513     SetError(kErrorAdapterNotInitialized);
 514     SendResponse(false);
 515     return false;
 516   }
 517
 518   scoped_ptr<apibtle::ReadCharacteristicValue::Params> params(
 519       apibtle::ReadCharacteristicValue::Params::Create(*args_));
 520   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 521
 522   instance_id_ = params->characteristic_id;
 523   event_router->ReadCharacteristicValue(
 524       extension(),
 525       instance_id_,
 526       base::Bind(
 527           &BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback,
 528           this),
 529       base::Bind(
 530           &BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback,
 531           this));
 532
 533   return true;
 534 }
 535
 536 void BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback() {
 537   // Obtain info on the characteristic and see whether or not the characteristic
 538   // is still around.
 539   apibtle::Characteristic characteristic;
 540   BluetoothLowEnergyEventRouter::Status status =
 541       GetEventRouter(browser_context())
 542           ->GetCharacteristic(extension(), instance_id_, &characteristic);
 543   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 544     SetError(StatusToString(status));
 545     SendResponse(false);
 546     return;
 547   }
 548
 549   // Manually construct the result instead of using
 550   // apibtle::GetCharacteristic::Result::Create as it doesn't convert lists of
 551   // enums correctly.
 552   SetResult(apibtle::CharacteristicToValue(&characteristic).release());
 553   SendResponse(true);
 554 }
 555
 556 void BluetoothLowEnergyReadCharacteristicValueFunction::ErrorCallback(
 557     BluetoothLowEnergyEventRouter::Status status) {
 558   SetError(StatusToString(status));
 559   SendResponse(false);
 560 }
 561
 562 bool BluetoothLowEnergyWriteCharacteristicValueFunction::DoWork() {
 563   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 564
 565   BluetoothLowEnergyEventRouter* event_router =
 566       GetEventRouter(browser_context());
 567
 568   // The adapter must be initialized at this point, but return an error instead
 569   // of asserting.
 570   if (!event_router->HasAdapter()) {
 571     SetError(kErrorAdapterNotInitialized);
 572     SendResponse(false);
 573     return false;
 574   }
 575
 576   scoped_ptr<apibtle::WriteCharacteristicValue::Params> params(
 577       apibtle::WriteCharacteristicValue::Params::Create(*args_));
 578   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 579
 580   std::vector<uint8> value(params->value.begin(), params->value.end());
 581   event_router->WriteCharacteristicValue(
 582       extension(),
 583       params->characteristic_id,
 584       value,
 585       base::Bind(
 586           &BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback,
 587           this),
 588       base::Bind(
 589           &BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback,
 590           this));
 591
 592   return true;
 593 }
 594
 595 void BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback() {
 596   results_ = apibtle::WriteCharacteristicValue::Results::Create();
 597   SendResponse(true);
 598 }
 599
 600 void BluetoothLowEnergyWriteCharacteristicValueFunction::ErrorCallback(
 601     BluetoothLowEnergyEventRouter::Status status) {
 602   SetError(StatusToString(status));
 603   SendResponse(false);
 604 }
 605
 606 bool BluetoothLowEnergyStartCharacteristicNotificationsFunction::DoWork() {
 607   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 608
 609   BluetoothLowEnergyEventRouter* event_router =
 610       GetEventRouter(browser_context());
 611
 612   // The adapter must be initialized at this point, but return an error instead
 613   // of asserting.
 614   if (!event_router->HasAdapter()) {
 615     SetError(kErrorAdapterNotInitialized);
 616     SendResponse(false);
 617     return false;
 618   }
 619
 620   scoped_ptr<apibtle::StartCharacteristicNotifications::Params> params(
 621       apibtle::StartCharacteristicNotifications::Params::Create(*args_));
 622   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 623
 624   bool persistent = false;  // Not persistent by default.
 625   apibtle::NotificationProperties* properties = params.get()->properties.get();
 626   if (properties)
 627     persistent = properties->persistent;
 628
 629   event_router->StartCharacteristicNotifications(
 630       persistent,
 631       extension(),
 632       params->characteristic_id,
 633       base::Bind(&BluetoothLowEnergyStartCharacteristicNotificationsFunction::
 634                      SuccessCallback,
 635                  this),
 636       base::Bind(&BluetoothLowEnergyStartCharacteristicNotificationsFunction::
 637                      ErrorCallback,
 638                  this));
 639
 640   return true;
 641 }
 642
 643 void
 644 BluetoothLowEnergyStartCharacteristicNotificationsFunction::SuccessCallback() {
 645   SendResponse(true);
 646 }
 647
 648 void BluetoothLowEnergyStartCharacteristicNotificationsFunction::ErrorCallback(
 649     BluetoothLowEnergyEventRouter::Status status) {
 650   SetError(StatusToString(status));
 651   SendResponse(false);
 652 }
 653
 654 bool BluetoothLowEnergyStopCharacteristicNotificationsFunction::DoWork() {
 655   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 656
 657   BluetoothLowEnergyEventRouter* event_router =
 658       GetEventRouter(browser_context());
 659
 660   // The adapter must be initialized at this point, but return an error instead
 661   // of asserting.
 662   if (!event_router->HasAdapter()) {
 663     SetError(kErrorAdapterNotInitialized);
 664     SendResponse(false);
 665     return false;
 666   }
 667
 668   scoped_ptr<apibtle::StopCharacteristicNotifications::Params> params(
 669       apibtle::StopCharacteristicNotifications::Params::Create(*args_));
 670   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 671
 672   event_router->StopCharacteristicNotifications(
 673       extension(),
 674       params->characteristic_id,
 675       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
 676                      SuccessCallback,
 677                  this),
 678       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
 679                      ErrorCallback,
 680                  this));
 681
 682   return true;
 683 }
 684
 685 void
 686 BluetoothLowEnergyStopCharacteristicNotificationsFunction::SuccessCallback() {
 687   SendResponse(true);
 688 }
 689
 690 void BluetoothLowEnergyStopCharacteristicNotificationsFunction::ErrorCallback(
 691     BluetoothLowEnergyEventRouter::Status status) {
 692   SetError(StatusToString(status));
 693   SendResponse(false);
 694 }
 695
 696 bool BluetoothLowEnergyReadDescriptorValueFunction::DoWork() {
 697   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 698
 699   BluetoothLowEnergyEventRouter* event_router =
 700       GetEventRouter(browser_context());
 701
 702   // The adapter must be initialized at this point, but return an error instead
 703   // of asserting.
 704   if (!event_router->HasAdapter()) {
 705     SetError(kErrorAdapterNotInitialized);
 706     SendResponse(false);
 707     return false;
 708   }
 709
 710   scoped_ptr<apibtle::ReadDescriptorValue::Params> params(
 711       apibtle::ReadDescriptorValue::Params::Create(*args_));
 712   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 713
 714   instance_id_ = params->descriptor_id;
 715   event_router->ReadDescriptorValue(
 716       extension(),
 717       instance_id_,
 718       base::Bind(
 719           &BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback,
 720           this),
 721       base::Bind(&BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback,
 722                  this));
 723
 724   return true;
 725 }
 726
 727 void BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback() {
 728   // Obtain info on the descriptor and see whether or not the descriptor is
 729   // still around.
 730   apibtle::Descriptor descriptor;
 731   BluetoothLowEnergyEventRouter::Status status =
 732       GetEventRouter(browser_context())
 733           ->GetDescriptor(extension(), instance_id_, &descriptor);
 734   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
 735     SetError(StatusToString(status));
 736     SendResponse(false);
 737     return;
 738   }
 739
 740   // Manually construct the result instead of using
 741   // apibtle::GetDescriptor::Results::Create as it doesn't convert lists of
 742   // enums correctly.
 743   SetResult(apibtle::DescriptorToValue(&descriptor).release());
 744   SendResponse(true);
 745 }
 746
 747 void BluetoothLowEnergyReadDescriptorValueFunction::ErrorCallback(
 748     BluetoothLowEnergyEventRouter::Status status) {
 749   SetError(StatusToString(status));
 750   SendResponse(false);
 751 }
 752
 753 bool BluetoothLowEnergyWriteDescriptorValueFunction::DoWork() {
 754   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 755
 756   BluetoothLowEnergyEventRouter* event_router =
 757       GetEventRouter(browser_context());
 758
 759   // The adapter must be initialized at this point, but return an error instead
 760   // of asserting.
 761   if (!event_router->HasAdapter()) {
 762     SetError(kErrorAdapterNotInitialized);
 763     SendResponse(false);
 764     return false;
 765   }
 766
 767   scoped_ptr<apibtle::WriteDescriptorValue::Params> params(
 768       apibtle::WriteDescriptorValue::Params::Create(*args_));
 769   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 770
 771   std::vector<uint8> value(params->value.begin(), params->value.end());
 772   event_router->WriteDescriptorValue(
 773       extension(),
 774       params->descriptor_id,
 775       value,
 776       base::Bind(
 777           &BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback,
 778           this),
 779       base::Bind(&BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback,
 780                  this));
 781
 782   return true;
 783 }
 784
 785 void BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback() {
 786   results_ = apibtle::WriteDescriptorValue::Results::Create();
 787   SendResponse(true);
 788 }
 789
 790 void BluetoothLowEnergyWriteDescriptorValueFunction::ErrorCallback(
 791     BluetoothLowEnergyEventRouter::Status status) {
 792   SetError(StatusToString(status));
 793   SendResponse(false);
 794 }
 795
 796 }  // namespace core_api
 797 }  // namespace extensions