tests_schema/daemon/testdevice/testdevice.cc - weave/libweave - Git at Google

 // Copyright 2016 The Weave Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <algorithm>
 #include <bitset>
 #include <string>
 #include <typeinfo>

 #include "examples/daemon/common/daemon.h"
 #include "tests_schema/daemon/testdevice/custom_traits.h"
 #include "tests_schema/daemon/testdevice/standard_traits.h"

 #include <weave/device.h>
 #include <weave/enum_to_string.h>

 #include <base/bind.h>
 #include <base/memory/weak_ptr.h>

 namespace weave {
 namespace lockstate {
 enum class LockState { kUnlocked, kLocked, kPartiallyLocked };

 const weave::EnumToStringMap<LockState>::Map kLockMapMethod[] = {
     {LockState::kLocked, "locked"},
     {LockState::kUnlocked, "unlocked"},
     {LockState::kPartiallyLocked, "partiallyLocked"}};
 }  // namespace lockstate

 template <>
 EnumToStringMap<lockstate::LockState>::EnumToStringMap()
     : EnumToStringMap(lockstate::kLockMapMethod) {}
 }  // namespace weave

 // TestDeviceHandler is a command handler example that shows
 // how to handle commands for a Weave testdevice.
 class TestDeviceHandler {
  public:
   TestDeviceHandler() = default;
   void Register(weave::Device* device) {
     device_ = device;

     device->AddTraitDefinitionsFromJson(standard_traits::kTraits);
     device->AddTraitDefinitionsFromJson(custom_traits::kCustomTraits);

     CHECK(device->AddComponent(
         standard_traits::kComponent,
         {"lock", "onOff", "brightness", "volume", "colorTemp", "colorXy"},
         nullptr));
     CHECK(device->AddComponent(custom_traits::ledflasher, {"_ledflasher"},
                                nullptr));

     CHECK(device->SetStatePropertiesFromJson(
         standard_traits::kComponent, standard_traits::kDefaultState, nullptr));
     CHECK(device->SetStatePropertiesFromJson(
         custom_traits::ledflasher, custom_traits::kLedflasherState, nullptr));

     for (size_t led_index = 0; led_index < led_states_.size(); led_index++) {
       std::string component_name =
           custom_traits::kLedComponentPrefix + std::to_string(led_index + 1);
       CHECK(device->AddComponent(component_name, {"onOff"}, nullptr));
       device->AddCommandHandler(
           component_name, "onOff.setConfig",
           base::Bind(&TestDeviceHandler::LedOnOffSetConfig,
                      weak_ptr_factory_.GetWeakPtr(), led_index));
       device->SetStateProperty(
           component_name, "onOff.state",
           base::StringValue{led_states_[led_index] ? "on" : "off"}, nullptr);
     }

     UpdateTestDeviceState();

     device->AddCommandHandler(standard_traits::kComponent, "onOff.setConfig",
                               base::Bind(&TestDeviceHandler::OnOnOffSetConfig,
                                          weak_ptr_factory_.GetWeakPtr()));
     device->AddCommandHandler(standard_traits::kComponent, "lock.setConfig",
                               base::Bind(&TestDeviceHandler::OnLockSetConfig,
                                          weak_ptr_factory_.GetWeakPtr()));
     device->AddCommandHandler(
         standard_traits::kComponent, "brightness.setConfig",
         base::Bind(&TestDeviceHandler::OnBrightnessSetConfig,
                    weak_ptr_factory_.GetWeakPtr()));
     device->AddCommandHandler(standard_traits::kComponent, "volume.setConfig",
                               base::Bind(&TestDeviceHandler::OnVolumeSetConfig,
                                          weak_ptr_factory_.GetWeakPtr()));
     device->AddCommandHandler(
         standard_traits::kComponent, "colorTemp.setConfig",
         base::Bind(&TestDeviceHandler::OnColorTempSetConfig,
                    weak_ptr_factory_.GetWeakPtr()));
     device->AddCommandHandler(standard_traits::kComponent, "colorXy.setConfig",
                               base::Bind(&TestDeviceHandler::OnColorXySetConfig,
                                          weak_ptr_factory_.GetWeakPtr()));
     device->AddCommandHandler(custom_traits::ledflasher, "_ledflasher.animate",
                               base::Bind(&TestDeviceHandler::OnAnimate,
                                          weak_ptr_factory_.GetWeakPtr()));
   }

  private:
   void OnLockSetConfig(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();
     const auto& params = cmd->GetParameters();
     std::string requested_state;
     if (params.GetString("lockedState", &requested_state)) {
       LOG(INFO) << cmd->GetName() << " state: " << requested_state;

       weave::lockstate::LockState new_lock_status;

       if (!weave::StringToEnum(requested_state, &new_lock_status)) {
         // Invalid lock state was specified.
         AbortCommand(cmd);
         return;
       }

       if (new_lock_status != lock_state_) {
         lock_state_ = new_lock_status;

         LOG(INFO) << "Lock is now: " << requested_state;
         UpdateTestDeviceState();
       }
       cmd->Complete({}, nullptr);
       return;
     }
     AbortCommand(cmd);
   }

   void OnBrightnessSetConfig(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();
     const auto& params = cmd->GetParameters();
     double brightness_value = 0.0;
     if (params.GetDouble("brightness", &brightness_value)) {
       LOG(INFO) << cmd->GetName() << " brightness: " << brightness_value;

       if (brightness_value < 0.0 || brightness_value > 1.0) {
         // Invalid brightness range value is specified.
         AbortCommand(cmd);
         return;
       }

       if (brightness_state_ != brightness_value) {
         brightness_state_ = brightness_value;
         UpdateTestDeviceState();
       }
       cmd->Complete({}, nullptr);
       return;
     }
     AbortCommand(cmd);
   }

   void OnVolumeSetConfig(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();
     const auto& params = cmd->GetParameters();
     // Handle volume parameter
     bool updateState = false;
     int32_t volume_value = 0;
     if (params.GetInteger("volume", &volume_value)) {
       LOG(INFO) << cmd->GetName() << " volume: " << volume_value;

       if (volume_value < 0 || volume_value > 100) {
         // Invalid volume range value is specified.
         AbortCommand(cmd);
         return;
       }

       if (volume_value_ != volume_value) {
         volume_value_ = volume_value;
         updateState = true;
       }
     }

     // Handle isMuted parameter
     bool isMuted_status = false;
     if (params.GetBoolean("isMuted", &isMuted_status)) {
       LOG(INFO) << cmd->GetName() << " is "
                 << (isMuted_status ? "muted" : "not muted");

       if (isMuted_status_ != isMuted_status) {
         isMuted_status_ = isMuted_status;
         LOG(INFO) << "Speaker is now: "
                   << (isMuted_status ? "muted" : "not muted");
         updateState = true;
       }
     }

     if (updateState) {
       UpdateTestDeviceState();
     }
     cmd->Complete({}, nullptr);
   }

   void OnOnOffSetConfig(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();
     const auto& params = cmd->GetParameters();
     std::string requested_state;
     if (params.GetString("state", &requested_state)) {
       LOG(INFO) << cmd->GetName() << " state: " << requested_state;

       std::string temp_state = requested_state;
       if (temp_state != "on" && temp_state != "off") {
         // Invalid OnOff state is specified.
         AbortCommand(cmd);
         return;
       }

       bool new_device_status = requested_state == "on";
       if (new_device_status != device_status_) {
         device_status_ = new_device_status;
         LOG(INFO) << "Device is now: " << (device_status_ ? "ON" : "OFF");
         UpdateTestDeviceState();
       }
       cmd->Complete({}, nullptr);
       return;
     }
     AbortCommand(cmd);
   }

   void OnColorTempSetConfig(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();

     const auto& params = cmd->GetParameters();
     int32_t color_temp = 0;
     if (params.GetInteger("colorTemp", &color_temp)) {
       LOG(INFO) << cmd->GetName() << " colorTemp: " << color_temp;

       if (color_temp < 0.0 || color_temp > 1.0) {
         // Invalid color_temp value is specified.
         AbortCommand(cmd);
         return;
       }

       if (color_temp != color_temp_) {
         color_temp_ = color_temp;

         LOG(INFO) << "color_Temp is now: " << color_temp_;
         UpdateTestDeviceState();
       }
       cmd->Complete({}, nullptr);
       return;
     }

     AbortCommand(cmd);
   }

   void OnColorXySetConfig(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();
     const auto& params = cmd->GetParameters();
     const base::DictionaryValue* colorXy = nullptr;
     if (params.GetDictionary("colorSetting", &colorXy)) {
       bool updateState = false;
       double X = 0.0;
       double Y = 0.0;
       if (colorXy->GetDouble("colorX", &X)) {
         color_X_ = X;
         updateState = true;
       }

       if (colorXy->GetDouble("colorY", &Y)) {
         color_Y_ = Y;
         updateState = true;
       }

       if ((color_X_ < 0.0 || color_Y_ > 1.0) ||
           (color_Y_ < 0.0 || color_Y_ > 1.0)) {
         // Invalid color range value is specified.
         AbortCommand(cmd);
         return;
       }

       if (updateState)
         UpdateTestDeviceState();

       cmd->Complete({}, nullptr);
       return;
     }

     AbortCommand(cmd);
   }

   void OnAnimate(const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;

     const auto& params = cmd->GetParameters();
     double duration = 0.0;
     std::string type;

     if (params.GetDouble("duration", &duration)) {
       LOG(INFO) << cmd->GetName() << " animate duration : " << duration;

       if (duration <= 0.0 || duration > 100.0) {
         // Invalid animate duration value is specified.
         AbortCommand(cmd);
         return;
       }

       if (params.GetString("type", &type)) {
         LOG(INFO) << " Animation type value is : " << type;
         if (type != "marquee_left" && type != "marquee_right" &&
             type != "blink" && type != "none") {
           // Invalid animation state is specified.
           AbortCommand(cmd);
           return;
         }
       }

       cmd->Complete({}, nullptr);
       return;
     }

     AbortCommand(cmd);
   }

   void LedOnOffSetConfig(size_t led_index,
                          const std::weak_ptr<weave::Command>& command) {
     auto cmd = command.lock();
     if (!cmd)
       return;
     LOG(INFO) << "received command: " << cmd->GetName();
     const auto& params = cmd->GetParameters();
     std::string state;
     if (params.GetString("state", &state)) {
       LOG(INFO) << cmd->GetName() << " led: " << led_index
                 << " state: " << state;

       std::string temp_state = state;
       if (temp_state != "on" && temp_state != "off") {
         // Invalid OnOff state is specified.
         AbortCommand(cmd);
         return;
       }

       int current_state = led_states_[led_index];
       int new_state = (state == "on") ? 1 : 0;
       led_states_[led_index] = new_state;
       if (new_state != current_state) {
         device_->SetStateProperty(cmd->GetComponent(), "onOff.state",
                                   base::StringValue{state}, nullptr);
       }
       cmd->Complete({}, nullptr);
       return;
     }
     AbortCommand(cmd);
   }

   void UpdateTestDeviceState() {
     std::string updated_state = weave::EnumToString(lock_state_);
     device_->SetStateProperty(standard_traits::kComponent, "lock.lockedState",
                               base::StringValue{updated_state}, nullptr);
     base::DictionaryValue state;
     state.SetString("onOff.state", device_status_ ? "on" : "off");
     state.SetDouble("brightness.brightness", brightness_state_);
     // state.SetString("onOff.state", speaker_status_ ? "on" : "off");
     state.SetBoolean("volume.isMuted", isMuted_status_);
     state.SetInteger("volume.volume", volume_value_);
     state.SetInteger("colorTemp.minColorTemp", color_temp_min_value_);
     state.SetInteger("colorTemp.maxColorTemp", color_temp_max_value_);
     state.SetInteger("colorTemp.colorTemp", color_temp_);

     std::unique_ptr<base::DictionaryValue> colorXy(new base::DictionaryValue());
     colorXy->SetDouble("colorX", color_X_);
     colorXy->SetDouble("colorY", color_Y_);
     state.Set("colorXy.colorSetting", std::move(colorXy));

     device_->SetStateProperties(standard_traits::kComponent, state, nullptr);
   }

   void AbortCommand(std::shared_ptr<weave::Command>& cmd) {
     weave::ErrorPtr error;
     weave::Error::AddTo(&error, FROM_HERE, "invalidParameterValue",
                         "Invalid parameters");
     cmd->Abort(error.get(), nullptr);
   }

   weave::Device* device_{nullptr};

   // Simulate the state of the testdevice.
   weave::lockstate::LockState lock_state_{weave::lockstate::LockState::kLocked};
   bool device_status_{false};
   double brightness_state_{0.0};
   bool isMuted_status_{false};
   int32_t volume_value_{0};
   int32_t color_temp_{0};
   int32_t color_temp_min_value_{0};
   int32_t color_temp_max_value_{1};
   double color_X_{0.0};
   double color_Y_{0.0};
   double duration{0.1};
   std::bitset<custom_traits::kLedCount> led_states_{0};
   base::WeakPtrFactory<TestDeviceHandler> weak_ptr_factory_{this};
 };

 int main(int argc, char** argv) {
   Daemon::Options opts;
   opts.model_id = "AOAAA";
   if (!opts.Parse(argc, argv)) {
     Daemon::Options::ShowUsage(argv[0]);
     return 1;
   }
   Daemon daemon{opts};
   TestDeviceHandler handler;
   handler.Register(daemon.GetDevice());
   daemon.Run();
   return 0;
 }
	// Copyright 2016 The Weave Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <algorithm>
	#include <bitset>
	#include <string>
	#include <typeinfo>

	#include "examples/daemon/common/daemon.h"
	#include "tests_schema/daemon/testdevice/custom_traits.h"
	#include "tests_schema/daemon/testdevice/standard_traits.h"

	#include <weave/device.h>
	#include <weave/enum_to_string.h>

	#include <base/bind.h>
	#include <base/memory/weak_ptr.h>

	namespace weave {
	namespace lockstate {
	enum class LockState { kUnlocked, kLocked, kPartiallyLocked };

	const weave::EnumToStringMap<LockState>::Map kLockMapMethod[] = {
	{LockState::kLocked, "locked"},
	{LockState::kUnlocked, "unlocked"},
	{LockState::kPartiallyLocked, "partiallyLocked"}};
	} // namespace lockstate

	template <>
	EnumToStringMap<lockstate::LockState>::EnumToStringMap()
	: EnumToStringMap(lockstate::kLockMapMethod) {}
	} // namespace weave

	// TestDeviceHandler is a command handler example that shows
	// how to handle commands for a Weave testdevice.
	class TestDeviceHandler {
	public:
	TestDeviceHandler() = default;
	void Register(weave::Device* device) {
	device_ = device;

	device->AddTraitDefinitionsFromJson(standard_traits::kTraits);
	device->AddTraitDefinitionsFromJson(custom_traits::kCustomTraits);

	CHECK(device->AddComponent(
	standard_traits::kComponent,
	{"lock", "onOff", "brightness", "volume", "colorTemp", "colorXy"},
	nullptr));
	CHECK(device->AddComponent(custom_traits::ledflasher, {"_ledflasher"},
	nullptr));

	CHECK(device->SetStatePropertiesFromJson(
	standard_traits::kComponent, standard_traits::kDefaultState, nullptr));
	CHECK(device->SetStatePropertiesFromJson(
	custom_traits::ledflasher, custom_traits::kLedflasherState, nullptr));

	for (size_t led_index = 0; led_index < led_states_.size(); led_index++) {
	std::string component_name =
	custom_traits::kLedComponentPrefix + std::to_string(led_index + 1);
	CHECK(device->AddComponent(component_name, {"onOff"}, nullptr));
	device->AddCommandHandler(
	component_name, "onOff.setConfig",
	base::Bind(&TestDeviceHandler::LedOnOffSetConfig,
	weak_ptr_factory_.GetWeakPtr(), led_index));
	device->SetStateProperty(
	component_name, "onOff.state",
	base::StringValue{led_states_[led_index] ? "on" : "off"}, nullptr);
	}

	UpdateTestDeviceState();

	device->AddCommandHandler(standard_traits::kComponent, "onOff.setConfig",
	base::Bind(&TestDeviceHandler::OnOnOffSetConfig,
	weak_ptr_factory_.GetWeakPtr()));
	device->AddCommandHandler(standard_traits::kComponent, "lock.setConfig",
	base::Bind(&TestDeviceHandler::OnLockSetConfig,
	weak_ptr_factory_.GetWeakPtr()));
	device->AddCommandHandler(
	standard_traits::kComponent, "brightness.setConfig",
	base::Bind(&TestDeviceHandler::OnBrightnessSetConfig,
	weak_ptr_factory_.GetWeakPtr()));
	device->AddCommandHandler(standard_traits::kComponent, "volume.setConfig",
	base::Bind(&TestDeviceHandler::OnVolumeSetConfig,
	weak_ptr_factory_.GetWeakPtr()));
	device->AddCommandHandler(
	standard_traits::kComponent, "colorTemp.setConfig",
	base::Bind(&TestDeviceHandler::OnColorTempSetConfig,
	weak_ptr_factory_.GetWeakPtr()));
	device->AddCommandHandler(standard_traits::kComponent, "colorXy.setConfig",
	base::Bind(&TestDeviceHandler::OnColorXySetConfig,
	weak_ptr_factory_.GetWeakPtr()));
	device->AddCommandHandler(custom_traits::ledflasher, "_ledflasher.animate",
	base::Bind(&TestDeviceHandler::OnAnimate,
	weak_ptr_factory_.GetWeakPtr()));
	}

	private:
	void OnLockSetConfig(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();
	const auto& params = cmd->GetParameters();
	std::string requested_state;
	if (params.GetString("lockedState", &requested_state)) {
	LOG(INFO) << cmd->GetName() << " state: " << requested_state;

	weave::lockstate::LockState new_lock_status;

	if (!weave::StringToEnum(requested_state, &new_lock_status)) {
	// Invalid lock state was specified.
	AbortCommand(cmd);
	return;
	}

	if (new_lock_status != lock_state_) {
	lock_state_ = new_lock_status;

	LOG(INFO) << "Lock is now: " << requested_state;
	UpdateTestDeviceState();
	}
	cmd->Complete({}, nullptr);
	return;
	}
	AbortCommand(cmd);
	}

	void OnBrightnessSetConfig(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();
	const auto& params = cmd->GetParameters();
	double brightness_value = 0.0;
	if (params.GetDouble("brightness", &brightness_value)) {
	LOG(INFO) << cmd->GetName() << " brightness: " << brightness_value;

	if (brightness_value < 0.0 \|\| brightness_value > 1.0) {
	// Invalid brightness range value is specified.
	AbortCommand(cmd);
	return;
	}

	if (brightness_state_ != brightness_value) {
	brightness_state_ = brightness_value;
	UpdateTestDeviceState();
	}
	cmd->Complete({}, nullptr);
	return;
	}
	AbortCommand(cmd);
	}

	void OnVolumeSetConfig(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();
	const auto& params = cmd->GetParameters();
	// Handle volume parameter
	bool updateState = false;
	int32_t volume_value = 0;
	if (params.GetInteger("volume", &volume_value)) {
	LOG(INFO) << cmd->GetName() << " volume: " << volume_value;

	if (volume_value < 0 \|\| volume_value > 100) {
	// Invalid volume range value is specified.
	AbortCommand(cmd);
	return;
	}

	if (volume_value_ != volume_value) {
	volume_value_ = volume_value;
	updateState = true;
	}
	}

	// Handle isMuted parameter
	bool isMuted_status = false;
	if (params.GetBoolean("isMuted", &isMuted_status)) {
	LOG(INFO) << cmd->GetName() << " is "
	<< (isMuted_status ? "muted" : "not muted");

	if (isMuted_status_ != isMuted_status) {
	isMuted_status_ = isMuted_status;
	LOG(INFO) << "Speaker is now: "
	<< (isMuted_status ? "muted" : "not muted");
	updateState = true;
	}
	}

	if (updateState) {
	UpdateTestDeviceState();
	}
	cmd->Complete({}, nullptr);
	}

	void OnOnOffSetConfig(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();
	const auto& params = cmd->GetParameters();
	std::string requested_state;
	if (params.GetString("state", &requested_state)) {
	LOG(INFO) << cmd->GetName() << " state: " << requested_state;

	std::string temp_state = requested_state;
	if (temp_state != "on" && temp_state != "off") {
	// Invalid OnOff state is specified.
	AbortCommand(cmd);
	return;
	}

	bool new_device_status = requested_state == "on";
	if (new_device_status != device_status_) {
	device_status_ = new_device_status;
	LOG(INFO) << "Device is now: " << (device_status_ ? "ON" : "OFF");
	UpdateTestDeviceState();
	}
	cmd->Complete({}, nullptr);
	return;
	}
	AbortCommand(cmd);
	}

	void OnColorTempSetConfig(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();

	const auto& params = cmd->GetParameters();
	int32_t color_temp = 0;
	if (params.GetInteger("colorTemp", &color_temp)) {
	LOG(INFO) << cmd->GetName() << " colorTemp: " << color_temp;

	if (color_temp < 0.0 \|\| color_temp > 1.0) {
	// Invalid color_temp value is specified.
	AbortCommand(cmd);
	return;
	}

	if (color_temp != color_temp_) {
	color_temp_ = color_temp;

	LOG(INFO) << "color_Temp is now: " << color_temp_;
	UpdateTestDeviceState();
	}
	cmd->Complete({}, nullptr);
	return;
	}

	AbortCommand(cmd);
	}

	void OnColorXySetConfig(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();
	const auto& params = cmd->GetParameters();
	const base::DictionaryValue* colorXy = nullptr;
	if (params.GetDictionary("colorSetting", &colorXy)) {
	bool updateState = false;
	double X = 0.0;
	double Y = 0.0;
	if (colorXy->GetDouble("colorX", &X)) {
	color_X_ = X;
	updateState = true;
	}

	if (colorXy->GetDouble("colorY", &Y)) {
	color_Y_ = Y;
	updateState = true;
	}

	if ((color_X_ < 0.0 \|\| color_Y_ > 1.0) \|\|
	(color_Y_ < 0.0 \|\| color_Y_ > 1.0)) {
	// Invalid color range value is specified.
	AbortCommand(cmd);
	return;
	}

	if (updateState)
	UpdateTestDeviceState();

	cmd->Complete({}, nullptr);
	return;
	}

	AbortCommand(cmd);
	}

	void OnAnimate(const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;

	const auto& params = cmd->GetParameters();
	double duration = 0.0;
	std::string type;

	if (params.GetDouble("duration", &duration)) {
	LOG(INFO) << cmd->GetName() << " animate duration : " << duration;

	if (duration <= 0.0 \|\| duration > 100.0) {
	// Invalid animate duration value is specified.
	AbortCommand(cmd);
	return;
	}

	if (params.GetString("type", &type)) {
	LOG(INFO) << " Animation type value is : " << type;
	if (type != "marquee_left" && type != "marquee_right" &&
	type != "blink" && type != "none") {
	// Invalid animation state is specified.
	AbortCommand(cmd);
	return;
	}
	}

	cmd->Complete({}, nullptr);
	return;
	}

	AbortCommand(cmd);
	}

	void LedOnOffSetConfig(size_t led_index,
	const std::weak_ptr<weave::Command>& command) {
	auto cmd = command.lock();
	if (!cmd)
	return;
	LOG(INFO) << "received command: " << cmd->GetName();
	const auto& params = cmd->GetParameters();
	std::string state;
	if (params.GetString("state", &state)) {
	LOG(INFO) << cmd->GetName() << " led: " << led_index
	<< " state: " << state;

	std::string temp_state = state;
	if (temp_state != "on" && temp_state != "off") {
	// Invalid OnOff state is specified.
	AbortCommand(cmd);
	return;
	}

	int current_state = led_states_[led_index];
	int new_state = (state == "on") ? 1 : 0;
	led_states_[led_index] = new_state;
	if (new_state != current_state) {
	device_->SetStateProperty(cmd->GetComponent(), "onOff.state",
	base::StringValue{state}, nullptr);
	}
	cmd->Complete({}, nullptr);
	return;
	}
	AbortCommand(cmd);
	}

	void UpdateTestDeviceState() {
	std::string updated_state = weave::EnumToString(lock_state_);
	device_->SetStateProperty(standard_traits::kComponent, "lock.lockedState",
	base::StringValue{updated_state}, nullptr);
	base::DictionaryValue state;
	state.SetString("onOff.state", device_status_ ? "on" : "off");
	state.SetDouble("brightness.brightness", brightness_state_);
	// state.SetString("onOff.state", speaker_status_ ? "on" : "off");
	state.SetBoolean("volume.isMuted", isMuted_status_);
	state.SetInteger("volume.volume", volume_value_);
	state.SetInteger("colorTemp.minColorTemp", color_temp_min_value_);
	state.SetInteger("colorTemp.maxColorTemp", color_temp_max_value_);
	state.SetInteger("colorTemp.colorTemp", color_temp_);

	std::unique_ptr<base::DictionaryValue> colorXy(new base::DictionaryValue());
	colorXy->SetDouble("colorX", color_X_);
	colorXy->SetDouble("colorY", color_Y_);
	state.Set("colorXy.colorSetting", std::move(colorXy));

	device_->SetStateProperties(standard_traits::kComponent, state, nullptr);
	}

	void AbortCommand(std::shared_ptr<weave::Command>& cmd) {
	weave::ErrorPtr error;
	weave::Error::AddTo(&error, FROM_HERE, "invalidParameterValue",
	"Invalid parameters");
	cmd->Abort(error.get(), nullptr);
	}

	weave::Device* device_{nullptr};

	// Simulate the state of the testdevice.
	weave::lockstate::LockState lock_state_{weave::lockstate::LockState::kLocked};
	bool device_status_{false};
	double brightness_state_{0.0};
	bool isMuted_status_{false};
	int32_t volume_value_{0};
	int32_t color_temp_{0};
	int32_t color_temp_min_value_{0};
	int32_t color_temp_max_value_{1};
	double color_X_{0.0};
	double color_Y_{0.0};
	double duration{0.1};
	std::bitset<custom_traits::kLedCount> led_states_{0};
	base::WeakPtrFactory<TestDeviceHandler> weak_ptr_factory_{this};
	};

	int main(int argc, char** argv) {
	Daemon::Options opts;
	opts.model_id = "AOAAA";
	if (!opts.Parse(argc, argv)) {
	Daemon::Options::ShowUsage(argv[0]);
	return 1;
	}
	Daemon daemon{opts};
	TestDeviceHandler handler;
	handler.Register(daemon.GetDevice());
	daemon.Run();
	return 0;
	}