From 5a1f600e9d7d26c36b3e22ff0dc0ae9e3b2425fc Mon Sep 17 00:00:00 2001 From: Paul Westbrook Date: Sun, 1 Nov 2015 15:29:33 -0800 Subject: Remove the unneeded libweave directory Change-Id: I30fd8c5626cf83da6415ffa14a2019ef43be9916 Reviewed-on: https://weave-review.googlesource.com/1450 Reviewed-by: Paul Westbrook --- src/device_registration_info.h | 352 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 352 insertions(+) create mode 100644 src/device_registration_info.h (limited to 'src/device_registration_info.h') diff --git a/src/device_registration_info.h b/src/device_registration_info.h new file mode 100644 index 0000000..f3bacc6 --- /dev/null +++ b/src/device_registration_info.h @@ -0,0 +1,352 @@ +// 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. + +#ifndef LIBWEAVE_SRC_DEVICE_REGISTRATION_INFO_H_ +#define LIBWEAVE_SRC_DEVICE_REGISTRATION_INFO_H_ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "src/backoff_entry.h" +#include "src/commands/cloud_command_update_interface.h" +#include "src/commands/command_manager.h" +#include "src/config.h" +#include "src/data_encoding.h" +#include "src/notification/notification_channel.h" +#include "src/notification/notification_delegate.h" +#include "src/notification/pull_channel.h" +#include "src/states/state_change_queue_interface.h" + +namespace base { +class DictionaryValue; +} // namespace base + +namespace weave { + +class StateManager; + +namespace provider { +class Network; +class TaskRunner; +} + +extern const char kErrorDomainOAuth2[]; +extern const char kErrorDomainGCD[]; +extern const char kErrorDomainGCDServer[]; + +// The DeviceRegistrationInfo class represents device registration information. +class DeviceRegistrationInfo : public NotificationDelegate, + public CloudCommandUpdateInterface { + public: + using CloudRequestDoneCallback = + base::Callback; + + DeviceRegistrationInfo(const std::shared_ptr& command_manager, + const std::shared_ptr& state_manager, + std::unique_ptr config, + provider::TaskRunner* task_runner, + provider::HttpClient* http_client, + provider::Network* network); + + ~DeviceRegistrationInfo() override; + + void AddGcdStateChangedCallback( + const Device::GcdStateChangedCallback& callback); + void RegisterDevice(const std::string& ticket_id, + const DoneCallback& callback); + + void UpdateDeviceInfo(const std::string& name, + const std::string& description, + const std::string& location); + void UpdateBaseConfig(AuthScope anonymous_access_role, + bool local_discovery_enabled, + bool local_pairing_enabled); + bool UpdateServiceConfig(const std::string& client_id, + const std::string& client_secret, + const std::string& api_key, + const std::string& oauth_url, + const std::string& service_url, + ErrorPtr* error); + + void GetDeviceInfo(const CloudRequestDoneCallback& callback); + + // Returns the GCD service request URL. If |subpath| is specified, it is + // appended to the base URL which is normally + // https://www.googleapis.com/clouddevices/v1/". + // If |params| are specified, each key-value pair is formatted using + // WebParamsEncode() and appended to URL as a query + // string. + // So, calling: + // GetServiceURL("ticket", {{"key","apiKey"}}) + // will return something like: + // https://www.googleapis.com/clouddevices/v1/ticket?key=apiKey + std::string GetServiceURL(const std::string& subpath = {}, + const WebParamList& params = {}) const; + + // Returns a service URL to access the registered device on GCD server. + // The base URL used to construct the full URL looks like this: + // https://www.googleapis.com/clouddevices/v1/devices// + std::string GetDeviceURL(const std::string& subpath = {}, + const WebParamList& params = {}) const; + + // Similar to GetServiceURL, GetOAuthURL() returns a URL of OAuth 2.0 server. + // The base URL used is https://accounts.google.com/o/oauth2/. + std::string GetOAuthURL(const std::string& subpath = {}, + const WebParamList& params = {}) const; + + // Starts GCD device if credentials available. + void Start(); + + // Checks whether we have credentials generated during registration. + bool HaveRegistrationCredentials() const; + // Calls HaveRegistrationCredentials() and logs an error if no credentials + // are available. + bool VerifyRegistrationCredentials(ErrorPtr* error) const; + + // Updates a command (override from CloudCommandUpdateInterface). + void UpdateCommand(const std::string& command_id, + const base::DictionaryValue& command_patch, + const DoneCallback& callback) override; + + // TODO(vitalybuka): remove getters and pass config to dependent code. + const Config::Settings& GetSettings() const { return config_->GetSettings(); } + Config* GetMutableConfig() { return config_.get(); } + + GcdState GetGcdState() const { return gcd_state_; } + + private: + friend class DeviceRegistrationInfoTest; + + base::WeakPtr AsWeakPtr() { + return weak_factory_.GetWeakPtr(); + } + + // Cause DeviceRegistrationInfo to attempt to connect to cloud server on + // its own later. + void ScheduleCloudConnection(const base::TimeDelta& delay); + + // Initiates the connection to the cloud server. + // Device will do required start up chores and then start to listen + // to new commands. + void ConnectToCloud(ErrorPtr error); + // Notification called when ConnectToCloud() succeeds. + void OnConnectedToCloud(ErrorPtr error); + + // Forcibly refreshes the access token. + void RefreshAccessToken(const DoneCallback& callback); + + // Callbacks for RefreshAccessToken(). + void OnRefreshAccessTokenDone( + const DoneCallback& callback, + std::unique_ptr response, + ErrorPtr error); + + // Parse the OAuth response, and sets registration status to + // kInvalidCredentials if our registration is no longer valid. + std::unique_ptr ParseOAuthResponse( + const provider::HttpClient::Response& response, + ErrorPtr* error); + + // This attempts to open a notification channel. The channel needs to be + // restarted anytime the access_token is refreshed. + void StartNotificationChannel(); + + // Do a HTTPS request to cloud services. + // Handles many cases like reauthorization, 5xx HTTP response codes + // and device removal. It is a recommended way to do cloud API + // requests. + // TODO(antonm): Consider moving into some other class. + void DoCloudRequest(provider::HttpClient::Method method, + const std::string& url, + const base::DictionaryValue* body, + const CloudRequestDoneCallback& callback); + + // Helper for DoCloudRequest(). + struct CloudRequestData { + provider::HttpClient::Method method; + std::string url; + std::string body; + CloudRequestDoneCallback callback; + }; + void SendCloudRequest(const std::shared_ptr& data); + void OnCloudRequestDone( + const std::shared_ptr& data, + std::unique_ptr response, + ErrorPtr error); + void RetryCloudRequest(const std::shared_ptr& data); + void OnAccessTokenRefreshed( + const std::shared_ptr& data, + ErrorPtr error); + void CheckAccessTokenError(ErrorPtr error); + + void UpdateDeviceResource(const DoneCallback& callback); + void StartQueuedUpdateDeviceResource(); + void OnUpdateDeviceResourceDone(const base::DictionaryValue& device_info, + ErrorPtr error); + void OnUpdateDeviceResourceError(ErrorPtr error); + + // Callback from GetDeviceInfo() to retrieve the device resource timestamp + // and retry UpdateDeviceResource() call. + void OnDeviceInfoRetrieved(const base::DictionaryValue& device_info, + ErrorPtr error); + + // Extracts the timestamp from the device resource and sets it to + // |last_device_resource_updated_timestamp_|. + // Returns false if the "lastUpdateTimeMs" field is not found in the device + // resource or it is invalid. + bool UpdateDeviceInfoTimestamp(const base::DictionaryValue& device_info); + + void FetchCommands( + const base::Callback& callback, + const std::string& reason); + void OnFetchCommandsDone( + const base::Callback& callback, + const base::DictionaryValue& json, + ErrorPtr); + // Called when FetchCommands completes (with either success or error). + // This method reschedules any pending/queued fetch requests. + void OnFetchCommandsReturned(); + + // Processes the command list that is fetched from the server on connection. + // Aborts commands which are in transitional states and publishes queued + // commands which are queued. + void ProcessInitialCommandList(const base::ListValue& commands, + ErrorPtr error); + + void PublishCommands(const base::ListValue& commands, ErrorPtr error); + void PublishCommand(const base::DictionaryValue& command); + + // Helper function to pull the pending command list from the server using + // FetchCommands() and make them available on D-Bus with PublishCommands(). + // |backup_fetch| is set to true when performing backup ("just-in-case") + // command fetch while XMPP channel is up and running. + void FetchAndPublishCommands(const std::string& reason); + + void PublishStateUpdates(); + void OnPublishStateDone(StateChangeQueueInterface::UpdateID update_id, + const base::DictionaryValue& reply, + ErrorPtr error); + void OnPublishStateError(ErrorPtr error); + + // If unrecoverable error occurred (e.g. error parsing command instance), + // notify the server that the command is aborted by the device. + void NotifyCommandAborted(const std::string& command_id, ErrorPtr error); + + // Builds Cloud API devices collection REST resource which matches + // current state of the device including command definitions + // for all supported commands and current device state. + std::unique_ptr BuildDeviceResource(ErrorPtr* error); + + void SetGcdState(GcdState new_state); + void SetDeviceId(const std::string& cloud_id); + + // Callback called when command definitions are changed to re-publish new CDD. + void OnCommandDefsChanged(); + void OnStateChanged(); + + // Overrides from NotificationDelegate. + void OnConnected(const std::string& channel_name) override; + void OnDisconnected() override; + void OnPermanentFailure() override; + void OnCommandCreated(const base::DictionaryValue& command, + const std::string& channel_name) override; + void OnDeviceDeleted(const std::string& cloud_id) override; + + // Wipes out the device registration information and stops server connections. + void MarkDeviceUnregistered(); + + void RegisterDeviceError(const DoneCallback& callback, ErrorPtr error); + void RegisterDeviceOnTicketSent( + const std::string& ticket_id, + const DoneCallback& callback, + std::unique_ptr response, + ErrorPtr error); + void RegisterDeviceOnTicketFinalized( + const DoneCallback& callback, + std::unique_ptr response, + ErrorPtr error); + void RegisterDeviceOnAuthCodeSent( + const std::string& cloud_id, + const std::string& robot_account, + const DoneCallback& callback, + std::unique_ptr response, + ErrorPtr error); + + // Transient data + std::string access_token_; + base::Time access_token_expiration_; + // The time stamp of last device resource update on the server. + std::string last_device_resource_updated_timestamp_; + // Set to true if the device has connected to the cloud server correctly. + // At this point, normal state and command updates can be dispatched to the + // server. + bool connected_to_cloud_{false}; + + // HTTP transport used for communications. + provider::HttpClient* http_client_{nullptr}; + + provider::TaskRunner* task_runner_{nullptr}; + // Global command manager. + std::shared_ptr command_manager_; + // Device state manager. + std::shared_ptr state_manager_; + + std::unique_ptr config_; + + // Backoff manager for DoCloudRequest() method. + std::unique_ptr cloud_backoff_policy_; + std::unique_ptr cloud_backoff_entry_; + std::unique_ptr oauth2_backoff_entry_; + + // Flag set to true while a device state update patch request is in flight + // to the cloud server. + bool device_state_update_pending_{false}; + + // Set to true when command queue fetch request is in flight to the server. + bool fetch_commands_request_sent_{false}; + // Set to true when another command queue fetch request is queued while + // another one was in flight. + bool fetch_commands_request_queued_{false}; + // Specifies the reason for queued command fetch request. + std::string queued_fetch_reason_; + + using ResourceUpdateCallbackList = std::vector; + // Callbacks for device resource update request currently in flight to the + // cloud server. + ResourceUpdateCallbackList in_progress_resource_update_callbacks_; + // Callbacks for device resource update requests queued while another request + // is in flight to the cloud server. + ResourceUpdateCallbackList queued_resource_update_callbacks_; + + std::unique_ptr primary_notification_channel_; + std::unique_ptr pull_channel_; + NotificationChannel* current_notification_channel_{nullptr}; + bool notification_channel_starting_{false}; + + provider::Network* network_{nullptr}; + + // Tracks our GCD state. + GcdState gcd_state_{GcdState::kUnconfigured}; + + std::vector gcd_state_changed_callbacks_; + + base::WeakPtrFactory weak_factory_{this}; + DISALLOW_COPY_AND_ASSIGN(DeviceRegistrationInfo); +}; + +} // namespace weave + +#endif // LIBWEAVE_SRC_DEVICE_REGISTRATION_INFO_H_ -- cgit v1.2.3