blob: 170688b1d6ddfe3bbbc268e8ff9e3d54ccd5e6e1 [file] [log] [blame]
Vitaly Buka4615e0d2015-10-14 15:35:12 -07001// Copyright 2015 The Weave Authors. All rights reserved.
Vitaly Buka7ce499f2015-06-09 08:04:11 -07002// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Stefan Sauer2d16dfa2015-09-25 17:08:35 +02005#include "src/privet/cloud_delegate.h"
Vitaly Buka7ce499f2015-06-09 08:04:11 -07006
7#include <map>
8#include <vector>
9
10#include <base/bind.h>
Vitaly Buka7ce499f2015-06-09 08:04:11 -070011#include <base/logging.h>
12#include <base/memory/weak_ptr.h>
Vitaly Buka7ce499f2015-06-09 08:04:11 -070013#include <base/values.h>
Vitaly Buka0801a1f2015-08-14 10:03:46 -070014#include <weave/error.h>
Vitaly Buka1e363672015-09-25 14:01:16 -070015#include <weave/provider/task_runner.h>
Vitaly Buka7ce499f2015-06-09 08:04:11 -070016
Stefan Sauer2d16dfa2015-09-25 17:08:35 +020017#include "src/backoff_entry.h"
Alex Vakulenkod91d6252015-12-05 17:14:39 -080018#include "src/component_manager.h"
Stefan Sauer2d16dfa2015-09-25 17:08:35 +020019#include "src/config.h"
20#include "src/device_registration_info.h"
21#include "src/privet/constants.h"
Vitaly Buka7ce499f2015-06-09 08:04:11 -070022
Vitaly Bukab6f015a2015-07-09 14:59:23 -070023namespace weave {
24namespace privet {
25
26namespace {
27
Vitaly Buka4ebd3292015-09-23 18:04:17 -070028const BackoffEntry::Policy register_backoff_policy = {0, 1000, 2.0, 0.2,
29 5000, -1, false};
Alex Vakulenko464f93e2015-09-11 15:32:39 -070030
31const int kMaxDeviceRegistrationTimeMinutes = 5;
Vitaly Buka7ce499f2015-06-09 08:04:11 -070032
Vitaly Bukaef213d72015-10-07 15:54:58 -070033CommandInstance* ReturnNotFound(const std::string& command_id,
34 ErrorPtr* error) {
Vitaly Buka0801a1f2015-08-14 10:03:46 -070035 Error::AddToPrintf(error, FROM_HERE, errors::kDomain, errors::kNotFound,
36 "Command not found, ID='%s'", command_id.c_str());
Vitaly Buka7ab89ff2015-06-09 22:11:40 -070037 return nullptr;
38}
39
Vitaly Buka7ce499f2015-06-09 08:04:11 -070040class CloudDelegateImpl : public CloudDelegate {
41 public:
Vitaly Buka1e363672015-09-25 14:01:16 -070042 CloudDelegateImpl(provider::TaskRunner* task_runner,
Vitaly Bukaf9630fb2015-08-12 21:15:40 -070043 DeviceRegistrationInfo* device,
Alex Vakulenkod91d6252015-12-05 17:14:39 -080044 ComponentManager* component_manager)
Vitaly Bukaf9630fb2015-08-12 21:15:40 -070045 : task_runner_{task_runner},
46 device_{device},
Alex Vakulenkod91d6252015-12-05 17:14:39 -080047 component_manager_{component_manager} {
Vitaly Bukaae6b35d2015-09-29 23:16:54 -070048 device_->GetMutableConfig()->AddOnChangedCallback(base::Bind(
Vitaly Buka7ab89ff2015-06-09 22:11:40 -070049 &CloudDelegateImpl::OnConfigChanged, weak_factory_.GetWeakPtr()));
Vitaly Bukac3c6dab2015-10-01 19:41:02 -070050 device_->AddGcdStateChangedCallback(base::Bind(
Vitaly Buka7ab89ff2015-06-09 22:11:40 -070051 &CloudDelegateImpl::OnRegistrationChanged, weak_factory_.GetWeakPtr()));
52
Alex Vakulenkod91d6252015-12-05 17:14:39 -080053 component_manager_->AddTraitDefChangedCallback(base::Bind(
54 &CloudDelegateImpl::NotifyOnTraitDefsChanged,
55 weak_factory_.GetWeakPtr()));
56 component_manager_->AddCommandAddedCallback(base::Bind(
Vitaly Buka7ab89ff2015-06-09 22:11:40 -070057 &CloudDelegateImpl::OnCommandAdded, weak_factory_.GetWeakPtr()));
Alex Vakulenkod91d6252015-12-05 17:14:39 -080058 component_manager_->AddCommandRemovedCallback(base::Bind(
Vitaly Buka7ce499f2015-06-09 08:04:11 -070059 &CloudDelegateImpl::OnCommandRemoved, weak_factory_.GetWeakPtr()));
Alex Vakulenkod91d6252015-12-05 17:14:39 -080060 component_manager_->AddStateChangedCallback(base::Bind(
Alex Vakulenko551a82b2015-12-07 14:46:12 -080061 &CloudDelegateImpl::NotifyOnStateChanged,
Alex Vakulenkod91d6252015-12-05 17:14:39 -080062 weak_factory_.GetWeakPtr()));
63 component_manager_->AddComponentTreeChangedCallback(base::Bind(
64 &CloudDelegateImpl::NotifyOnComponentTreeChanged,
65 weak_factory_.GetWeakPtr()));
Vitaly Buka7ce499f2015-06-09 08:04:11 -070066 }
67
68 ~CloudDelegateImpl() override = default;
69
Johan Euphrosine0b7bb9f2015-09-29 01:11:21 -070070 std::string GetDeviceId() const override {
71 return device_->GetSettings().device_id;
72 }
73
Vitaly Buka658aa362015-09-15 20:59:12 -070074 std::string GetModelId() const override {
Vitaly Buka5cf12a32015-09-15 21:25:48 -070075 CHECK_EQ(5u, device_->GetSettings().model_id.size());
76 return device_->GetSettings().model_id;
Vitaly Buka7ce499f2015-06-09 08:04:11 -070077 }
78
Vitaly Buka5cf12a32015-09-15 21:25:48 -070079 std::string GetName() const override { return device_->GetSettings().name; }
Vitaly Buka7ce499f2015-06-09 08:04:11 -070080
81 std::string GetDescription() const override {
Vitaly Buka5cf12a32015-09-15 21:25:48 -070082 return device_->GetSettings().description;
Vitaly Buka7ce499f2015-06-09 08:04:11 -070083 }
84
85 std::string GetLocation() const override {
Vitaly Buka5cf12a32015-09-15 21:25:48 -070086 return device_->GetSettings().location;
Vitaly Buka7ce499f2015-06-09 08:04:11 -070087 }
88
89 void UpdateDeviceInfo(const std::string& name,
90 const std::string& description,
Vitaly Bukab624bc42015-09-29 19:13:55 -070091 const std::string& location) override {
92 device_->UpdateDeviceInfo(name, description, location);
Vitaly Buka7ce499f2015-06-09 08:04:11 -070093 }
94
95 std::string GetOemName() const override {
Vitaly Buka5cf12a32015-09-15 21:25:48 -070096 return device_->GetSettings().oem_name;
Vitaly Buka7ce499f2015-06-09 08:04:11 -070097 }
98
99 std::string GetModelName() const override {
Vitaly Buka5cf12a32015-09-15 21:25:48 -0700100 return device_->GetSettings().model_name;
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700101 }
102
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700103 AuthScope GetAnonymousMaxScope() const override {
Vitaly Bukab624bc42015-09-29 19:13:55 -0700104 return device_->GetSettings().local_anonymous_access_role;
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700105 }
106
107 const ConnectionState& GetConnectionState() const override {
108 return connection_state_;
109 }
110
111 const SetupState& GetSetupState() const override { return setup_state_; }
112
113 bool Setup(const std::string& ticket_id,
114 const std::string& user,
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700115 ErrorPtr* error) override {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700116 if (setup_state_.IsStatusEqual(SetupState::kInProgress)) {
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700117 Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kDeviceBusy,
118 "Setup in progress");
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700119 return false;
120 }
121 VLOG(1) << "GCD Setup started. ticket_id: " << ticket_id
122 << ", user:" << user;
123 setup_state_ = SetupState(SetupState::kInProgress);
124 setup_weak_factory_.InvalidateWeakPtrs();
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700125 backoff_entry_.Reset();
126 base::Time deadline = base::Time::Now();
127 deadline += base::TimeDelta::FromMinutes(kMaxDeviceRegistrationTimeMinutes);
Vitaly Bukaf9630fb2015-08-12 21:15:40 -0700128 task_runner_->PostDelayedTask(
Vitaly Buka4ebd3292015-09-23 18:04:17 -0700129 FROM_HERE,
130 base::Bind(&CloudDelegateImpl::CallManagerRegisterDevice,
131 setup_weak_factory_.GetWeakPtr(), ticket_id, deadline),
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700132 {});
133 // Return true because we initiated setup.
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700134 return true;
135 }
136
137 std::string GetCloudId() const override {
Vitaly Buka1c522d82015-11-23 13:01:06 -0800138 return connection_state_.status() > ConnectionState::kUnconfigured
139 ? device_->GetSettings().cloud_id
140 : "";
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700141 }
142
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800143 const base::DictionaryValue& GetLegacyCommandDef() const override {
144 return component_manager_->GetLegacyCommandDefinitions();
145 }
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700146
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800147 const base::DictionaryValue& GetLegacyState() const override {
148 return component_manager_->GetLegacyState();
149 }
150
151 const base::DictionaryValue& GetComponents() const override {
152 return component_manager_->GetComponents();
153 }
154
155 const base::DictionaryValue& GetTraits() const override {
156 return component_manager_->GetTraits();
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700157 }
158
159 void AddCommand(const base::DictionaryValue& command,
160 const UserInfo& user_info,
Vitaly Buka74763422015-10-11 00:39:52 -0700161 const CommandDoneCallback& callback) override {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700162 CHECK(user_info.scope() != AuthScope::kNone);
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700163 CHECK_NE(user_info.user_id(), 0u);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700164
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700165 ErrorPtr error;
Vitaly Bukab6f015a2015-07-09 14:59:23 -0700166 UserRole role;
Vitaly Buka7197c1a2015-07-17 14:48:30 -0700167 std::string str_scope = EnumToString(user_info.scope());
168 if (!StringToEnum(str_scope, &role)) {
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700169 Error::AddToPrintf(&error, FROM_HERE, errors::kDomain,
170 errors::kInvalidParams, "Invalid role: '%s'",
171 str_scope.c_str());
Vitaly Buka74763422015-10-11 00:39:52 -0700172 return callback.Run({}, std::move(error));
Vitaly Buka7197c1a2015-07-17 14:48:30 -0700173 }
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700174
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700175 std::string id;
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800176 auto command_instance = component_manager_->ParseCommandInstance(
177 command, Command::Origin::kLocal, role, &id, &error);
178 if (!command_instance)
Vitaly Buka74763422015-10-11 00:39:52 -0700179 return callback.Run({}, std::move(error));
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800180 component_manager_->AddCommand(std::move(command_instance));
Vitaly Buka8b32d592015-06-24 16:41:25 -0700181 command_owners_[id] = user_info.user_id();
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800182 callback.Run(*component_manager_->FindCommand(id)->ToJson(), nullptr);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700183 }
184
185 void GetCommand(const std::string& id,
186 const UserInfo& user_info,
Vitaly Buka74763422015-10-11 00:39:52 -0700187 const CommandDoneCallback& callback) override {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700188 CHECK(user_info.scope() != AuthScope::kNone);
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700189 ErrorPtr error;
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700190 auto command = GetCommandInternal(id, user_info, &error);
191 if (!command)
Vitaly Buka74763422015-10-11 00:39:52 -0700192 return callback.Run({}, std::move(error));
193 callback.Run(*command->ToJson(), nullptr);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700194 }
195
196 void CancelCommand(const std::string& id,
197 const UserInfo& user_info,
Vitaly Buka74763422015-10-11 00:39:52 -0700198 const CommandDoneCallback& callback) override {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700199 CHECK(user_info.scope() != AuthScope::kNone);
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700200 ErrorPtr error;
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700201 auto command = GetCommandInternal(id, user_info, &error);
Vitaly Buka47a1f6f2015-10-07 18:09:57 -0700202 if (!command || !command->Cancel(&error))
Vitaly Buka74763422015-10-11 00:39:52 -0700203 return callback.Run({}, std::move(error));
204 callback.Run(*command->ToJson(), nullptr);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700205 }
206
207 void ListCommands(const UserInfo& user_info,
Vitaly Buka74763422015-10-11 00:39:52 -0700208 const CommandDoneCallback& callback) override {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700209 CHECK(user_info.scope() != AuthScope::kNone);
210
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700211 base::ListValue list_value;
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700212
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700213 for (const auto& it : command_owners_) {
214 if (CanAccessCommand(it.second, user_info, nullptr)) {
215 list_value.Append(
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800216 component_manager_->FindCommand(it.first)->ToJson().release());
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700217 }
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700218 }
219
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700220 base::DictionaryValue commands_json;
221 commands_json.Set("commands", list_value.DeepCopy());
222
Vitaly Buka74763422015-10-11 00:39:52 -0700223 callback.Run(commands_json, nullptr);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700224 }
225
226 private:
Vitaly Buka12affd82015-07-23 18:45:35 -0700227 void OnCommandAdded(Command* command) {
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700228 // Set to 0 for any new unknown command.
Vitaly Buka52d006a2015-11-21 17:14:51 -0800229 command_owners_.insert(std::make_pair(command->GetID(), 0));
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700230 }
231
Vitaly Buka12affd82015-07-23 18:45:35 -0700232 void OnCommandRemoved(Command* command) {
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700233 CHECK(command_owners_.erase(command->GetID()));
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700234 }
235
Vitaly Bukabc3e8bd2015-07-20 00:37:48 -0700236 void OnConfigChanged(const Settings&) { NotifyOnDeviceInfoChanged(); }
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700237
Vitaly Bukac3c6dab2015-10-01 19:41:02 -0700238 void OnRegistrationChanged(GcdState status) {
Vitaly Buka672634b2015-11-20 09:49:30 -0800239 if (status == GcdState::kUnconfigured ||
240 status == GcdState::kInvalidCredentials) {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700241 connection_state_ = ConnectionState{ConnectionState::kUnconfigured};
Vitaly Bukac3c6dab2015-10-01 19:41:02 -0700242 } else if (status == GcdState::kConnecting) {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700243 // TODO(vitalybuka): Find conditions for kOffline.
244 connection_state_ = ConnectionState{ConnectionState::kConnecting};
Vitaly Bukac3c6dab2015-10-01 19:41:02 -0700245 } else if (status == GcdState::kConnected) {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700246 connection_state_ = ConnectionState{ConnectionState::kOnline};
247 } else {
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700248 ErrorPtr error;
249 Error::AddToPrintf(
Vitaly Bukab6f015a2015-07-09 14:59:23 -0700250 &error, FROM_HERE, errors::kDomain, errors::kInvalidState,
Vitaly Buka8e2f4162015-08-02 21:14:50 -0700251 "Unexpected registration status: %s", EnumToString(status).c_str());
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700252 connection_state_ = ConnectionState{std::move(error)};
253 }
254 NotifyOnDeviceInfoChanged();
255 }
256
Johan Euphrosine312c2f52015-09-29 00:04:29 -0700257 void OnRegisterSuccess(const std::string& cloud_id) {
258 VLOG(1) << "Device registered: " << cloud_id;
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700259 setup_state_ = SetupState(SetupState::kSuccess);
260 }
261
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700262 void CallManagerRegisterDevice(const std::string& ticket_id,
263 const base::Time& deadline) {
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700264 ErrorPtr error;
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700265 if (base::Time::Now() > deadline) {
Vitaly Buka4ebd3292015-09-23 18:04:17 -0700266 Error::AddTo(&error, FROM_HERE, errors::kDomain, errors::kInvalidState,
267 "Failed to register device");
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700268 setup_state_ = SetupState{std::move(error)};
269 return;
270 }
271
Vitaly Buka12870bd2015-10-08 23:49:39 -0700272 device_->RegisterDevice(
Vitaly Buka74763422015-10-11 00:39:52 -0700273 ticket_id,
274 base::Bind(&CloudDelegateImpl::RegisterDeviceDone,
Vitaly Buka12870bd2015-10-08 23:49:39 -0700275 setup_weak_factory_.GetWeakPtr(), ticket_id, deadline));
276 }
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700277
Vitaly Buka74763422015-10-11 00:39:52 -0700278 void RegisterDeviceDone(const std::string& ticket_id,
279 const base::Time& deadline,
280 ErrorPtr error) {
281 if (error) {
282 // Registration failed. Retry with backoff.
283 backoff_entry_.InformOfRequest(false);
284 return task_runner_->PostDelayedTask(
285 FROM_HERE,
286 base::Bind(&CloudDelegateImpl::CallManagerRegisterDevice,
287 setup_weak_factory_.GetWeakPtr(), ticket_id, deadline),
288 backoff_entry_.GetTimeUntilRelease());
289 }
Vitaly Buka12870bd2015-10-08 23:49:39 -0700290 backoff_entry_.InformOfRequest(true);
291 setup_state_ = SetupState(SetupState::kSuccess);
292 }
293
Vitaly Bukaef213d72015-10-07 15:54:58 -0700294 CommandInstance* GetCommandInternal(const std::string& command_id,
295 const UserInfo& user_info,
296 ErrorPtr* error) const {
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700297 if (user_info.scope() != AuthScope::kOwner) {
298 auto it = command_owners_.find(command_id);
299 if (it == command_owners_.end())
300 return ReturnNotFound(command_id, error);
301 if (CanAccessCommand(it->second, user_info, error))
302 return nullptr;
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700303 }
304
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800305 auto command = component_manager_->FindCommand(command_id);
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700306 if (!command)
307 return ReturnNotFound(command_id, error);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700308
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700309 return command;
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700310 }
311
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700312 bool CanAccessCommand(uint64_t owner_id,
313 const UserInfo& user_info,
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700314 ErrorPtr* error) const {
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700315 CHECK(user_info.scope() != AuthScope::kNone);
316 CHECK_NE(user_info.user_id(), 0u);
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700317
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700318 if (user_info.scope() == AuthScope::kOwner ||
319 owner_id == user_info.user_id()) {
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700320 return true;
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700321 }
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700322
Vitaly Buka0801a1f2015-08-14 10:03:46 -0700323 Error::AddTo(error, FROM_HERE, errors::kDomain, errors::kAccessDenied,
324 "Need to be owner of the command.");
Vitaly Buka7ab89ff2015-06-09 22:11:40 -0700325 return false;
326 }
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700327
Vitaly Buka1e363672015-09-25 14:01:16 -0700328 provider::TaskRunner* task_runner_{nullptr};
Vitaly Bukab6f015a2015-07-09 14:59:23 -0700329 DeviceRegistrationInfo* device_{nullptr};
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800330 ComponentManager* component_manager_{nullptr};
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700331
332 // Primary state of GCD.
333 ConnectionState connection_state_{ConnectionState::kDisabled};
334
335 // State of the current or last setup.
336 SetupState setup_state_{SetupState::kNone};
337
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700338 // Map of command IDs to user IDs.
339 std::map<std::string, uint64_t> command_owners_;
340
Alex Vakulenko464f93e2015-09-11 15:32:39 -0700341 // Backoff entry for retrying device registration.
342 BackoffEntry backoff_entry_{&register_backoff_policy};
343
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700344 // |setup_weak_factory_| tracks the lifetime of callbacks used in connection
345 // with a particular invocation of Setup().
346 base::WeakPtrFactory<CloudDelegateImpl> setup_weak_factory_{this};
347 // |weak_factory_| tracks the lifetime of |this|.
348 base::WeakPtrFactory<CloudDelegateImpl> weak_factory_{this};
349};
350
351} // namespace
352
Vitaly Buka4ebd3292015-09-23 18:04:17 -0700353CloudDelegate::CloudDelegate() {}
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700354
Vitaly Buka4ebd3292015-09-23 18:04:17 -0700355CloudDelegate::~CloudDelegate() {}
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700356
357// static
358std::unique_ptr<CloudDelegate> CloudDelegate::CreateDefault(
Vitaly Buka1e363672015-09-25 14:01:16 -0700359 provider::TaskRunner* task_runner,
Vitaly Bukab6f015a2015-07-09 14:59:23 -0700360 DeviceRegistrationInfo* device,
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800361 ComponentManager* component_manager) {
Vitaly Bukaf9630fb2015-08-12 21:15:40 -0700362 return std::unique_ptr<CloudDelegateImpl>{new CloudDelegateImpl{
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800363 task_runner, device, component_manager}};
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700364}
365
366void CloudDelegate::NotifyOnDeviceInfoChanged() {
367 FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceInfoChanged());
368}
369
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800370void CloudDelegate::NotifyOnTraitDefsChanged() {
371 FOR_EACH_OBSERVER(Observer, observer_list_, OnTraitDefsChanged());
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700372}
373
Alex Vakulenkod91d6252015-12-05 17:14:39 -0800374void CloudDelegate::NotifyOnComponentTreeChanged() {
375 FOR_EACH_OBSERVER(Observer, observer_list_, OnComponentTreeChanged());
Vitaly Buka7ce499f2015-06-09 08:04:11 -0700376}
377
Alex Vakulenko551a82b2015-12-07 14:46:12 -0800378void CloudDelegate::NotifyOnStateChanged() {
379 FOR_EACH_OBSERVER(Observer, observer_list_, OnStateChanged());
380}
381
Vitaly Bukab6f015a2015-07-09 14:59:23 -0700382} // namespace privet
383} // namespace weave