GCP2.0 Device: Local settings workflow.

cloud_print/gcp20/prototype/printer.cc

 // Copyright 2013 The Chromium 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 "cloud_print/gcp20/prototype/printer.h"
 
 #include <stdio.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "cloud_print/gcp20/prototype/command_line_reader.h"
+#include "cloud_print/gcp20/prototype/local_settings.h"
 #include "cloud_print/gcp20/prototype/service_parameters.h"
 #include "cloud_print/gcp20/prototype/special_io.h"
 #include "net/base/net_util.h"
 #include "net/base/url_util.h"
 
 const char kPrinterStatePathDefault[] = "printer_state.json";
 
 namespace {
 
 const uint16 kHttpPortDefault = 10101;
 const uint32 kTtlDefault = 60*60;  // in seconds
-const int kXmppPingIntervalDefault = 5*60;  // in seconds
 
 const char kServiceType[] = "_privet._tcp.local";
 const char kServiceNamePrefixDefault[] = "first_gcp20_device";
 const char kServiceDomainNameDefault[] = "my-privet-device.local";
 
 const char kPrinterName[] = "Google GCP2.0 Prototype";
 const char kPrinterDescription[] = "Printer emulator";
 
 const char kUserConfirmationTitle[] = "Confirm registration: type 'y' if you "
                                       "agree and any other to discard\n";
@@ skipping 42 matching lines @@
   bool success = net::GetNetworkList(&interfaces);
   DCHECK(success);
 
   size_t expected_address_size = return_ipv6_number ? net::kIPv6AddressSize
                                                     : net::kIPv4AddressSize;
 
   for (net::NetworkInterfaceList::iterator iter = interfaces.begin();
        iter != interfaces.end(); ++iter) {
     if (iter->address.size() == expected_address_size &&
         (interface_name.empty() || interface_name == iter->name)) {
-      LOG(INFO) << net::IPAddressToString(iter->address);
       return iter->address;
     }
   }
 
   return net::IPAddressNumber();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() {
   return base::MessageLoop::current()->message_loop_proxy();
 }
 
 }  // namespace
 
 using cloud_print_response_parser::Job;
 
 Printer::RegistrationInfo::RegistrationInfo()
     : state(DEV_REG_UNREGISTERED),
       confirmation_state(CONFIRMATION_PENDING) {
 }
 
 Printer::RegistrationInfo::~RegistrationInfo() {
 }
 
 Printer::Printer()
     : http_server_(this),
       connection_state_(OFFLINE),
       on_idle_posted_(false),
       pending_local_settings_check_(false),
-      pending_print_jobs_check_(false) {
+      pending_print_jobs_check_(false),
+      pending_deletion_(false) {
 }
 
 Printer::~Printer() {
   Stop();
 }
 
 bool Printer::Start() {
   if (IsRunning())
     return true;
 
-  // TODO(maksymb): Add switch for command line to control interface name.
-  net::IPAddressNumber ip = GetLocalIp("", false);
-  if (ip.empty()) {
-    LOG(ERROR) << "No local IP found. Cannot start printer.";
-    return false;
-  }
-  VLOG(1) << "Local address: " << net::IPAddressToString(ip);
-
-  uint16 port = command_line_reader::ReadHttpPort(kHttpPortDefault);
-
-  // Starting HTTP server.
-  if (!http_server_.Start(port))
-    return false;
-
   if (!LoadFromFile())
     reg_info_ = RegistrationInfo();
 
-  // Starting DNS-SD server.
-  std::string service_name_prefix =
-      command_line_reader::ReadServiceNamePrefix(kServiceNamePrefixDefault);
-  std::string service_domain_name =
-      command_line_reader::ReadDomainName(kServiceDomainNameDefault);
-  if (!dns_server_.Start(
-      ServiceParameters(kServiceType, service_name_prefix, service_domain_name,
-                        ip, port),
-      command_line_reader::ReadTtl(kTtlDefault),
-      CreateTxt())) {
-    http_server_.Shutdown();
-    return false;
+  if (local_settings_.local_discovery) {
+    if (!StartHttpServer())
+      return false;
+
+    if (!StartDnsServer()) {
+      http_server_.Shutdown();
+      return false;
+    }
   }
 
   print_job_handler_.reset(new PrintJobHandler);
   xtoken_ = XPrivetToken();
   starttime_ = base::Time::Now();
 
   TryConnect();
   return true;
 }
 
 bool Printer::IsRunning() const {
   return print_job_handler_;
 }
 
 void Printer::Stop() {
+  if (!IsRunning())
+    return;
   dns_server_.Shutdown();
   http_server_.Shutdown();
   requester_.reset();
   print_job_handler_.reset();
   xmpp_listener_.reset();
 }
 
 void Printer::OnAuthError() {
   LOG(ERROR) << "Auth error occurred";
   access_token_update_ = base::Time();
@@ skipping 33 matching lines @@
     LOG(INFO) << "Registration confirmed by default.";
   } else {
     printf("%s", kUserConfirmationTitle);
     base::Time valid_until = base::Time::Now() +
         base::TimeDelta::FromSeconds(kUserConfirmationTimeout);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&Printer::WaitUserConfirmation, AsWeakPtr(), valid_until));
   }
 
-  requester_->StartRegistration(GenerateProxyId(), kPrinterName, user, kCdd);
+  requester_->StartRegistration(GenerateProxyId(), kPrinterName, user,
+                                local_settings_, kCdd);
 
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationGetClaimToken(
     const std::string& user,
     std::string* token,
     std::string* claim_url) {
   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
   if (status != PrivetHttpServer::REG_ERROR_OK)
@@ skipping 197 matching lines @@
       base::StringPrintf("%s.%s", job.create_time.c_str(), job.job_id.c_str()),
       job.title);
   requester_->SendPrintJobDone(job.job_id);
 }
 
 void Printer::OnPrintJobDone() {
   VLOG(3) << "Function: " << __FUNCTION__;
   PostOnIdle();
 }
 
+void Printer::OnLocalSettingsReceived(LocalSettings::State state,
+                                      const LocalSettings& settings) {
+  pending_local_settings_check_ = false;
+  switch (state) {
+    case LocalSettings::CURRENT:
+      LOG(INFO) << "No new local settings";
+      PostOnIdle();
+      break;
+    case LocalSettings::PENDING:
+      LOG(INFO) << "New local settings were received";
+      ApplyLocalSettings(settings);
+      break;
+    case LocalSettings::PRINTER_DELETED:
+      LOG(WARNING) << "Printer was deleted on server";
+      pending_deletion_ = true;
+      PostOnIdle();
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
+void Printer::OnLocalSettingsUpdated() {
+  PostOnIdle();
+}
+
 void Printer::OnXmppConnected() {
   pending_local_settings_check_ = true;
   pending_print_jobs_check_ = true;
   ChangeState(ONLINE);
   PostOnIdle();
 }
 
 void Printer::OnXmppAuthError() {
   OnAuthError();
 }
 
 void Printer::OnXmppNetworkError() {
   FallOffline(false);
 }
 
 void Printer::OnXmppNewPrintJob(const std::string& device_id) {
   DCHECK_EQ(reg_info_.device_id, device_id) << "Data should contain printer_id";
   pending_print_jobs_check_ = true;
 }
 
 void Printer::OnXmppNewLocalSettings(const std::string& device_id) {
   DCHECK_EQ(reg_info_.device_id, device_id) << "Data should contain printer_id";
-  NOTIMPLEMENTED();
+  pending_local_settings_check_ = true;
 }
 
 void Printer::OnXmppDeleteNotification(const std::string& device_id) {
   DCHECK_EQ(reg_info_.device_id, device_id) << "Data should contain printer_id";
-  NOTIMPLEMENTED();
+  pending_deletion_ = true;
 }
 
 void Printer::TryConnect() {
   VLOG(3) << "Function: " << __FUNCTION__;
 
   ChangeState(CONNECTING);
   if (!requester_)
     requester_.reset(new CloudPrintRequester(GetTaskRunner(), this));
 
   if (IsRegistered()) {
     if (access_token_update_ < base::Time::Now()) {
       requester_->UpdateAccesstoken(reg_info_.refresh_token);
     } else {
       ConnectXmpp();
     }
   } else {
     // TODO(maksymb): Ping google.com to check connection state.
     ChangeState(ONLINE);
   }
 }
 
 void Printer::ConnectXmpp() {
   xmpp_listener_.reset(
-      new CloudPrintXmppListener(reg_info_.xmpp_jid, kXmppPingIntervalDefault,
+      new CloudPrintXmppListener(reg_info_.xmpp_jid,
+                                 local_settings_.xmpp_timeout_value,
                                  GetTaskRunner(), this));
   xmpp_listener_->Connect(access_token_);
 }
 
 void Printer::OnIdle() {
   DCHECK(IsRegistered());
   DCHECK(on_idle_posted_) << "Instant call is not allowed";
   on_idle_posted_ = false;
 
   if (connection_state_ != ONLINE)
     return;
 
+  if (pending_deletion_) {
+    OnPrinterDeleted();
+    return;
+  }
+
   if (access_token_update_ < base::Time::Now()) {
     requester_->UpdateAccesstoken(reg_info_.refresh_token);
     return;
   }
 
   // TODO(maksymb): Check if privet-accesstoken was requested.
 
-  // TODO(maksymb): Check if local-printing was requested.
-
   if (pending_local_settings_check_) {
     GetLocalSettings();
     return;
   }
 
   if (pending_print_jobs_check_) {
     FetchPrintJobs();
     return;
   }
 
   base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&Printer::PostOnIdle, AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(1000));
 }
 
-void Printer::GetLocalSettings() {
-  DCHECK(IsRegistered());
-
-  pending_local_settings_check_ = false;
-  PostOnIdle();
-}
-
 void Printer::FetchPrintJobs() {
   VLOG(3) << "Function: " << __FUNCTION__;
-
   DCHECK(IsRegistered());
   requester_->FetchPrintJobs(reg_info_.device_id);
 }
 
+void Printer::GetLocalSettings() {
+  VLOG(3) << "Function: " << __FUNCTION__;
+  DCHECK(IsRegistered());
+  requester_->RequestLocalSettings(reg_info_.device_id);
+}
+
+void Printer::ApplyLocalSettings(const LocalSettings& settings) {
+  local_settings_ = settings;
+  SaveToFile();
+
+  if (local_settings_.local_discovery) {
+    StartDnsServer();
+    StartHttpServer();
+  } else {
+    dns_server_.Shutdown();
+    http_server_.Shutdown();
+  }
+
+  xmpp_listener_->set_ping_interval(local_settings_.xmpp_timeout_value);
+
+  requester_->SendLocalSettings(reg_info_.device_id, local_settings_);
+}
+
+void Printer::OnPrinterDeleted() {
+  pending_deletion_ = false;
+
+  reg_info_ = RegistrationInfo();
+  access_token_.clear();
+  access_token_update_ = base::Time();
+  local_settings_ = LocalSettings();
+
+  SaveToFile();
+  Stop();
+  Start();
+}
+
 void Printer::RememberAccessToken(const std::string& access_token,
                                   int expires_in_seconds) {
   using base::Time;
   using base::TimeDelta;
   access_token_ = access_token;
   int64 time_to_update = static_cast<int64>(expires_in_seconds *
                                             kTimeToNextAccessTokenUpdate);
   access_token_update_ = Time::Now() + TimeDelta::FromSeconds(time_to_update);
   VLOG(1) << "Current access_token: " << access_token;
   SaveToFile();
@@ skipping 78 matching lines @@
   // TODO(maksymb): Get rid of in-place constants.
   if (IsRegistered()) {
     json.SetBoolean("registered", true);
     json.SetString("user", reg_info_.user);
     json.SetString("device_id", reg_info_.device_id);
     json.SetString("refresh_token", reg_info_.refresh_token);
     json.SetString("xmpp_jid", reg_info_.xmpp_jid);
     json.SetString("access_token", access_token_);
     json.SetInteger("access_token_update",
                     static_cast<int>(access_token_update_.ToTimeT()));
+
+    scoped_ptr<base::DictionaryValue> local_settings(new DictionaryValue);
+    local_settings->SetBoolean("local_discovery",
+                               local_settings_.local_discovery);
+    local_settings->SetBoolean("access_token_enabled",
+                               local_settings_.access_token_enabled);
+    local_settings->SetBoolean("printer/local_printing_enabled",
+                               local_settings_.local_printing_enabled);
+    local_settings->SetInteger("xmpp_timeout_value",
+                               local_settings_.xmpp_timeout_value);
+    json.Set("local_settings", local_settings.release());
   } else {
     json.SetBoolean("registered", false);
   }
 
   std::string json_str;
   base::JSONWriter::WriteWithOptions(&json,
                                      base::JSONWriter::OPTIONS_PRETTY_PRINT,
                                      &json_str);
   if (!file_util::WriteFile(file_path, json_str.data(),
                             static_cast<int>(json_str.size()))) {
@@ skipping 65 matching lines @@
     LOG(ERROR) << "Cannot parse |access_token|.";
     return false;
   }
 
   int access_token_update;
   if (!json->GetInteger("access_token_update", &access_token_update)) {
     LOG(ERROR) << "Cannot parse |access_token_update|.";
     return false;
   }
 
+  LocalSettings local_settings;
+  base::DictionaryValue* settings_dict;
+  if (!json->GetDictionary("local_settings", &settings_dict)) {
+    LOG(ERROR) << "Cannot read |local_settings|. Reset to default.";
+  } else {
+    if (!settings_dict->GetBoolean("local_discovery",
+                                   &local_settings.local_discovery) ||
+        !settings_dict->GetBoolean("access_token_enabled",
+                                   &local_settings.access_token_enabled) ||
+        !settings_dict->GetBoolean("printer/local_printing_enabled",
+                                   &local_settings.local_printing_enabled) ||
+        !settings_dict->GetInteger("xmpp_timeout_value",
+                                   &local_settings.xmpp_timeout_value)) {
+      LOG(ERROR) << "Cannot parse |local_settings|. Reset to default.";
+      local_settings = LocalSettings();
+    }
+  }
+
   reg_info_ = RegistrationInfo();
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTERED;
   reg_info_.user = user;
   reg_info_.device_id = device_id;
   reg_info_.refresh_token = refresh_token;
   reg_info_.xmpp_jid = xmpp_jid;
-  using base::Time;
   access_token_ = access_token;
-  access_token_update_ = Time::FromTimeT(access_token_update);
+  access_token_update_ = base::Time::FromTimeT(access_token_update);
+  local_settings_ = local_settings;
 
   return true;
 }
 
 void Printer::PostOnIdle() {
   VLOG(3) << "Function: " << __FUNCTION__;
   DCHECK(!on_idle_posted_) << "Only one instance can be posted.";
   on_idle_posted_ = true;
 
   base::MessageLoop::current()->PostTask(
@@ skipping 13 matching lines @@
 
 void Printer::UpdateRegistrationExpiration() {
   registration_expiration_ =
       base::Time::Now() + base::TimeDelta::FromSeconds(kRegistrationTimeout);
 }
 
 void Printer::InvalidateRegistrationExpiration() {
   registration_expiration_ = base::Time();
 }
 
+bool Printer::StartHttpServer() {
+  DCHECK(local_settings_.local_discovery);
+  using command_line_reader::ReadHttpPort;
+  return http_server_.Start(ReadHttpPort(kHttpPortDefault));
+}
+
+bool Printer::StartDnsServer() {
+  DCHECK(local_settings_.local_discovery);
+
+  // TODO(maksymb): Add switch for command line to control interface name.
+  net::IPAddressNumber ip = GetLocalIp("", false);
+  if (ip.empty()) {
+    LOG(ERROR) << "No local IP found. Cannot start printer.";
+    return false;
+  }
+  VLOG(1) << "Local address: " << net::IPAddressToString(ip);
+
+  uint16 port = command_line_reader::ReadHttpPort(kHttpPortDefault);
+
+  std::string service_name_prefix =
+      command_line_reader::ReadServiceNamePrefix(kServiceNamePrefixDefault);
+  std::string service_domain_name =
+      command_line_reader::ReadDomainName(kServiceDomainNameDefault);
+
+  ServiceParameters params(kServiceType, service_name_prefix,
+                           service_domain_name, ip, port);
+
+  return dns_server_.Start(params,
+                           command_line_reader::ReadTtl(kTtlDefault),
+                           CreateTxt());
+}
+
 PrivetHttpServer::RegistrationErrorStatus
 Printer::ConfirmationToRegistrationError(
     RegistrationInfo::ConfirmationState state) {
   switch (state) {
     case RegistrationInfo::CONFIRMATION_PENDING:
       return PrivetHttpServer::REG_ERROR_PENDING_USER_ACTION;
     case RegistrationInfo::CONFIRMATION_DISCARDED:
       return PrivetHttpServer::REG_ERROR_USER_CANCEL;
     case RegistrationInfo::CONFIRMATION_CONFIRMED:
       NOTREACHED();
@@ skipping 53 matching lines @@
   dns_server_.UpdateMetadata(CreateTxt());
 
   if (connection_state_ == OFFLINE) {
     requester_.reset();
     xmpp_listener_.reset();
   }
 
   return true;
 }