Home | History | Annotate | Download | only in serial 
      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/serial/serial_api.h"
      6 
      7 #include <algorithm>
      8 #include <vector>
      9 
     10 #include "base/values.h"
     11 #include "content/public/browser/browser_thread.h"
     12 #include "device/serial/serial_device_enumerator.h"
     13 #include "extensions/browser/api/serial/serial_connection.h"
     14 #include "extensions/browser/api/serial/serial_event_dispatcher.h"
     15 #include "extensions/common/api/serial.h"
     16 
     17 using content::BrowserThread;
     18 
     19 namespace extensions {
     20 
     21 namespace core_api {
     22 
     23 namespace {
     24 
     25 // It's a fool's errand to come up with a default bitrate, because we don't get
     26 // to control both sides of the communication. Unless the other side has
     27 // implemented auto-bitrate detection (rare), if we pick the wrong rate, then
     28 // you're gonna have a bad time. Close doesn't count.
     29 //
     30 // But we'd like to pick something that has a chance of working, and 9600 is a
     31 // good balance between popularity and speed. So 9600 it is.
     32 const int kDefaultBufferSize = 4096;
     33 const int kDefaultBitrate = 9600;
     34 const serial::DataBits kDefaultDataBits = serial::DATA_BITS_EIGHT;
     35 const serial::ParityBit kDefaultParityBit = serial::PARITY_BIT_NO;
     36 const serial::StopBits kDefaultStopBits = serial::STOP_BITS_ONE;
     37 const int kDefaultReceiveTimeout = 0;
     38 const int kDefaultSendTimeout = 0;
     39 
     40 const char kErrorConnectFailed[] = "Failed to connect to the port.";
     41 const char kErrorSerialConnectionNotFound[] = "Serial connection not found.";
     42 const char kErrorGetControlSignalsFailed[] = "Failed to get control signals.";
     43 
     44 template <class T>
     45 void SetDefaultScopedPtrValue(scoped_ptr<T>& ptr, const T& value) {
     46   if (!ptr.get())
     47     ptr.reset(new T(value));
     48 }
     49 
     50 }  // namespace
     51 
     52 SerialAsyncApiFunction::SerialAsyncApiFunction() : manager_(NULL) {
     53 }
     54 
     55 SerialAsyncApiFunction::~SerialAsyncApiFunction() {
     56 }
     57 
     58 bool SerialAsyncApiFunction::PrePrepare() {
     59   manager_ = ApiResourceManager<SerialConnection>::Get(browser_context());
     60   DCHECK(manager_);
     61   return true;
     62 }
     63 
     64 bool SerialAsyncApiFunction::Respond() {
     65   return error_.empty();
     66 }
     67 
     68 SerialConnection* SerialAsyncApiFunction::GetSerialConnection(
     69     int api_resource_id) {
     70   return manager_->Get(extension_->id(), api_resource_id);
     71 }
     72 
     73 void SerialAsyncApiFunction::RemoveSerialConnection(int api_resource_id) {
     74   manager_->Remove(extension_->id(), api_resource_id);
     75 }
     76 
     77 SerialGetDevicesFunction::SerialGetDevicesFunction() {
     78 }
     79 
     80 bool SerialGetDevicesFunction::Prepare() {
     81   set_work_thread_id(BrowserThread::FILE);
     82   return true;
     83 }
     84 
     85 void SerialGetDevicesFunction::Work() {
     86   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     87 
     88   scoped_ptr<device::SerialDeviceEnumerator> enumerator =
     89       device::SerialDeviceEnumerator::Create();
     90   mojo::Array<device::serial::DeviceInfoPtr> devices = enumerator->GetDevices();
     91   results_ = serial::GetDevices::Results::Create(
     92       devices.To<std::vector<linked_ptr<serial::DeviceInfo> > >());
     93 }
     94 
     95 SerialConnectFunction::SerialConnectFunction() {
     96 }
     97 
     98 SerialConnectFunction::~SerialConnectFunction() {
     99 }
    100 
    101 bool SerialConnectFunction::Prepare() {
    102   params_ = serial::Connect::Params::Create(*args_);
    103   EXTENSION_FUNCTION_VALIDATE(params_.get());
    104 
    105   // Fill in any omitted options to ensure a known initial configuration.
    106   if (!params_->options.get())
    107     params_->options.reset(new serial::ConnectionOptions());
    108   serial::ConnectionOptions* options = params_->options.get();
    109 
    110   SetDefaultScopedPtrValue(options->persistent, false);
    111   SetDefaultScopedPtrValue(options->buffer_size, kDefaultBufferSize);
    112   SetDefaultScopedPtrValue(options->bitrate, kDefaultBitrate);
    113   SetDefaultScopedPtrValue(options->cts_flow_control, false);
    114   SetDefaultScopedPtrValue(options->receive_timeout, kDefaultReceiveTimeout);
    115   SetDefaultScopedPtrValue(options->send_timeout, kDefaultSendTimeout);
    116 
    117   if (options->data_bits == serial::DATA_BITS_NONE)
    118     options->data_bits = kDefaultDataBits;
    119   if (options->parity_bit == serial::PARITY_BIT_NONE)
    120     options->parity_bit = kDefaultParityBit;
    121   if (options->stop_bits == serial::STOP_BITS_NONE)
    122     options->stop_bits = kDefaultStopBits;
    123 
    124   serial_event_dispatcher_ = SerialEventDispatcher::Get(browser_context());
    125   DCHECK(serial_event_dispatcher_);
    126 
    127   return true;
    128 }
    129 
    130 void SerialConnectFunction::AsyncWorkStart() {
    131   DCHECK_CURRENTLY_ON(BrowserThread::IO);
    132   connection_ = CreateSerialConnection(params_->path, extension_->id());
    133   connection_->Open(base::Bind(&SerialConnectFunction::OnConnected, this));
    134 }
    135 
    136 void SerialConnectFunction::OnConnected(bool success) {
    137   DCHECK(connection_);
    138 
    139   if (success) {
    140     if (!connection_->Configure(*params_->options.get())) {
    141       delete connection_;
    142       connection_ = NULL;
    143     }
    144   } else {
    145     delete connection_;
    146     connection_ = NULL;
    147   }
    148 
    149   BrowserThread::PostTask(
    150       BrowserThread::IO,
    151       FROM_HERE,
    152       base::Bind(&SerialConnectFunction::FinishConnect, this));
    153 }
    154 
    155 void SerialConnectFunction::FinishConnect() {
    156   DCHECK_CURRENTLY_ON(BrowserThread::IO);
    157   if (!connection_) {
    158     error_ = kErrorConnectFailed;
    159   } else {
    160     int id = manager_->Add(connection_);
    161     serial::ConnectionInfo info;
    162     info.connection_id = id;
    163     if (connection_->GetInfo(&info)) {
    164       serial_event_dispatcher_->PollConnection(extension_->id(), id);
    165       results_ = serial::Connect::Results::Create(info);
    166     } else {
    167       RemoveSerialConnection(id);
    168       error_ = kErrorConnectFailed;
    169     }
    170   }
    171   AsyncWorkCompleted();
    172 }
    173 
    174 SerialConnection* SerialConnectFunction::CreateSerialConnection(
    175     const std::string& port,
    176     const std::string& extension_id) const {
    177   return new SerialConnection(port, extension_id);
    178 }
    179 
    180 SerialUpdateFunction::SerialUpdateFunction() {
    181 }
    182 
    183 SerialUpdateFunction::~SerialUpdateFunction() {
    184 }
    185 
    186 bool SerialUpdateFunction::Prepare() {
    187   params_ = serial::Update::Params::Create(*args_);
    188   EXTENSION_FUNCTION_VALIDATE(params_.get());
    189 
    190   return true;
    191 }
    192 
    193 void SerialUpdateFunction::Work() {
    194   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    195   if (!connection) {
    196     error_ = kErrorSerialConnectionNotFound;
    197     return;
    198   }
    199   bool success = connection->Configure(params_->options);
    200   results_ = serial::Update::Results::Create(success);
    201 }
    202 
    203 SerialDisconnectFunction::SerialDisconnectFunction() {
    204 }
    205 
    206 SerialDisconnectFunction::~SerialDisconnectFunction() {
    207 }
    208 
    209 bool SerialDisconnectFunction::Prepare() {
    210   params_ = serial::Disconnect::Params::Create(*args_);
    211   EXTENSION_FUNCTION_VALIDATE(params_.get());
    212 
    213   return true;
    214 }
    215 
    216 void SerialDisconnectFunction::Work() {
    217   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    218   if (!connection) {
    219     error_ = kErrorSerialConnectionNotFound;
    220     return;
    221   }
    222   RemoveSerialConnection(params_->connection_id);
    223   results_ = serial::Disconnect::Results::Create(true);
    224 }
    225 
    226 SerialSendFunction::SerialSendFunction() {
    227 }
    228 
    229 SerialSendFunction::~SerialSendFunction() {
    230 }
    231 
    232 bool SerialSendFunction::Prepare() {
    233   params_ = serial::Send::Params::Create(*args_);
    234   EXTENSION_FUNCTION_VALIDATE(params_.get());
    235 
    236   return true;
    237 }
    238 
    239 void SerialSendFunction::AsyncWorkStart() {
    240   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    241   if (!connection) {
    242     error_ = kErrorSerialConnectionNotFound;
    243     AsyncWorkCompleted();
    244     return;
    245   }
    246 
    247   if (!connection->Send(
    248           params_->data,
    249           base::Bind(&SerialSendFunction::OnSendComplete, this))) {
    250     OnSendComplete(0, serial::SEND_ERROR_PENDING);
    251   }
    252 }
    253 
    254 void SerialSendFunction::OnSendComplete(int bytes_sent,
    255                                         serial::SendError error) {
    256   serial::SendInfo send_info;
    257   send_info.bytes_sent = bytes_sent;
    258   send_info.error = error;
    259   results_ = serial::Send::Results::Create(send_info);
    260   AsyncWorkCompleted();
    261 }
    262 
    263 SerialFlushFunction::SerialFlushFunction() {
    264 }
    265 
    266 SerialFlushFunction::~SerialFlushFunction() {
    267 }
    268 
    269 bool SerialFlushFunction::Prepare() {
    270   params_ = serial::Flush::Params::Create(*args_);
    271   EXTENSION_FUNCTION_VALIDATE(params_.get());
    272   return true;
    273 }
    274 
    275 void SerialFlushFunction::Work() {
    276   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    277   if (!connection) {
    278     error_ = kErrorSerialConnectionNotFound;
    279     return;
    280   }
    281 
    282   bool success = connection->Flush();
    283   results_ = serial::Flush::Results::Create(success);
    284 }
    285 
    286 SerialSetPausedFunction::SerialSetPausedFunction() {
    287 }
    288 
    289 SerialSetPausedFunction::~SerialSetPausedFunction() {
    290 }
    291 
    292 bool SerialSetPausedFunction::Prepare() {
    293   params_ = serial::SetPaused::Params::Create(*args_);
    294   EXTENSION_FUNCTION_VALIDATE(params_.get());
    295 
    296   serial_event_dispatcher_ = SerialEventDispatcher::Get(browser_context());
    297   DCHECK(serial_event_dispatcher_);
    298   return true;
    299 }
    300 
    301 void SerialSetPausedFunction::Work() {
    302   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    303   if (!connection) {
    304     error_ = kErrorSerialConnectionNotFound;
    305     return;
    306   }
    307 
    308   if (params_->paused != connection->paused()) {
    309     connection->set_paused(params_->paused);
    310     if (!params_->paused) {
    311       serial_event_dispatcher_->PollConnection(extension_->id(),
    312                                                params_->connection_id);
    313     }
    314   }
    315 
    316   results_ = serial::SetPaused::Results::Create();
    317 }
    318 
    319 SerialGetInfoFunction::SerialGetInfoFunction() {
    320 }
    321 
    322 SerialGetInfoFunction::~SerialGetInfoFunction() {
    323 }
    324 
    325 bool SerialGetInfoFunction::Prepare() {
    326   params_ = serial::GetInfo::Params::Create(*args_);
    327   EXTENSION_FUNCTION_VALIDATE(params_.get());
    328 
    329   return true;
    330 }
    331 
    332 void SerialGetInfoFunction::Work() {
    333   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    334   if (!connection) {
    335     error_ = kErrorSerialConnectionNotFound;
    336     return;
    337   }
    338 
    339   serial::ConnectionInfo info;
    340   info.connection_id = params_->connection_id;
    341   connection->GetInfo(&info);
    342   results_ = serial::GetInfo::Results::Create(info);
    343 }
    344 
    345 SerialGetConnectionsFunction::SerialGetConnectionsFunction() {
    346 }
    347 
    348 SerialGetConnectionsFunction::~SerialGetConnectionsFunction() {
    349 }
    350 
    351 bool SerialGetConnectionsFunction::Prepare() {
    352   return true;
    353 }
    354 
    355 void SerialGetConnectionsFunction::Work() {
    356   std::vector<linked_ptr<serial::ConnectionInfo> > infos;
    357   const base::hash_set<int>* connection_ids =
    358       manager_->GetResourceIds(extension_->id());
    359   if (connection_ids) {
    360     for (base::hash_set<int>::const_iterator it = connection_ids->begin();
    361          it != connection_ids->end();
    362          ++it) {
    363       int connection_id = *it;
    364       SerialConnection* connection = GetSerialConnection(connection_id);
    365       if (connection) {
    366         linked_ptr<serial::ConnectionInfo> info(new serial::ConnectionInfo());
    367         info->connection_id = connection_id;
    368         connection->GetInfo(info.get());
    369         infos.push_back(info);
    370       }
    371     }
    372   }
    373   results_ = serial::GetConnections::Results::Create(infos);
    374 }
    375 
    376 SerialGetControlSignalsFunction::SerialGetControlSignalsFunction() {
    377 }
    378 
    379 SerialGetControlSignalsFunction::~SerialGetControlSignalsFunction() {
    380 }
    381 
    382 bool SerialGetControlSignalsFunction::Prepare() {
    383   params_ = serial::GetControlSignals::Params::Create(*args_);
    384   EXTENSION_FUNCTION_VALIDATE(params_.get());
    385 
    386   return true;
    387 }
    388 
    389 void SerialGetControlSignalsFunction::Work() {
    390   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    391   if (!connection) {
    392     error_ = kErrorSerialConnectionNotFound;
    393     return;
    394   }
    395 
    396   serial::DeviceControlSignals signals;
    397   if (!connection->GetControlSignals(&signals)) {
    398     error_ = kErrorGetControlSignalsFailed;
    399     return;
    400   }
    401 
    402   results_ = serial::GetControlSignals::Results::Create(signals);
    403 }
    404 
    405 SerialSetControlSignalsFunction::SerialSetControlSignalsFunction() {
    406 }
    407 
    408 SerialSetControlSignalsFunction::~SerialSetControlSignalsFunction() {
    409 }
    410 
    411 bool SerialSetControlSignalsFunction::Prepare() {
    412   params_ = serial::SetControlSignals::Params::Create(*args_);
    413   EXTENSION_FUNCTION_VALIDATE(params_.get());
    414 
    415   return true;
    416 }
    417 
    418 void SerialSetControlSignalsFunction::Work() {
    419   SerialConnection* connection = GetSerialConnection(params_->connection_id);
    420   if (!connection) {
    421     error_ = kErrorSerialConnectionNotFound;
    422     return;
    423   }
    424 
    425   bool success = connection->SetControlSignals(params_->signals);
    426   results_ = serial::SetControlSignals::Results::Create(success);
    427 }
    428 
    429 }  // namespace core_api
    430 
    431 }  // namespace extensions
    432 
    433 namespace mojo {
    434 
    435 // static
    436 linked_ptr<extensions::core_api::serial::DeviceInfo> TypeConverter<
    437     linked_ptr<extensions::core_api::serial::DeviceInfo>,
    438     device::serial::DeviceInfoPtr>::Convert(const device::serial::DeviceInfoPtr&
    439                                                 device) {
    440   linked_ptr<extensions::core_api::serial::DeviceInfo> info(
    441       new extensions::core_api::serial::DeviceInfo);
    442   info->path = device->path;
    443   if (device->has_vendor_id)
    444     info->vendor_id.reset(new int(static_cast<int>(device->vendor_id)));
    445   if (device->has_product_id)
    446     info->product_id.reset(new int(static_cast<int>(device->product_id)));
    447   if (device->display_name)
    448     info->display_name.reset(new std::string(device->display_name));
    449   return info;
    450 }
    451 
    452 }  // namespace mojo
    453