nfc: Implement NfcAdapterChromeOS.

Added the basic implementation of NfcAdapterChromeOS, with no tag/peer logic.

BUG=316471
TEST=device_unittests

Review URL: https://codereview.chromium.org/100393011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@239388 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 127 insertions, 8 deletions

diff --git a/chromeos/dbus/fake_nfc_adapter_client.cc b/chromeos/dbus/fake_nfc_adapter_client.cc
index f9b1688..ddc673a 100644
--- a/chromeos/dbus/fake_nfc_adapter_client.cc
+++ b/chromeos/dbus/fake_nfc_adapter_client.cc
@@ -5,14 +5,15 @@
 #include "chromeos/dbus/fake_nfc_adapter_client.h"
 
 #include "base/logging.h"
+#include "dbus/message.h"
 #include "dbus/object_path.h"
-
-// TODO(armansito): For now, this class doesn't do anything. Implement fake
-// behavior in conjunction with unit tests while implementing the src/device
-// layer.
+#include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
+const char FakeNfcAdapterClient::kAdapterPath0[] = "/fake/nfc0";
+const char FakeNfcAdapterClient::kAdapterPath1[] = "/fake/nfc1";
+
 FakeNfcAdapterClient::Properties::Properties(
     const PropertyChangedCallback& callback)
     : NfcAdapterClient::Properties(NULL, callback) {
@@ -36,11 +37,56 @@ void FakeNfcAdapterClient::Properties::Set(
     dbus::PropertyBase* property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
-  callback.Run(false);
+  if (property->name() != powered.name()) {
+    callback.Run(false);
+    return;
+  }
+
+  // Cannot set the power if currently polling.
+  if (polling.value()) {
+    callback.Run(false);
+    return;
+  }
+
+  // Obtain the cached "set value" and send a property changed signal only if
+  // its value is different from the current value of the property.
+  scoped_ptr<dbus::Response> response(dbus::Response::CreateEmpty());
+  dbus::MessageWriter writer(response.get());
+  property->AppendSetValueToWriter(&writer);
+  dbus::MessageReader reader(response.get());
+  bool set_value = false;
+  if (!reader.PopVariantOfBool(&set_value) || set_value == powered.value()) {
+    LOG(WARNING) << "Property has not changed.";
+    callback.Run(false);
+    return;
+  }
+  property->ReplaceValueWithSetValue();
+  callback.Run(true);
 }
 
-FakeNfcAdapterClient::FakeNfcAdapterClient() {
+FakeNfcAdapterClient::FakeNfcAdapterClient()
+    : present_(true),
+      second_present_(false) {
   VLOG(1) << "Creating FakeNfcAdapterClient";
+
+  std::vector<std::string> protocols;
+  protocols.push_back(nfc_common::kProtocolFelica);
+  protocols.push_back(nfc_common::kProtocolMifare);
+  protocols.push_back(nfc_common::kProtocolJewel);
+  protocols.push_back(nfc_common::kProtocolIsoDep);
+  protocols.push_back(nfc_common::kProtocolNfcDep);
+
+  properties_.reset(new Properties(base::Bind(
+      &FakeNfcAdapterClient::OnPropertyChanged,
+      base::Unretained(this),
+      dbus::ObjectPath(kAdapterPath0))));
+  properties_->protocols.ReplaceValue(protocols);
+
+  second_properties_.reset(new Properties(base::Bind(
+      &FakeNfcAdapterClient::OnPropertyChanged,
+      base::Unretained(this),
+      dbus::ObjectPath(kAdapterPath1))));
+  second_properties_->protocols.ReplaceValue(protocols);
 }
 
 FakeNfcAdapterClient::~FakeNfcAdapterClient() {
@@ -50,13 +96,28 @@ void FakeNfcAdapterClient::Init(dbus::Bus* bus) {
 }
 
 void FakeNfcAdapterClient::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
 }
 
 void FakeNfcAdapterClient::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+std::vector<dbus::ObjectPath> FakeNfcAdapterClient::GetAdapters() {
+  std::vector<dbus::ObjectPath> object_paths;
+  if (present_)
+    object_paths.push_back(dbus::ObjectPath(kAdapterPath0));
+  if (second_present_)
+    object_paths.push_back(dbus::ObjectPath(kAdapterPath1));
+  return object_paths;
 }
 
 FakeNfcAdapterClient::Properties*
 FakeNfcAdapterClient::GetProperties(const dbus::ObjectPath& object_path) {
+  if (object_path == dbus::ObjectPath(kAdapterPath0))
+    return properties_.get();
+  if (object_path == dbus::ObjectPath(kAdapterPath1))
+    return second_properties_.get();
   return NULL;
 }
 
@@ -65,14 +126,72 @@ void FakeNfcAdapterClient::StartPollLoop(
     const std::string& mode,
     const base::Closure& callback,
     const nfc_client_helpers::ErrorCallback& error_callback) {
-  VLOG(1) << "FakeNfcAdapterClient::StartPollLoop called. Nothing happened.";
+  VLOG(1) << "FakeNfcAdapterClient::StartPollLoop";
+  if (object_path != dbus::ObjectPath(kAdapterPath0)) {
+    error_callback.Run(nfc_client_helpers::kNoResponseError, "");
+    return;
+  }
+  if (!properties_->powered.value()) {
+    error_callback.Run("org.neard.Error.Failed", "Adapter not powered.");
+    return;
+  }
+  if (properties_->polling.value()) {
+    error_callback.Run("org.neard.Error.Failed", "Already polling.");
+    return;
+  }
+  properties_->polling.ReplaceValue(true);
+  properties_->mode.ReplaceValue(mode);
+  // TODO(armansito): Initiate fake device/tag simulation here.
 }
 
 void FakeNfcAdapterClient::StopPollLoop(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const nfc_client_helpers::ErrorCallback& error_callback) {
-  VLOG(1) << "FakeNfcAdapterClient::StopPollLoop called. Nothing happened.";
+  VLOG(1) << "FakeNfcAdapterClient::StopPollLoop.";
+  if (object_path != dbus::ObjectPath(kAdapterPath0)) {
+    error_callback.Run(nfc_client_helpers::kNoResponseError, "");
+    return;
+  }
+  if (!properties_->polling.value()) {
+    error_callback.Run("org.neard.Error.Failed", "Not polling.");
+    return;
+  }
+  // TODO(armansito): End fake device/tag simulation here.
+  properties_->polling.ReplaceValue(false);
+}
+
+void FakeNfcAdapterClient::SetAdapterPresent(bool present) {
+  if (present == present_)
+    return;
+  present_ = present;
+  if (present_) {
+    FOR_EACH_OBSERVER(NfcAdapterClient::Observer, observers_,
+                      AdapterAdded(dbus::ObjectPath(kAdapterPath0)));
+  } else {
+    FOR_EACH_OBSERVER(NfcAdapterClient::Observer, observers_,
+                      AdapterRemoved(dbus::ObjectPath(kAdapterPath0)));
+  }
+}
+
+void FakeNfcAdapterClient::SetSecondAdapterPresent(bool present) {
+  if (present == second_present_)
+    return;
+  second_present_ = present;
+  if (present_) {
+    FOR_EACH_OBSERVER(NfcAdapterClient::Observer, observers_,
+                      AdapterAdded(dbus::ObjectPath(kAdapterPath1)));
+  } else {
+    FOR_EACH_OBSERVER(NfcAdapterClient::Observer, observers_,
+                      AdapterRemoved(dbus::ObjectPath(kAdapterPath1)));
+  }
+}
+
+void FakeNfcAdapterClient::OnPropertyChanged(
+    const dbus::ObjectPath& object_path,
+    const std::string& property_name) {
+  FOR_EACH_OBSERVER(NfcAdapterClient::Observer, observers_,
+                    AdapterPropertyChanged(object_path, property_name));
 }
 
 }  // namespace chromeos