GCP2.0 Device: Receiving printjobs.

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/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 kPrinterStatePath[] = "printer_state.json";
 
+typedef std::vector<Printjob> PrintjobList;
+
 namespace {
 
 const char kServiceType[] = "_privet._tcp.local";
 const char kServiceNamePrefix[] = "first_gcp20_device";
 const char kServiceDomainName[] = "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";
 const uint kUserConfirmationTimeout = 30;  // in seconds
 
+const uint32 kReconnectTimeout = 5;  // in seconds
+const uint32 kPrintjobsTimeout = 10;  // in seconds
+
 const char kCdd[] =
 "{\n"
 " 'version': '1.0',\n"
 "  'printer': {\n"
 "    'vendor_capability': [\n"
 "      {\n"
 "        'id': 'psk:MediaType',\n"
 "        'display_name': 'Media Type',\n"
 "        'type': 'SELECT',\n"
 "        'select_cap': {\n"
@@ skipping 44 matching lines @@
 }  // namespace
 
 Printer::RegistrationInfo::RegistrationInfo()
     : state(DEV_REG_UNREGISTERED),
       confirmation_state(CONFIRMATION_PENDING) {
 }
 
 Printer::RegistrationInfo::~RegistrationInfo() {
 }
 
-Printer::Printer() : http_server_(this) {
+Printer::Printer() : http_server_(this), connection_state_(OFFLINE) {
 }
 
 Printer::~Printer() {
   Stop();
 }
 
 bool Printer::Start() {
   if (IsOnline())
     return true;
 
@@ skipping 26 matching lines @@
 
   // Creating Cloud Requester.
   requester_.reset(
       new CloudPrintRequester(
           base::MessageLoop::current()->message_loop_proxy(),
           this));
 
   xtoken_ = XPrivetToken();
   starttime_ = base::Time::Now();
 
+  printjob_handler_.reset(new PrintjobHandler);
+  connection_state_ = CONNECTING;
+  if (IsRegistered())
+    WakeUp();
+
   return true;
 }
 
 bool Printer::IsOnline() const {
   return requester_;
 }
 
+void Printer::WakeUp() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+
+  if (!IsRegistered())
+    return;
+
+  FetchPrintjobs();
+}
+
 void Printer::Stop() {
   dns_server_.Shutdown();
   http_server_.Shutdown();
   requester_.reset();
+  printjob_handler_.reset();
 }
 
 PrivetHttpServer::RegistrationErrorStatus Printer::RegistrationStart(
     const std::string& user) {
   PrivetHttpServer::RegistrationErrorStatus status = CheckCommonRegErrors(user);
   if (status != PrivetHttpServer::REG_ERROR_OK)
     return status;
 
   if (reg_info_.state != RegistrationInfo::DEV_REG_UNREGISTERED)
     return PrivetHttpServer::REG_ERROR_INVALID_ACTION;
 
   reg_info_ = RegistrationInfo();
   reg_info_.user = user;
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_STARTED;
 
   printf("%s\n", kUserConfirmationTitle);
   base::Time valid_until = base::Time::Now() +
       base::TimeDelta::FromSeconds(kUserConfirmationTimeout);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
-      base::Bind(&Printer::WaitUserConfirmation,
-                 base::Unretained(this), valid_until));
+      base::Bind(&Printer::WaitUserConfirmation, this->AsWeakPtr(),

[Vitaly Buka (NO REVIEWS), 2013/07/22 03:57:31]

remote this->

[maksymb, 2013/07/22 22:56:53]

Done.

+                 valid_until));
 
   requester_->StartRegistration(GenerateProxyId(), kPrinterName, user, kCdd);
 
   return PrivetHttpServer::REG_ERROR_OK;
 }
 
-bool Printer::CheckXPrivetTokenHeader(const std::string& token) const {
-  return xtoken_.CheckValidXToken(token);
-}
-
-bool Printer::IsRegistered() const {
-  return reg_info_.state == RegistrationInfo::DEV_REG_REGISTERED;
-}
-
 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)
     return status;
 
   if (reg_info_.state != RegistrationInfo::DEV_REG_REGISTRATION_STARTED &&
       reg_info_.state !=
@@ skipping 62 matching lines @@
 void Printer::CreateInfo(PrivetHttpServer::DeviceInfo* info) {
   // TODO(maksymb): Replace "text" with constants.
 
   *info = PrivetHttpServer::DeviceInfo();
   info->version = "1.0";
   info->name = kPrinterName;
   info->description = kPrinterDescription;
   info->url = kCloudPrintUrl;
   info->id = reg_info_.device_id;
   info->device_state = "idle";
-  info->connection_state = "offline";
+  info->connection_state = ConnectionStateToString(connection_state_);
   info->manufacturer = "Google";
   info->model = "Prototype";
   info->serial_number = "2.3.5.7.13.17.19.31.61.89.107.127.521.607.1279.2203";
   info->firmware = "3.7.31.127.8191.131071.524287.2147483647";
   info->uptime = static_cast<int>((base::Time::Now() - starttime_).InSeconds());
 
   info->x_privet_token = xtoken_.GenerateXToken();
 
   if (reg_info_.state == RegistrationInfo::DEV_REG_UNREGISTERED)
     info->api.push_back("/privet/register");
 
   info->type.push_back("printer");
 }
 
+bool Printer::IsRegistered() const {
+  return reg_info_.state == RegistrationInfo::DEV_REG_REGISTERED;
+}
+
+bool Printer::CheckXPrivetTokenHeader(const std::string& token) const {
+  return xtoken_.CheckValidXToken(token);
+}
+
 void Printer::OnRegistrationStartResponseParsed(
     const std::string& registration_token,
     const std::string& complete_invite_url,
     const std::string& device_id) {
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_CLAIM_TOKEN_READY;
   reg_info_.device_id = device_id;
   reg_info_.registration_token = registration_token;
   reg_info_.complete_invite_url = complete_invite_url;
 }
 
 void Printer::OnGetAuthCodeResponseParsed(const std::string& refresh_token) {
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTERED;
   reg_info_.refresh_token = refresh_token;
   SaveToFile(kPrinterStatePath);
+  FetchPrintjobs();
 }
 
 void Printer::OnRegistrationError(const std::string& description) {
   LOG(ERROR) << "server_error: " << description;
 
   // TODO(maksymb): Implement waiting after error and timeout of registration.
   reg_info_.state = RegistrationInfo::DEV_REG_REGISTRATION_ERROR;
   reg_info_.error_description = description;
 }
 
+void Printer::OnServerError(const std::string& description) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  LOG(ERROR) << "Server error: " << description;
+
+  PostDelayedWakeUp(base::TimeDelta::FromSeconds(kReconnectTimeout));
+}
+
+void Printer::OnNetworkError() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  ChangeState(OFFLINE);
+  PostDelayedWakeUp(base::TimeDelta::FromSeconds(kReconnectTimeout));
+}
+
+void Printer::OnPrintjobsAvailable(const std::vector<Printjob>& printjobs) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  ChangeState(ONLINE);
+
+  LOG(INFO) << "Available printjobs: " << printjobs.size();
+
+  if (printjobs.empty()) {
+    PostDelayedWakeUp(base::TimeDelta::FromSeconds(kPrintjobsTimeout));
+    return;
+  }
+
+  // TODO(maksymb): After finishing XMPP add 'Printjobs available' flag.
+  LOG(INFO) << "Downloading first printjob.";
+  requester_->RequestPrintjob(printjobs[0]);
+  return;
+}
+
+void Printer::OnPrintjobDownloaded(const Printjob& printjob) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  printjob_handler_->SavePrintjob(
+      printjob.file,
+      printjob.ticket,
+      base::StringPrintf("%s.%s",
+                         printjob.create_time.c_str(), printjob.jobid.c_str()),
+      printjob.title);
+  requester_->SendPrintjobDone(printjob.jobid);
+}
+
+void Printer::OnPrintjobDone() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  // TODO(maksymb): Replace PostTask with with XMPP notifications.
+  PostWakeUp();
+}
+
 PrivetHttpServer::RegistrationErrorStatus Printer::CheckCommonRegErrors(
     const std::string& user) const {
   DCHECK(!IsRegistered());
 
   if (reg_info_.state != RegistrationInfo::DEV_REG_UNREGISTERED &&
       user != reg_info_.user) {
     return PrivetHttpServer::REG_ERROR_DEVICE_BUSY;
   }
 
   if (reg_info_.state == RegistrationInfo::DEV_REG_REGISTRATION_ERROR)
@@ skipping 16 matching lines @@
       LOG(INFO) << "Registration confirmed by user.";
     } else {
       reg_info_.confirmation_state = RegistrationInfo::CONFIRMATION_DISCARDED;
       LOG(INFO) << "Registration discarded by user.";
     }
     return;
   }
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&Printer::WaitUserConfirmation, base::Unretained(this),
+      base::Bind(&Printer::WaitUserConfirmation, this->AsWeakPtr(),
                  valid_until),
       base::TimeDelta::FromMilliseconds(100));
 }
 
 std::string Printer::GenerateProxyId() const {
   return "{" + base::GenerateGUID() +"}";
 }
 
 std::vector<std::string> Printer::CreateTxt() const {
   std::vector<std::string> txt;
   txt.push_back("txtvers=1");
   txt.push_back("ty=" + std::string(kPrinterName));
   txt.push_back("note=" + std::string(kPrinterDescription));
   txt.push_back("url=" + std::string(kCloudPrintUrl));
   txt.push_back("type=printer");
   txt.push_back("id=" + reg_info_.device_id);
-  txt.push_back("cs=offline");
+  txt.push_back("cs=" + ConnectionStateToString(connection_state_));
 
   return txt;
 }
 
+void Printer::FetchPrintjobs() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+
+  if (!IsRegistered())
+    return;
+
+  if (requester_->IsBusy()) {
+    PostDelayedWakeUp(base::TimeDelta::FromSeconds(kReconnectTimeout));
+  } else {
+    requester_->FetchPrintjobs(reg_info_.refresh_token, reg_info_.device_id);
+  }
+}
+
 void Printer::SaveToFile(const std::string& filename) const {
   base::DictionaryValue json;
   // 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);
   } else {
     json.SetBoolean("registered", false);
@@ skipping 61 matching lines @@
 
   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;
 
   return true;
 }
 
+void Printer::PostWakeUp() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&Printer::WakeUp, this->AsWeakPtr()));
+}
+
+void Printer::PostDelayedWakeUp(const base::TimeDelta& delay) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  base::MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&Printer::WakeUp, this->AsWeakPtr()),
+      delay);
+}
+
 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();
       return PrivetHttpServer::REG_ERROR_OK;
     case RegistrationInfo::CONFIRMATION_TIMEOUT:
       return PrivetHttpServer::REG_ERROR_CONFIRMATION_TIMEOUT;
     default:
       NOTREACHED();
       return PrivetHttpServer::REG_ERROR_OK;
   }
 }
 
+std::string Printer::ConnectionStateToString(ConnectionState state) const {
+  if (state == OFFLINE)
+    return "offline";
+  if (state == ONLINE)
+    return "online";
+  if (state == CONNECTING)
+    return "connecting";
+  if (state == NOT_CONFIGURED)
+    return "not-configured";
+
+  NOTREACHED();
+  return "";
+}
+
+bool Printer::ChangeState(ConnectionState new_state) {
+  if (connection_state_ == new_state)
+    return false;
+
+  VLOG(1) << "Printer is now " << ConnectionStateToString(new_state);
+  connection_state_ = new_state;
+  dns_server_.UpdateMetadata(CreateTxt());
+  return true;
+}
+