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_record_client.h"
      6 
      7 #include "base/logging.h"
      8 #include "chromeos/dbus/dbus_thread_manager.h"
      9 #include "chromeos/dbus/fake_nfc_device_client.h"
     10 #include "chromeos/dbus/fake_nfc_tag_client.h"
     11 #include "third_party/cros_system_api/dbus/service_constants.h"
     12 
     13 namespace chromeos {
     14 
     15 namespace {
     16 
     17 // Gets and returns the value for |key| in |dictionary| as a string. If |key| is
     18 // not found, returns an empty string.
     19 std::string GetStringValue(const base::DictionaryValue& dictionary,
     20                            const std::string& key) {
     21   std::string value;
     22   bool result = dictionary.GetString(key, &value);
     23 
     24   // Simply return |value|. |value| will remain untouched if
     25   // base::DictionaryValue::GetString returns false.
     26   DCHECK(result || value.empty());
     27   return value;
     28 }
     29 
     30 // Gets and returns the value for |key| in |dictionary| as a double. If |key| is
     31 // not found, returns 0.
     32 double GetDoubleValue(const base::DictionaryValue& dictionary,
     33                       const std::string& key) {
     34   double value = 0;
     35   bool result = dictionary.GetDouble(key, &value);
     36 
     37   // Simply return |value|. |value| will remain untouched if
     38   // base::DictionaryValue::GetString returns false.
     39   DCHECK(result || !value);
     40   return value;
     41 }
     42 
     43 }  // namespace
     44 
     45 const char FakeNfcRecordClient::kDeviceSmartPosterRecordPath[] =
     46     "/fake/device/record0";
     47 const char FakeNfcRecordClient::kDeviceTextRecordPath[] =
     48     "/fake/device/record1";
     49 const char FakeNfcRecordClient::kDeviceUriRecordPath[] = "/fake/device/record2";
     50 const char FakeNfcRecordClient::kTagRecordPath[] = "/fake/tag/record0";
     51 
     52 FakeNfcRecordClient::Properties::Properties(
     53     const PropertyChangedCallback& callback)
     54     : NfcRecordClient::Properties(NULL, callback) {
     55 }
     56 
     57 FakeNfcRecordClient::Properties::~Properties() {
     58 }
     59 
     60 void FakeNfcRecordClient::Properties::Get(
     61     dbus::PropertyBase* property,
     62     dbus::PropertySet::GetCallback callback) {
     63   VLOG(1) << "Get " << property->name();
     64   callback.Run(false);
     65 }
     66 
     67 void FakeNfcRecordClient::Properties::GetAll() {
     68   VLOG(1) << "GetAll";
     69   if (!on_get_all_callback().is_null())
     70     on_get_all_callback().Run();
     71 }
     72 
     73 void FakeNfcRecordClient::Properties::Set(
     74     dbus::PropertyBase* property,
     75     dbus::PropertySet::SetCallback callback) {
     76   VLOG(1) << "Set " << property->name();
     77   callback.Run(false);
     78 }
     79 
     80 FakeNfcRecordClient::FakeNfcRecordClient()
     81     : device_records_visible_(false),
     82       tag_records_visible_(false) {
     83   VLOG(1) << "Creating FakeNfcRecordClient";
     84 
     85   device_smart_poster_record_properties_.reset(new Properties(
     86       base::Bind(&FakeNfcRecordClient::OnPropertyChanged,
     87                  base::Unretained(this),
     88                  dbus::ObjectPath(kDeviceSmartPosterRecordPath))));
     89   device_smart_poster_record_properties_->SetAllPropertiesReceivedCallback(
     90       base::Bind(&FakeNfcRecordClient::OnPropertiesReceived,
     91                  base::Unretained(this),
     92                  dbus::ObjectPath(kDeviceSmartPosterRecordPath)));
     93 
     94   device_text_record_properties_.reset(new Properties(
     95       base::Bind(&FakeNfcRecordClient::OnPropertyChanged,
     96                  base::Unretained(this),
     97                  dbus::ObjectPath(kDeviceTextRecordPath))));
     98   device_text_record_properties_->SetAllPropertiesReceivedCallback(
     99       base::Bind(&FakeNfcRecordClient::OnPropertiesReceived,
    100                  base::Unretained(this),
    101                  dbus::ObjectPath(kDeviceTextRecordPath)));
    102 
    103   device_uri_record_properties_.reset(new Properties(
    104       base::Bind(&FakeNfcRecordClient::OnPropertyChanged,
    105                  base::Unretained(this),
    106                  dbus::ObjectPath(kDeviceUriRecordPath))));
    107   device_uri_record_properties_->SetAllPropertiesReceivedCallback(
    108       base::Bind(&FakeNfcRecordClient::OnPropertiesReceived,
    109                  base::Unretained(this),
    110                  dbus::ObjectPath(kDeviceUriRecordPath)));
    111 
    112   tag_record_properties_.reset(new Properties(
    113       base::Bind(&FakeNfcRecordClient::OnPropertyChanged,
    114                  base::Unretained(this),
    115                  dbus::ObjectPath(kTagRecordPath))));
    116 }
    117 
    118 FakeNfcRecordClient::~FakeNfcRecordClient() {
    119 }
    120 
    121 void FakeNfcRecordClient::Init(dbus::Bus* bus) {
    122 }
    123 
    124 void FakeNfcRecordClient::AddObserver(Observer* observer) {
    125   observers_.AddObserver(observer);
    126 }
    127 
    128 void FakeNfcRecordClient::RemoveObserver(Observer* observer) {
    129   observers_.RemoveObserver(observer);
    130 }
    131 
    132 std::vector<dbus::ObjectPath> FakeNfcRecordClient::GetRecordsForDevice(
    133       const dbus::ObjectPath& device_path) {
    134   std::vector<dbus::ObjectPath> record_paths;
    135   if (device_records_visible_ &&
    136       device_path == dbus::ObjectPath(FakeNfcDeviceClient::kDevicePath)) {
    137     record_paths.push_back(dbus::ObjectPath(kDeviceSmartPosterRecordPath));
    138     record_paths.push_back(dbus::ObjectPath(kDeviceTextRecordPath));
    139     record_paths.push_back(dbus::ObjectPath(kDeviceUriRecordPath));
    140   }
    141   return record_paths;
    142 }
    143 
    144 std::vector<dbus::ObjectPath> FakeNfcRecordClient::GetRecordsForTag(
    145       const dbus::ObjectPath& tag_path) {
    146   std::vector<dbus::ObjectPath> record_paths;
    147   if (tag_records_visible_ && tag_path.value() == FakeNfcTagClient::kTagPath)
    148     record_paths.push_back(dbus::ObjectPath(kTagRecordPath));
    149   return record_paths;
    150 }
    151 
    152 FakeNfcRecordClient::Properties*
    153 FakeNfcRecordClient::GetProperties(const dbus::ObjectPath& object_path) {
    154   if (device_records_visible_) {
    155     if (object_path.value() == kDeviceSmartPosterRecordPath)
    156       return device_smart_poster_record_properties_.get();
    157     if (object_path.value() == kDeviceTextRecordPath)
    158       return device_text_record_properties_.get();
    159     if (object_path.value() == kDeviceUriRecordPath)
    160       return device_uri_record_properties_.get();
    161     return NULL;
    162   }
    163   if (tag_records_visible_ && object_path.value() == kTagRecordPath)
    164       return tag_record_properties_.get();
    165   return NULL;
    166 }
    167 
    168 void FakeNfcRecordClient::SetDeviceRecordsVisible(bool visible) {
    169   if (device_records_visible_ == visible) {
    170     VLOG(1) << "Record visibility is already: " << visible;
    171     return;
    172   }
    173   FakeNfcDeviceClient* device_client = static_cast<FakeNfcDeviceClient*>(
    174       DBusThreadManager::Get()->GetNfcDeviceClient());
    175   if (!device_client->device_visible()) {
    176     VLOG(1) << "Cannot set records when device is not visible.";
    177     return;
    178   }
    179   if (!visible) {
    180     device_client->ClearRecords();
    181     FOR_EACH_OBSERVER(
    182         NfcRecordClient::Observer, observers_,
    183         RecordRemoved(dbus::ObjectPath(kDeviceSmartPosterRecordPath)));
    184     FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    185                       RecordRemoved(dbus::ObjectPath(kDeviceTextRecordPath)));
    186     FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    187                       RecordRemoved(dbus::ObjectPath(kDeviceUriRecordPath)));
    188     device_records_visible_ = visible;
    189     return;
    190   }
    191   device_records_visible_ = visible;
    192   std::vector<dbus::ObjectPath> record_paths =
    193       GetRecordsForDevice(
    194           dbus::ObjectPath(FakeNfcDeviceClient::kDevicePath));
    195   device_client->SetRecords(record_paths);
    196 
    197   // Reassign each property and send signals.
    198   FOR_EACH_OBSERVER(
    199       NfcRecordClient::Observer, observers_,
    200       RecordAdded(dbus::ObjectPath(kDeviceSmartPosterRecordPath)));
    201   device_smart_poster_record_properties_->type.ReplaceValue(
    202       nfc_record::kTypeSmartPoster);
    203   device_smart_poster_record_properties_->uri.ReplaceValue(
    204       "http://fake.uri0.fake");
    205   device_smart_poster_record_properties_->mime_type.ReplaceValue("text/fake");
    206   device_smart_poster_record_properties_->size.ReplaceValue(128);
    207   device_smart_poster_record_properties_->
    208       representation.ReplaceValue("Fake Title");
    209   device_smart_poster_record_properties_->encoding.ReplaceValue(
    210       nfc_record::kEncodingUtf16);
    211   device_smart_poster_record_properties_->language.ReplaceValue("en");
    212   OnPropertiesReceived(dbus::ObjectPath(kDeviceSmartPosterRecordPath));
    213 
    214   FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    215                     RecordAdded(dbus::ObjectPath(kDeviceTextRecordPath)));
    216   device_text_record_properties_->type.ReplaceValue(nfc_record::kTypeText);
    217   device_text_record_properties_->representation.ReplaceValue(
    218       "Kablosuz \xC4\xb0leti\xC5\x9fim");
    219   device_text_record_properties_->encoding.ReplaceValue(
    220       nfc_record::kEncodingUtf8);
    221   device_text_record_properties_->language.ReplaceValue("tr");
    222   OnPropertiesReceived(dbus::ObjectPath(kDeviceTextRecordPath));
    223 
    224   FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    225                     RecordAdded(dbus::ObjectPath(kDeviceUriRecordPath)));
    226   device_uri_record_properties_->type.ReplaceValue(nfc_record::kTypeUri);
    227   device_uri_record_properties_->uri.ReplaceValue("file://some/fake/path");
    228   device_uri_record_properties_->mime_type.ReplaceValue("text/fake");
    229   device_uri_record_properties_->size.ReplaceValue(512);
    230   OnPropertiesReceived(dbus::ObjectPath(kDeviceUriRecordPath));
    231 }
    232 
    233 void FakeNfcRecordClient::SetTagRecordsVisible(bool visible) {
    234   if (tag_records_visible_ == visible) {
    235     VLOG(1) << "Record visibility is already: " << visible;
    236     return;
    237   }
    238   FakeNfcTagClient* tag_client = static_cast<FakeNfcTagClient*>(
    239       DBusThreadManager::Get()->GetNfcTagClient());
    240   if (!tag_client->tag_visible()) {
    241     VLOG(1) << "Cannot set records when tag is not visible.";
    242     return;
    243   }
    244   if (!visible) {
    245     tag_client->ClearRecords();
    246     FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    247                       RecordRemoved(dbus::ObjectPath(kTagRecordPath)));
    248     tag_records_visible_ = visible;
    249     return;
    250   }
    251   tag_records_visible_ = visible;
    252   std::vector<dbus::ObjectPath> record_paths =
    253     GetRecordsForTag(dbus::ObjectPath(FakeNfcTagClient::kTagPath));
    254   tag_client->SetRecords(record_paths);
    255 
    256   // Reassign each property to its current value to trigger a property change
    257   // signal.
    258   FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    259                     RecordAdded(dbus::ObjectPath(kTagRecordPath)));
    260   tag_record_properties_->type.ReplaceValue(
    261       tag_record_properties_->type.value());
    262   tag_record_properties_->representation.ReplaceValue(
    263       tag_record_properties_->representation.value());
    264   tag_record_properties_->encoding.ReplaceValue(
    265       tag_record_properties_->encoding.value());
    266   tag_record_properties_->language.ReplaceValue(
    267       tag_record_properties_->language.value());
    268   tag_record_properties_->uri.ReplaceValue(
    269       tag_record_properties_->uri.value());
    270   tag_record_properties_->mime_type.ReplaceValue(
    271       tag_record_properties_->mime_type.value());
    272   tag_record_properties_->size.ReplaceValue(
    273       tag_record_properties_->size.value());
    274   tag_record_properties_->action.ReplaceValue(
    275       tag_record_properties_->action.value());
    276   OnPropertiesReceived(dbus::ObjectPath(kTagRecordPath));
    277 }
    278 
    279 bool FakeNfcRecordClient::WriteTagRecord(
    280     const base::DictionaryValue& attributes) {
    281   if (attributes.empty())
    282     return false;
    283 
    284   tag_record_properties_->type.ReplaceValue(
    285       GetStringValue(attributes, nfc_record::kTypeProperty));
    286   tag_record_properties_->encoding.ReplaceValue(
    287       GetStringValue(attributes, nfc_record::kEncodingProperty));
    288   tag_record_properties_->language.ReplaceValue(
    289       GetStringValue(attributes, nfc_record::kLanguageProperty));
    290   tag_record_properties_->representation.ReplaceValue(
    291       GetStringValue(attributes, nfc_record::kRepresentationProperty));
    292   tag_record_properties_->uri.ReplaceValue(
    293       GetStringValue(attributes, nfc_record::kUriProperty));
    294   tag_record_properties_->mime_type.ReplaceValue(
    295       GetStringValue(attributes, nfc_record::kMimeTypeProperty));
    296   tag_record_properties_->action.ReplaceValue(
    297       GetStringValue(attributes, nfc_record::kActionProperty));
    298   tag_record_properties_->size.ReplaceValue(static_cast<uint32>(
    299       GetDoubleValue(attributes, nfc_record::kSizeProperty)));
    300 
    301   SetTagRecordsVisible(false);
    302   SetTagRecordsVisible(true);
    303 
    304   return true;
    305 }
    306 
    307 void FakeNfcRecordClient::OnPropertyChanged(
    308     const dbus::ObjectPath& object_path,
    309     const std::string& property_name) {
    310   FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    311                     RecordPropertyChanged(object_path, property_name));
    312 }
    313 
    314 void FakeNfcRecordClient::OnPropertiesReceived(
    315     const dbus::ObjectPath& object_path) {
    316   FOR_EACH_OBSERVER(NfcRecordClient::Observer, observers_,
    317                     RecordPropertiesReceived(object_path));
    318 }
    319 
    320 }  // namespace chromeos
    321