src/chrome/browser/chromeos/mobile/mobile_activator.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_CHROMEOS_MOBILE_MOBILE_ACTIVATOR_H_
   6 #define CHROME_BROWSER_CHROMEOS_MOBILE_MOBILE_ACTIVATOR_H_
   7
   8 #include <map>
   9 #include <string>
  10
  11 #include "base/files/file_path.h"
  12 #include "base/gtest_prod_util.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/singleton.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "base/observer_list.h"
  17 #include "base/timer/timer.h"
  18 #include "chromeos/network/network_handler_callbacks.h"
  19 #include "chromeos/network/network_state_handler_observer.h"
  20
  21 namespace base {
  22 class DictionaryValue;
  23 }
  24
  25 namespace chromeos {
  26
  27 class NetworkState;
  28 class TestMobileActivator;
  29
  30 // Cellular plan config document.
  31 class CellularConfigDocument
  32     : public base::RefCountedThreadSafe<CellularConfigDocument> {
  33  public:
  34   CellularConfigDocument();
  35
  36   // Return error message for a given code.
  37   std::string GetErrorMessage(const std::string& code);
  38   void LoadCellularConfigFile();
  39   const std::string& version() { return version_; }
  40
  41  private:
  42   friend class base::RefCountedThreadSafe<CellularConfigDocument>;
  43   typedef std::map<std::string, std::string> ErrorMap;
  44
  45   virtual ~CellularConfigDocument();
  46
  47   void SetErrorMap(const ErrorMap& map);
  48   bool LoadFromFile(const base::FilePath& config_path);
  49
  50   std::string version_;
  51   ErrorMap error_map_;
  52   base::Lock config_lock_;
  53
  54   DISALLOW_COPY_AND_ASSIGN(CellularConfigDocument);
  55 };
  56
  57 // This class performs mobile plan activation process.
  58 class MobileActivator
  59     : public base::SupportsWeakPtr<MobileActivator>,
  60       public NetworkStateHandlerObserver {
  61  public:
  62   // Activation state.
  63   enum PlanActivationState {
  64     // Activation WebUI page is loading, activation not started.
  65     PLAN_ACTIVATION_PAGE_LOADING            = -1,
  66     // Activation process started.
  67     PLAN_ACTIVATION_START                   = 0,
  68     // Initial over the air activation attempt.
  69     PLAN_ACTIVATION_TRYING_OTASP            = 1,
  70     // Performing pre-activation process.
  71     PLAN_ACTIVATION_INITIATING_ACTIVATION   = 3,
  72     // Reconnecting to network. Used for networks activated over cellular
  73     // connection.
  74     PLAN_ACTIVATION_RECONNECTING            = 4,
  75     // Passively waiting for a network connection. Used for networks activated
  76     // over non-cellular network.
  77     PLAN_ACTIVATION_WAITING_FOR_CONNECTION  = 5,
  78     // Loading payment portal page.
  79     PLAN_ACTIVATION_PAYMENT_PORTAL_LOADING  = 6,
  80     // Showing payment portal page.
  81     PLAN_ACTIVATION_SHOWING_PAYMENT         = 7,
  82     // Decides whether to load the portal again or call us done.
  83     PLAN_ACTIVATION_RECONNECTING_PAYMENT    = 8,
  84     // Delaying activation until payment portal catches up.
  85     PLAN_ACTIVATION_DELAY_OTASP             = 9,
  86     // Starting post-payment activation attempt.
  87     PLAN_ACTIVATION_START_OTASP             = 10,
  88     // Attempting activation.
  89     PLAN_ACTIVATION_OTASP                   = 11,
  90     // Finished activation.
  91     PLAN_ACTIVATION_DONE                    = 12,
  92     // Error occured during activation process.
  93     PLAN_ACTIVATION_ERROR                   = 0xFF,
  94   };
  95
  96   // Activation process observer.
  97   class Observer {
  98    public:
  99     // Signals activation |state| change for given |network|.
 100     virtual void OnActivationStateChanged(
 101         const NetworkState* network,
 102         PlanActivationState state,
 103         const std::string& error_description) = 0;
 104
 105    protected:
 106     Observer() {}
 107     virtual ~Observer() {}
 108   };
 109
 110   static MobileActivator* GetInstance();
 111
 112   // Add/remove activation process observer.
 113   void AddObserver(Observer* observer);
 114   void RemoveObserver(Observer* observer);
 115
 116   // Activation is in process.
 117   bool RunningActivation() const;
 118   // Activation state.
 119   PlanActivationState state() const { return state_; }
 120   // Initiates activation process.  Can only be called from the UI thread.
 121   void InitiateActivation(const std::string& service_path);
 122   // Terminates activation process if already started.
 123   void TerminateActivation();
 124   // Process portal load attempt status.
 125   void OnPortalLoaded(bool success);
 126   // Process payment transaction status.
 127   void OnSetTransactionStatus(bool success);
 128
 129  private:
 130   friend struct DefaultSingletonTraits<MobileActivator>;
 131   friend class TestMobileActivator;
 132   FRIEND_TEST_ALL_PREFIXES(MobileActivatorTest, BasicFlowForNewDevices);
 133   FRIEND_TEST_ALL_PREFIXES(MobileActivatorTest, OTASPScheduling);
 134   FRIEND_TEST_ALL_PREFIXES(MobileActivatorTest,
 135                            ReconnectOnDisconnectFromPaymentPortal);
 136   FRIEND_TEST_ALL_PREFIXES(MobileActivatorTest, StartAtStart);
 137   // We reach directly into the activator for testing purposes.
 138   friend class MobileActivatorTest;
 139
 140   MobileActivator();
 141   virtual ~MobileActivator();
 142
 143   // NetworkStateHandlerObserver overrides.
 144   virtual void DefaultNetworkChanged(const NetworkState* network) OVERRIDE;
 145   virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE;
 146
 147   // Continue activation after inital setup (config load). Makes an
 148   // asynchronous call to NetworkConfigurationHandler::GetProperties.
 149   void ContinueActivation();
 150   void GetPropertiesAndContinueActivation(
 151       const std::string& service_path,
 152       const base::DictionaryValue& properties);
 153   void GetPropertiesFailure(const std::string& error_name,
 154                             scoped_ptr<base::DictionaryValue> error_data);
 155   // Handles the signal that the payment portal has finished loading.
 156   void HandlePortalLoaded(bool success);
 157   // Handles the signal that the user has finished with the portal.
 158   void HandleSetTransactionStatus(bool success);
 159   // Starts activation.
 160   void StartActivation();
 161   // Called after we delay our OTASP (after payment).
 162   void RetryOTASP();
 163   // Continues activation process. This method is called after we disconnect
 164   // due to detected connectivity issue to kick off reconnection.
 165   void ContinueConnecting();
 166
 167   // Sends message to host registration page with system/user info data.
 168   void SendDeviceInfo();
 169
 170   // Starts OTASP process.
 171   void StartOTASP();
 172   // Called when an OTASP attempt times out.
 173   void HandleOTASPTimeout();
 174   // Forces disconnect / reconnect when we detect portal connectivity issues.
 175   void ForceReconnect(const NetworkState* network,
 176                       PlanActivationState next_state);
 177   // Called when ForceReconnect takes too long to reconnect.
 178   void ReconnectTimedOut();
 179
 180   // Called on default network changes to update cellular network activation
 181   // state.
 182   void RefreshCellularNetworks();
 183
 184   // Helper to get network state corresponding to service path. Provided
 185   // for easy mocking in unit tests.
 186   virtual const NetworkState* GetNetworkState(const std::string& service_path);
 187
 188   // Verify the state of cellular network and modify internal state.
 189   virtual void EvaluateCellularNetwork(const NetworkState* network);
 190   // PickNextState selects the desired state based on the current state of the
 191   // modem and the activator.  It does not transition to this state however.
 192   PlanActivationState PickNextState(const NetworkState* network,
 193                                     std::string* error_description) const;
 194   // One of PickNext*State are called in PickNextState based on whether the
 195   // modem is online or not.
 196   PlanActivationState PickNextOnlineState(const NetworkState* network) const;
 197   PlanActivationState PickNextOfflineState(const NetworkState* network) const;
 198   // Check the current cellular network for error conditions.
 199   bool GotActivationError(const NetworkState* network,
 200                           std::string* error) const;
 201   // Sends status updates to WebUI page.
 202   void UpdatePage(const NetworkState* network,
 203                   const std::string& error_description);
 204
 205   // Callback used to handle an activation error.
 206   void HandleActivationFailure(
 207       const std::string& service_path,
 208       PlanActivationState new_state,
 209       const std::string& error_name,
 210       scoped_ptr<base::DictionaryValue> error_data);
 211
 212   // Request cellular activation for |network|.
 213   // On success, |success_callback| will be called.
 214   // On failure, |error_callback| will be called.
 215   virtual void RequestCellularActivation(
 216       const NetworkState* network,
 217       const base::Closure& success_callback,
 218       const network_handler::ErrorCallback& error_callback);
 219
 220   // Changes internal state.
 221   virtual void ChangeState(const NetworkState* network,
 222                            PlanActivationState new_state,
 223                            std::string error_description);
 224   // Resets network devices after cellular activation process.
 225   void CompleteActivation();
 226   // Disables SSL certificate revocation checking mechanism. In the case
 227   // where captive portal connection is the only one present, such revocation
 228   // checks could prevent payment portal page from loading.
 229   void DisableCertRevocationChecking();
 230   // Reenables SSL certificate revocation checking mechanism.
 231   void ReEnableCertRevocationChecking();
 232   // Return error message for a given code.
 233   std::string GetErrorMessage(const std::string& code) const;
 234
 235   // Performs activation state cellular device evaluation.
 236   // Returns false if device activation failed. In this case |error|
 237   // will contain error message to be reported to Web UI.
 238   static bool EvaluateCellularDeviceState(bool* report_status,
 239                                           std::string* state,
 240                                           std::string* error);
 241   // Starts the OTASP timeout timer.  If the timer fires, we'll force a
 242   // disconnect/reconnect cycle on this network.
 243   virtual void StartOTASPTimer();
 244
 245   // Records information that cellular plan payment has happened.
 246   virtual void SignalCellularPlanPayment();
 247
 248   // Returns true if cellular plan payment has been recorded recently.
 249   virtual bool HasRecentCellularPlanPayment() const;
 250
 251   static const char* GetStateDescription(PlanActivationState state);
 252
 253   scoped_refptr<CellularConfigDocument> cellular_config_;
 254   // Internal handler state.
 255   PlanActivationState state_;
 256   // MEID of cellular device to activate.
 257   std::string meid_;
 258   // ICCID of the SIM card on cellular device to activate.
 259   std::string iccid_;
 260   // Service path of network being activated. Note that the path can change
 261   // during the activation process while still representing the same service.
 262   std::string service_path_;
 263   // Device on which the network service is activated. While the service path
 264   // can change during activation due to modem resets, the device path stays
 265   // the same.
 266   std::string device_path_;
 267   // Flags that controls if cert_checks needs to be restored
 268   // after the activation of cellular network.
 269   bool reenable_cert_check_;
 270   // True if activation process has been terminated.
 271   bool terminated_;
 272   // True if an asynchronous activation request was dispatched to Shill
 273   // but the succcess or failure of the request is yet unknown.
 274   bool pending_activation_request_;
 275   // Connection retry counter.
 276   int connection_retry_count_;
 277   // Counters for how many times we've tried each OTASP step.
 278   int initial_OTASP_attempts_;
 279   int trying_OTASP_attempts_;
 280   int final_OTASP_attempts_;
 281   // Payment portal reload/reconnect attempt count.
 282   int payment_reconnect_count_;
 283   // Timer that monitors how long we spend in error-prone states.
 284   base::RepeatingTimer<MobileActivator> state_duration_timer_;
 285
 286   // State we will return to if we are disconnected.
 287   PlanActivationState post_reconnect_state_;
 288   // Called to continue the reconnect attempt.
 289   base::RepeatingTimer<MobileActivator> continue_reconnect_timer_;
 290   // Called when the reconnect attempt times out.
 291   base::OneShotTimer<MobileActivator> reconnect_timeout_timer_;
 292   // Cellular plan payment time.
 293   base::Time cellular_plan_payment_time_;
 294
 295   ObserverList<Observer> observers_;
 296   base::WeakPtrFactory<MobileActivator> weak_ptr_factory_;
 297
 298   DISALLOW_COPY_AND_ASSIGN(MobileActivator);
 299 };
 300
 301 }  // namespace chromeos
 302
 303 #endif  // CHROME_BROWSER_CHROMEOS_MOBILE_MOBILE_ACTIVATOR_H_