blob: ee6358f8e1cfbb9731c23749496bff7e4037c84d [file] [log] [blame]
// Copyright 2015 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 <deque>
#include <memory>
#include <string>
#include <utility>
#include <base/macros.h>
#include <base/memory/weak_ptr.h>
#include <base/scoped_observer.h>
#include <weave/command.h>
#include "src/backoff_entry.h"
#include "src/commands/cloud_command_update_interface.h"
#include "src/commands/command_instance.h"
#include "src/states/state_change_queue_interface.h"
namespace weave {
class CommandInstance;
namespace provider {
class TaskRunner;
// Command proxy which publishes command updates to the cloud.
class CloudCommandProxy final : public CommandInstance::Observer {
CloudCommandProxy(CommandInstance* command_instance,
CloudCommandUpdateInterface* cloud_command_updater,
StateChangeQueueInterface* state_change_queue,
std::unique_ptr<BackoffEntry> backoff_entry,
provider::TaskRunner* task_runner);
~CloudCommandProxy() override = default;
// CommandProxyInterface implementation/overloads.
void OnCommandDestroyed() override;
void OnErrorChanged() override;
void OnProgressChanged() override;
void OnResultsChanged() override;
void OnStateChanged() override;
using UpdateID = StateChangeQueueInterface::UpdateID;
using UpdateQueueEntry =
std::pair<UpdateID, std::unique_ptr<base::DictionaryValue>>;
// Puts a command update data into the update queue, and optionally sends an
// asynchronous request to GCD server to update the command resource, if there
// are no pending device status updates.
void QueueCommandUpdate(std::unique_ptr<base::DictionaryValue> patch);
// Sends an asynchronous request to GCD server to update the command resource,
// if there are no pending device status updates.
void SendCommandUpdate();
// Retry the last failed command update request to the server.
void ResendCommandUpdate();
// Callback invoked by the asynchronous PATCH request to the server.
void OnUpdateCommandDone(ErrorPtr error);
// Callback invoked by the device state change queue to notify of the
// successful device state update. |update_id| is the ID of the state that
// has been updated on the server.
void OnDeviceStateUpdated(UpdateID update_id);
CommandInstance* command_instance_;
CloudCommandUpdateInterface* cloud_command_updater_;
StateChangeQueueInterface* state_change_queue_;
provider::TaskRunner* task_runner_{nullptr};
// Backoff for SendCommandUpdate() method.
std::unique_ptr<BackoffEntry> cloud_backoff_entry_;
// Set to true while a pending PATCH request is in flight to the server.
bool command_update_in_progress_{false};
// Update queue with all the command update requests ready to be sent to
// the server.
std::deque<UpdateQueueEntry> update_queue_;
// Callback token from the state change queue for OnDeviceStateUpdated()
// callback for ask the device state change queue to call when the state
// is updated on the server.
StateChangeQueueInterface::Token callback_token_;
// Last device state update ID that has been sent out to the server
// successfully.
UpdateID last_state_update_id_{0};
ScopedObserver<CommandInstance, CommandInstance::Observer> observer_{this};
base::WeakPtrFactory<CloudCommandProxy> backoff_weak_ptr_factory_{this};
base::WeakPtrFactory<CloudCommandProxy> weak_ptr_factory_{this};
} // namespace weave