| // |
| // Copyright (C) 2012 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| |
| #ifndef SHILL_CELLULAR_CELLULAR_SERVICE_H_ |
| #define SHILL_CELLULAR_CELLULAR_SERVICE_H_ |
| |
| #include <map> |
| #include <memory> |
| #include <string> |
| |
| #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/out_of_credits_detector.h" |
| #include "shill/refptr_types.h" |
| #include "shill/service.h" |
| |
| namespace shill { |
| |
| class ControlInterface; |
| class Error; |
| class EventDispatcher; |
| class Manager; |
| class OutOfCreditsDetector; |
| |
| class CellularService : public Service { |
| public: |
| enum ActivationType { |
| kActivationTypeNonCellular, // For future use |
| kActivationTypeOMADM, // For future use |
| kActivationTypeOTA, |
| kActivationTypeOTASP, |
| kActivationTypeUnknown |
| }; |
| |
| CellularService(ModemInfo* modem_info, |
| const CellularRefPtr& device); |
| ~CellularService() override; |
| |
| // Inherited from Service. |
| void AutoConnect() override; |
| void Connect(Error* error, const char* reason) override; |
| void Disconnect(Error* error, const char* reason) override; |
| void ActivateCellularModem(const std::string& carrier, |
| Error* error, |
| const ResultCallback& callback) override; |
| void CompleteCellularActivation(Error* error) override; |
| void SetState(ConnectState new_state) override; |
| |
| std::string GetStorageIdentifier() const override; |
| void SetStorageIdentifier(const std::string& identifier); |
| |
| const CellularRefPtr& cellular() const { return cellular_; } |
| |
| void SetActivationType(ActivationType type); |
| std::string GetActivationTypeString() const; |
| |
| virtual void SetActivationState(const std::string& state); |
| virtual 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 set_serving_operator(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_; } |
| |
| bool is_auto_connecting() const { |
| return is_auto_connecting_; |
| } |
| |
| const std::string& ppp_username() const { return ppp_username_; } |
| const std::string& ppp_password() const { return ppp_password_; } |
| |
| virtual const base::Time& resume_start_time() const { |
| return resume_start_time_; |
| } |
| |
| OutOfCreditsDetector* out_of_credits_detector() { |
| return out_of_credits_detector_.get(); |
| } |
| void SignalOutOfCreditsChanged(bool state) const; |
| |
| // Overrides Load and Save from parent Service class. We will call |
| // the parent method. |
| bool Load(StoreInterface* storage) override; |
| bool Save(StoreInterface* storage) override; |
| |
| Stringmap* GetUserSpecifiedApn(); |
| Stringmap* GetLastGoodApn(); |
| virtual void SetLastGoodApn(const Stringmap& apn_info); |
| virtual void ClearLastGoodApn(); |
| |
| void OnAfterResume() override; |
| |
| // Initialize out-of-credits detection. |
| void InitOutOfCreditsDetection(OutOfCreditsDetector::OOCType ooc_type); |
| |
| protected: |
| // Overrides IsAutoConnectable from parent Service class. |
| bool IsAutoConnectable(const char** reason) const override; |
| |
| private: |
| friend class CellularCapabilityUniversalTest; |
| friend class CellularServiceTest; |
| FRIEND_TEST(CellularCapabilityGSMTest, SetupApnTryList); |
| FRIEND_TEST(CellularCapabilityTest, TryApns); |
| FRIEND_TEST(CellularCapabilityUniversalMainTest, |
| UpdatePendingActivationState); |
| FRIEND_TEST(CellularCapabilityUniversalMainTest, UpdateServiceName); |
| FRIEND_TEST(CellularTest, Connect); |
| FRIEND_TEST(CellularTest, GetLogin); // ppp_username_, ppp_password_ |
| FRIEND_TEST(CellularTest, OnConnectionHealthCheckerResult); |
| FRIEND_TEST(CellularServiceTest, SetApn); |
| FRIEND_TEST(CellularServiceTest, ClearApn); |
| FRIEND_TEST(CellularServiceTest, LastGoodApn); |
| FRIEND_TEST(CellularServiceTest, LoadResetsPPPAuthFailure); |
| FRIEND_TEST(CellularServiceTest, IsAutoConnectable); |
| FRIEND_TEST(CellularServiceTest, OutOfCreditsDetected); |
| FRIEND_TEST(CellularServiceTest, |
| OutOfCreditsDetectionNotSkippedAfterSlowResume); |
| FRIEND_TEST(CellularServiceTest, OutOfCreditsDetectionSkippedAfterResume); |
| FRIEND_TEST(CellularServiceTest, |
| OutOfCreditsDetectionSkippedAlreadyOutOfCredits); |
| FRIEND_TEST(CellularServiceTest, |
| OutOfCreditsDetectionSkippedExplicitDisconnect); |
| FRIEND_TEST(CellularServiceTest, OutOfCreditsNotDetectedConnectionNotDropped); |
| FRIEND_TEST(CellularServiceTest, OutOfCreditsNotDetectedIntermittentNetwork); |
| FRIEND_TEST(CellularServiceTest, OutOfCreditsNotEnforced); |
| FRIEND_TEST(CellularServiceTest, CustomSetterNoopChange); |
| |
| static const char kAutoConnActivating[]; |
| static const char kAutoConnBadPPPCredentials[]; |
| static const char kAutoConnDeviceDisabled[]; |
| static const char kAutoConnOutOfCredits[]; |
| static const char kAutoConnOutOfCreditsDetectionInProgress[]; |
| static const char kStoragePPPUsername[]; |
| static const char kStoragePPPPassword[]; |
| |
| 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::string GetDeviceRpcId(Error* error) const override; |
| |
| std::string CalculateActivationType(Error* error); |
| |
| Stringmap GetApn(Error* error); |
| bool SetApn(const Stringmap& value, Error* error); |
| static void SaveApn(StoreInterface* storage, |
| const std::string& storage_group, |
| const Stringmap* apn_info, |
| const std::string& keytag); |
| static void SaveApnField(StoreInterface* storage, |
| const std::string& storage_group, |
| const Stringmap* apn_info, |
| const std::string& keytag, |
| const std::string& apntag); |
| static void LoadApn(StoreInterface* storage, |
| const std::string& storage_group, |
| const std::string& keytag, |
| Stringmap* apn_info); |
| static bool LoadApnField(StoreInterface* storage, |
| const std::string& storage_group, |
| const std::string& keytag, |
| const std::string& apntag, |
| Stringmap* apn_info); |
| bool IsOutOfCredits(Error* /*error*/); |
| |
| // For unit test. |
| void set_out_of_credits_detector(OutOfCreditsDetector* detector); |
| |
| base::WeakPtrFactory<CellularService> weak_ptr_factory_; |
| |
| // Properties |
| ActivationType activation_type_; |
| 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_; |
| std::string ppp_username_; |
| std::string ppp_password_; |
| |
| std::string storage_identifier_; |
| |
| CellularRefPtr cellular_; |
| |
| // Flag indicating that a connect request is an auto-connect request. |
| // Note: Since Connect() is asynchronous, this flag is only set during the |
| // call to Connect(). It does not remain set while the async request is |
| // in flight. |
| bool is_auto_connecting_; |
| // Time when the last resume occurred. |
| base::Time resume_start_time_; |
| // Out-of-credits detector. |
| std::unique_ptr<OutOfCreditsDetector> out_of_credits_detector_; |
| |
| DISALLOW_COPY_AND_ASSIGN(CellularService); |
| }; |
| |
| } // namespace shill |
| |
| #endif // SHILL_CELLULAR_CELLULAR_SERVICE_H_ |