Home | History | Annotate | Download | only in dbus
      1 // Copyright 2013 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 "chromeos/dbus/fake_nfc_device_client.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/time/time.h"
     11 #include "chromeos/dbus/dbus_thread_manager.h"
     12 #include "chromeos/dbus/fake_nfc_adapter_client.h"
     13 #include "chromeos/dbus/fake_nfc_record_client.h"
     14 #include "chromeos/dbus/nfc_client_helpers.h"
     15 #include "dbus/object_path.h"
     16 #include "third_party/cros_system_api/dbus/service_constants.h"
     17 
     18 namespace chromeos {
     19 
     20 using nfc_client_helpers::ObjectPathVector;
     21 
     22 const char FakeNfcDeviceClient::kDevicePath[] = "/fake/device0";
     23 const int FakeNfcDeviceClient::kDefaultSimulationTimeoutMilliseconds = 10000;
     24 
     25 FakeNfcDeviceClient::Properties::Properties(
     26     const PropertyChangedCallback& callback)
     27     : NfcDeviceClient::Properties(NULL, callback) {
     28 }
     29 
     30 FakeNfcDeviceClient::Properties::~Properties() {
     31 }
     32 
     33 void FakeNfcDeviceClient::Properties::Get(
     34     dbus::PropertyBase* property,
     35     dbus::PropertySet::GetCallback callback) {
     36   VLOG(1) << "Get " << property->name();
     37   callback.Run(false);
     38 }
     39 
     40 void FakeNfcDeviceClient::Properties::GetAll() {
     41   VLOG(1) << "GetAll";
     42 }
     43 
     44 void FakeNfcDeviceClient::Properties::Set(
     45     dbus::PropertyBase* property,
     46     dbus::PropertySet::SetCallback callback) {
     47   VLOG(1) << "Set " << property->name();
     48   callback.Run(false);
     49 }
     50 
     51 FakeNfcDeviceClient::FakeNfcDeviceClient()
     52     : pairing_started_(false),
     53       device_visible_(false),
     54       simulation_timeout_(kDefaultSimulationTimeoutMilliseconds) {
     55   VLOG(1) << "Creating FakeNfcDeviceClient";
     56 
     57   properties_.reset(new Properties(
     58       base::Bind(&FakeNfcDeviceClient::OnPropertyChanged,
     59                  base::Unretained(this),
     60                  dbus::ObjectPath(kDevicePath))));
     61 }
     62 
     63 FakeNfcDeviceClient::~FakeNfcDeviceClient() {
     64 }
     65 
     66 void FakeNfcDeviceClient::Init(dbus::Bus* bus) {
     67 }
     68 
     69 void FakeNfcDeviceClient::AddObserver(Observer* observer) {
     70   observers_.AddObserver(observer);
     71 }
     72 
     73 void FakeNfcDeviceClient::RemoveObserver(Observer* observer) {
     74   observers_.RemoveObserver(observer);
     75 }
     76 
     77 std::vector<dbus::ObjectPath> FakeNfcDeviceClient::GetDevicesForAdapter(
     78       const dbus::ObjectPath& adapter_path) {
     79   std::vector<dbus::ObjectPath> device_paths;
     80   if (device_visible_ &&
     81       adapter_path.value() == FakeNfcAdapterClient::kAdapterPath0)
     82     device_paths.push_back(dbus::ObjectPath(kDevicePath));
     83   return device_paths;
     84 }
     85 
     86 FakeNfcDeviceClient::Properties*
     87 FakeNfcDeviceClient::GetProperties(const dbus::ObjectPath& object_path) {
     88   if (!device_visible_)
     89     return NULL;
     90   return properties_.get();
     91 }
     92 
     93 void FakeNfcDeviceClient::Push(
     94     const dbus::ObjectPath& object_path,
     95     const base::DictionaryValue& attributes,
     96     const base::Closure& callback,
     97     const nfc_client_helpers::ErrorCallback& error_callback) {
     98   VLOG(1) << "FakeNfcDeviceClient::Write called.";
     99 
    100   // Success!
    101   if (!device_visible_) {
    102     LOG(ERROR) << "Device not visible. Cannot push record.";
    103     error_callback.Run(nfc_error::kDoesNotExist, "No such device.");
    104     return;
    105   }
    106   callback.Run();
    107 }
    108 
    109 void FakeNfcDeviceClient::BeginPairingSimulation(int visibility_delay,
    110                                                  int record_push_delay) {
    111   if (pairing_started_) {
    112     VLOG(1) << "Simulation already started.";
    113     return;
    114   }
    115   DCHECK(!device_visible_);
    116   DCHECK(visibility_delay >= 0);
    117 
    118   pairing_started_ = true;
    119 
    120   base::MessageLoop::current()->PostDelayedTask(
    121       FROM_HERE,
    122       base::Bind(&FakeNfcDeviceClient::MakeDeviceVisible,
    123                  base::Unretained(this),
    124                  record_push_delay),
    125       base::TimeDelta::FromMilliseconds(visibility_delay));
    126 }
    127 
    128 void FakeNfcDeviceClient::EndPairingSimulation() {
    129   if (!pairing_started_) {
    130     VLOG(1) << "No simulation started.";
    131     return;
    132   }
    133   if (device_visible_) {
    134     // Remove records, if they were added.
    135     if (!properties_->records.value().empty()) {
    136       FakeNfcRecordClient* record_client =
    137           static_cast<FakeNfcRecordClient*>(
    138               DBusThreadManager::Get()->GetNfcRecordClient());
    139       record_client->SetDeviceRecordsVisible(false);
    140     }
    141     // Remove the device.
    142     FOR_EACH_OBSERVER(Observer, observers_,
    143                       DeviceRemoved(dbus::ObjectPath(kDevicePath)));
    144     FakeNfcAdapterClient* adapter_client =
    145         static_cast<FakeNfcAdapterClient*>(
    146             DBusThreadManager::Get()->GetNfcAdapterClient());
    147     adapter_client->UnsetDevice(dbus::ObjectPath(kDevicePath));
    148     device_visible_ = false;
    149   }
    150   pairing_started_ = false;
    151 }
    152 
    153 void FakeNfcDeviceClient::EnableSimulationTimeout(int simulation_timeout) {
    154   simulation_timeout_ = simulation_timeout;
    155 }
    156 
    157 void FakeNfcDeviceClient::DisableSimulationTimeout() {
    158   simulation_timeout_ = -1;
    159 }
    160 
    161 void FakeNfcDeviceClient::SetRecords(
    162     const std::vector<dbus::ObjectPath>& record_paths) {
    163   if (!device_visible_) {
    164     VLOG(1) << "Device not visible.";
    165     return;
    166   }
    167   properties_->records.ReplaceValue(record_paths);
    168 }
    169 
    170 void FakeNfcDeviceClient::ClearRecords() {
    171   ObjectPathVector records;
    172   SetRecords(records);
    173 }
    174 
    175 void FakeNfcDeviceClient::OnPropertyChanged(
    176     const dbus::ObjectPath& object_path,
    177     const std::string& property_name) {
    178   FOR_EACH_OBSERVER(NfcDeviceClient::Observer, observers_,
    179                     DevicePropertyChanged(object_path, property_name));
    180 }
    181 
    182 void FakeNfcDeviceClient::MakeDeviceVisible(int record_push_delay) {
    183   if (!pairing_started_) {
    184     VLOG(1) << "Device pairing was cancelled.";
    185     return;
    186   }
    187   device_visible_ = true;
    188 
    189   FakeNfcAdapterClient* adapter_client =
    190       static_cast<FakeNfcAdapterClient*>(
    191           DBusThreadManager::Get()->GetNfcAdapterClient());
    192   adapter_client->SetDevice(dbus::ObjectPath(kDevicePath));
    193   FOR_EACH_OBSERVER(Observer, observers_,
    194                     DeviceAdded(dbus::ObjectPath(kDevicePath)));
    195 
    196   if (record_push_delay < 0) {
    197     // Don't simulate record push. Instead, skip directly to the timeout step.
    198     if (simulation_timeout_ >= 0) {
    199       base::MessageLoop::current()->PostDelayedTask(
    200           FROM_HERE,
    201           base::Bind(&FakeNfcDeviceClient::HandleSimulationTimeout,
    202                      base::Unretained(this)),
    203           base::TimeDelta::FromMilliseconds(simulation_timeout_));
    204     }
    205     return;
    206   }
    207 
    208   base::MessageLoop::current()->PostDelayedTask(
    209       FROM_HERE,
    210       base::Bind(&FakeNfcDeviceClient::MakeRecordsVisible,
    211                  base::Unretained(this)),
    212       base::TimeDelta::FromMilliseconds(record_push_delay));
    213 }
    214 
    215 void FakeNfcDeviceClient::MakeRecordsVisible() {
    216   if (!pairing_started_) {
    217     VLOG(1) << "Pairing was cancelled";
    218     return;
    219   }
    220   DCHECK(device_visible_);
    221   FakeNfcRecordClient* record_client =
    222       static_cast<FakeNfcRecordClient*>(
    223           DBusThreadManager::Get()->GetNfcRecordClient());
    224   record_client->SetDeviceRecordsVisible(true);
    225 
    226   if (simulation_timeout_ < 0)
    227     return;
    228 
    229   base::MessageLoop::current()->PostDelayedTask(
    230       FROM_HERE,
    231       base::Bind(&FakeNfcDeviceClient::HandleSimulationTimeout,
    232                  base::Unretained(this)),
    233       base::TimeDelta::FromMilliseconds(simulation_timeout_));
    234 }
    235 
    236 void FakeNfcDeviceClient::HandleSimulationTimeout() {
    237   if (simulation_timeout_ < 0) {
    238     VLOG(1) << "Simulation timeout was cancelled. Nothing to do.";
    239     return;
    240   }
    241   EndPairingSimulation();
    242 }
    243 
    244 }  // namespace chromeos
    245