shill/cellular/cellular_service.h

// Copyright 2018 The Chromium OS 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 SHILL_CELLULAR_CELLULAR_SERVICE_H_
#define SHILL_CELLULAR_CELLULAR_SERVICE_H_

#include <memory>
#include <set>
#include <string>
#include <utility>

#include <base/macros.h>
#include <base/time/time.h>
#include <gtest/gtest_prod.h>  // for FRIEND_TEST

#include "shill/cellular/cellular.h"
#include "shill/cellular/subscription_state.h"
#include "shill/mockable.h"
#include "shill/refptr_types.h"
#include "shill/service.h"

namespace shill {

class Error;
class Manager;

class CellularService : public Service {
 public:
  enum ActivationType {
    kActivationTypeNonCellular,  // For future use
    kActivationTypeOMADM,        // For future use
    kActivationTypeOTA,
    kActivationTypeOTASP,
    kActivationTypeUnknown
  };

  // A CellularService is associated with a single SIM Profile, uniquely
  // identified by |iccid|. For pSIM profiles this also identifies the SIM card.
  // For eSIM profiles, |eid| is non-empty and identifies the eSIM card.
  // A CellularService may not be the active service for the associated
  // device, so its eID, ICCID and IMSI properties may not match the device
  // properties.
  CellularService(Manager* manager,
                  const std::string& imsi,
                  const std::string& iccid,
                  const std::string& eid);
  CellularService(const CellularService&) = delete;
  CellularService& operator=(const CellularService&) = delete;

  ~CellularService() override;

  void SetDevice(Cellular* device);

  // Public Service overrides
  void CompleteCellularActivation(Error* error) override;
  std::string GetStorageIdentifier() const override;
  std::string GetLoadableStorageIdentifier(
      const StoreInterface& storage) const override;
  bool IsLoadableFrom(const StoreInterface& storage) const override;
  bool Load(const StoreInterface* storage) override;
  bool Unload() override;
  bool Save(StoreInterface* storage) override;
  bool IsVisible() const override;

  // See matching method in cellular.h for details.
  const std::string& GetSimCardId() const;

  const std::string& imsi() const { return imsi_; }
  const std::string& iccid() const { return iccid_; }
  const std::string& eid() const { return eid_; }
  const CellularRefPtr& cellular() const { return cellular_; }

  void SetActivationType(ActivationType type);
  std::string GetActivationTypeString() const;

  mockable void SetActivationState(const std::string& state);
  mockable const std::string& activation_state() const {
    return activation_state_;
  }

  void SetOLP(const std::string& url,
              const std::string& method,
              const std::string& post_data);
  const Stringmap& olp() const { return olp_; }

  void SetUsageURL(const std::string& url);
  const std::string& usage_url() const { return usage_url_; }

  void SetServingOperator(const Stringmap& serving_operator);
  const Stringmap& serving_operator() const { return serving_operator_; }

  // Sets network technology to |technology| and broadcasts the property change.
  void SetNetworkTechnology(const std::string& technology);
  const std::string& network_technology() const { return network_technology_; }

  // Sets roaming state to |state| and broadcasts the property change.
  void SetRoamingState(const std::string& state);
  const std::string& roaming_state() const { return roaming_state_; }
  // Checks device rules as well as service rules and returns if roaming is
  // allowed for this service.
  bool IsRoamingAllowed();
  // Returns true if we are registered on a roaming network, but roaming is
  // disallowed.
  bool IsRoamingRuleViolated();
  // Returns allow_roaming_ for the service. If allow_roaming_ is nullopt,
  // returns any persisted value prior to M92.
  bool GetAllowRoaming();

  const std::string& ppp_username() const { return ppp_username_; }
  const std::string& ppp_password() const { return ppp_password_; }

  Stringmap* GetUserSpecifiedApn();
  Stringmap* GetLastGoodApn();
  virtual void SetLastGoodApn(const Stringmap& apn_info);
  virtual void ClearLastGoodApn();
  Stringmap* GetLastAttachApn();
  virtual void SetLastAttachApn(const Stringmap& apn_info);
  virtual void ClearLastAttachApn();

  void NotifySubscriptionStateChanged(SubscriptionState subscription_state);

  static const char kStorageIccid[];
  static const char kStorageImsi[];
  static const char kStoragePPPUsername[];
  static const char kStoragePPPPassword[];
  static const char kStorageSimCardId[];
  static const char kStorageAllowRoaming[];

  void set_activation_state_for_testing(const std::string& activation_state) {
    activation_state_ = activation_state;
  }
  void set_allow_roaming_for_testing(bool allow_roaming) {
    allow_roaming_ = allow_roaming;
  }
  void set_apn_info_for_testing(const Stringmap& apn_info) {
    apn_info_ = apn_info;
  }

 protected:
  // Protected Service overrides
  void OnConnect(Error* error) override;
  void OnDisconnect(Error* error, const char* reason) override;
  bool IsAutoConnectable(const char** reason) const override;
  uint64_t GetMaxAutoConnectCooldownTimeMilliseconds() const override;
  bool IsDisconnectable(Error* error) const override;
  bool IsMeteredByServiceProperties() const override;
  RpcIdentifier GetDeviceRpcId(Error* error) const override;

 private:
  friend class CellularCapability3gppTest;
  friend class CellularCapabilityCdmaTest;
  friend class CellularServiceTest;
  friend class CellularTest;

  template <typename key_type, typename value_type>
  friend class ContainsCellularPropertiesMatcherP2;

  FRIEND_TEST(CellularTest, Connect);
  FRIEND_TEST(CellularTest, FriendlyServiceName);
  FRIEND_TEST(CellularTest, GetLogin);  // ppp_username_, ppp_password_
  FRIEND_TEST(CellularServiceTest, SetApn);
  FRIEND_TEST(CellularServiceTest, SetAttachApn);
  FRIEND_TEST(CellularServiceTest, ClearApn);
  FRIEND_TEST(CellularServiceTest, LastGoodApn);
  FRIEND_TEST(CellularServiceTest, IsAutoConnectable);
  FRIEND_TEST(CellularServiceTest, LoadResetsPPPAuthFailure);
  FRIEND_TEST(CellularServiceTest, SaveAndLoadApn);
  FRIEND_TEST(CellularServiceTest, MergeDetailsFromApnList);
  FRIEND_TEST(CellularServiceTest, CustomSetterNoopChange);
  FRIEND_TEST(CellularServiceTest, SetAllowRoaming);

  // Used in CellularServiceTest
  static const char kAutoConnActivating[];
  static const char kAutoConnSimUnselected[];
  static const char kAutoConnBadPPPCredentials[];
  static const char kAutoConnDeviceDisabled[];
  static const char kAutoConnNotRegistered[];
  static const char kAutoConnOutOfCredits[];
  static const char kAutoConnConnectFailed[];
  static const char kAutoConnInhibited[];

  void HelpRegisterDerivedString(
      const std::string& name,
      std::string (CellularService::*get)(Error* error),
      bool (CellularService::*set)(const std::string& value, Error* error));
  void HelpRegisterDerivedStringmap(
      const std::string& name,
      Stringmap (CellularService::*get)(Error* error),
      bool (CellularService::*set)(const Stringmap& value, Error* error));
  void HelpRegisterDerivedBool(const std::string& name,
                               bool (CellularService::*get)(Error* error),
                               bool (CellularService::*set)(const bool&,
                                                            Error*));
  std::set<std::string> GetStorageGroupsWithProperty(
      const StoreInterface& storage,
      const std::string& key,
      const std::string& value) const;
  std::string CalculateActivationType(Error* error);
  Stringmap GetApn(Error* error);
  bool SetApn(const Stringmap& value, Error* error);
  KeyValueStore GetStorageProperties() const;
  std::string GetDefaultStorageIdentifier() const;
  bool IsOutOfCredits(Error* /*error*/);
  bool SetAllowRoaming(const bool& value, Error* error);
  bool GetAllowRoaming(Error* /*error*/);
  void ClearAllowRoaming(Error* /*error*/);

  // The IMSI for the SIM. This is saved in the Profile and emitted as a
  // property so that it is available for non primary SIM Profiles.
  // This is set on construction when available, or may be loaded from a saved
  // Profile entry.
  std::string imsi_;

  // ICCID uniquely identifies a SIM profile.
  const std::string iccid_;

  // EID of the associated eSIM card, or empty for a SIM profile associated with
  // a physical SIM card.
  const std::string eid_;

  ActivationType activation_type_ = kActivationTypeUnknown;
  std::string activation_state_;
  Stringmap serving_operator_;
  std::string network_technology_;
  std::string roaming_state_;
  Stringmap olp_;
  std::string usage_url_;
  Stringmap apn_info_;
  Stringmap last_good_apn_info_;
  // Stores the attach APN used for the initial EPS settings
  Stringmap last_attach_apn_info_;
  std::string ppp_username_;
  std::string ppp_password_;
  base::Optional<bool> allow_roaming_;
  bool provider_requires_roaming_ = false;

  // The storage identifier defaults to cellular_{iccid}.
  std::string storage_identifier_;

  // The Cellular Device associated with this Service. Note: This may not be
  // the active service for |cellular_| if there are multiple SIM profiles for
  // |cellular_|.
  CellularRefPtr cellular_;

  // Flag indicating if the user has run out of data credits.
  bool out_of_credits_ = false;
};

}  // namespace shill

#endif  // SHILL_CELLULAR_CELLULAR_SERVICE_H_