1 // 2 // Copyright (C) 2012 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #ifndef SHILL_CELLULAR_CELLULAR_CAPABILITY_CLASSIC_H_ 18 #define SHILL_CELLULAR_CELLULAR_CAPABILITY_CLASSIC_H_ 19 20 #include <memory> 21 #include <string> 22 #include <vector> 23 24 #include <base/callback.h> 25 #include <base/macros.h> 26 #include <base/memory/weak_ptr.h> 27 #include <gtest/gtest_prod.h> // for FRIEND_TEST 28 29 #include "shill/cellular/cellular.h" 30 #include "shill/cellular/cellular_capability.h" 31 #include "shill/cellular/modem_proxy_interface.h" 32 #include "shill/cellular/modem_simple_proxy_interface.h" 33 34 namespace shill { 35 36 class Cellular; 37 class ControlInterface; 38 class Error; 39 class EventDispatcher; 40 class ModemGobiProxyInterface; 41 class ModemInfo; 42 43 enum ModemClassicState { 44 kModemClassicStateUnknown = 0, 45 kModemClassicStateDisabled = 10, 46 kModemClassicStateDisabling = 20, 47 kModemClassicStateEnabling = 30, 48 kModemClassicStateEnabled = 40, 49 kModemClassicStateSearching = 50, 50 kModemClassicStateRegistered = 60, 51 kModemClassicStateDisconnecting = 70, 52 kModemClassicStateConnecting = 80, 53 kModemClassicStateConnected = 90, 54 }; 55 56 // CellularCapabilityClassic handles modems using the 57 // org.chromium.ModemManager DBUS interface. 58 class CellularCapabilityClassic : public CellularCapability { 59 public: 60 static const char kConnectPropertyApn[]; 61 static const char kConnectPropertyApnUsername[]; 62 static const char kConnectPropertyApnPassword[]; 63 static const char kConnectPropertyHomeOnly[]; 64 static const char kConnectPropertyPhoneNumber[]; 65 static const char kModemPropertyEnabled[]; 66 static const int kTimeoutSetCarrierMilliseconds; 67 68 // |cellular| is the parent Cellular device. 69 CellularCapabilityClassic(Cellular* cellular, 70 ControlInterface* control_interface, 71 ModemInfo* modem_info); 72 ~CellularCapabilityClassic() override; 73 74 // Inherited from CellularCapability. 75 void OnPropertiesChanged( 76 const std::string& interface, 77 const KeyValueStore& changed_properties, 78 const std::vector<std::string>& invalidated_properties) override; 79 void StopModem(Error* error, const ResultCallback& callback) override; 80 bool AreProxiesInitialized() const override; 81 void SetCarrier(const std::string& carrier, 82 Error* error, 83 const ResultCallback& callback) override; 84 void Connect(const KeyValueStore& properties, 85 Error* error, 86 const ResultCallback& callback) override; 87 void Disconnect(Error* error, 88 const ResultCallback& callback) override; 89 90 protected: 91 typedef std::vector<base::Closure> CellularTaskList; 92 93 virtual void GetRegistrationState() = 0; 94 95 // The following five methods are only ever called as 96 // callbacks (from the main loop), which is why they 97 // don't take an Error* argument. 98 virtual void EnableModem(const ResultCallback& callback); 99 virtual void DisableModem(const ResultCallback& callback); 100 virtual void GetModemStatus(const ResultCallback& callback); 101 virtual void GetModemInfo(const ResultCallback& callback); 102 virtual void GetProperties(const ResultCallback& callback) = 0; 103 104 void FinishEnable(const ResultCallback& callback); 105 void FinishDisable(const ResultCallback& callback); 106 virtual void InitProxies(); 107 void ReleaseProxies() override; 108 109 // Default implementation is no-op. 110 virtual void UpdateStatus(const KeyValueStore& properties); 111 112 // Runs the next task in a list. 113 // Precondition: |tasks| is not empty. 114 void RunNextStep(CellularTaskList* tasks); 115 // StepCompletedCallback is called after a task completes. 116 // |callback| is the original callback that needs to be invoked when all of 117 // the tasks complete or if there is a failure. |ignore_error| will be set 118 // to true if the next task should be run regardless of the result of the 119 // just-completed task. |tasks| is the list of tasks remaining. |error| is 120 // the result of the just-completed task. 121 void StepCompletedCallback(const ResultCallback& callback, 122 bool ignore_error, 123 CellularTaskList* tasks, 124 const Error& error); 125 126 std::unique_ptr<ModemSimpleProxyInterface> simple_proxy_; 127 128 private: 129 friend class CellularTest; 130 friend class CellularCapabilityCDMATest; 131 friend class CellularCapabilityTest; 132 friend class CellularCapabilityGSMTest; 133 FRIEND_TEST(CellularCapabilityGSMTest, SetProxy); 134 FRIEND_TEST(CellularCapabilityGSMTest, SetStorageIdentifier); 135 FRIEND_TEST(CellularCapabilityGSMTest, UpdateStatus); 136 FRIEND_TEST(CellularCapabilityTest, AllowRoaming); 137 FRIEND_TEST(CellularCapabilityTest, EnableModemFail); 138 FRIEND_TEST(CellularCapabilityTest, EnableModemSucceed); 139 FRIEND_TEST(CellularCapabilityTest, FinishEnable); 140 FRIEND_TEST(CellularCapabilityTest, GetModemInfo); 141 FRIEND_TEST(CellularCapabilityTest, GetModemStatus); 142 FRIEND_TEST(CellularCapabilityTest, TryApns); 143 FRIEND_TEST(CellularServiceTest, FriendlyName); 144 FRIEND_TEST(CellularTest, StartCDMARegister); 145 FRIEND_TEST(CellularTest, StartConnected); 146 FRIEND_TEST(CellularTest, StartGSMRegister); 147 FRIEND_TEST(CellularTest, StartLinked); 148 FRIEND_TEST(CellularTest, Connect); 149 FRIEND_TEST(CellularTest, ConnectFailure); 150 FRIEND_TEST(CellularTest, ConnectFailureNoService); 151 FRIEND_TEST(CellularTest, ConnectSuccessNoService); 152 FRIEND_TEST(CellularTest, Disconnect); 153 FRIEND_TEST(CellularTest, DisconnectFailure); 154 FRIEND_TEST(CellularTest, DisconnectWithCallback); 155 FRIEND_TEST(CellularTest, ModemStateChangeEnable); 156 FRIEND_TEST(CellularTest, ModemStateChangeDisable); 157 158 // Method reply and signal callbacks from Modem interface 159 void OnModemStateChangedSignal(uint32_t old_state, 160 uint32_t new_state, 161 uint32_t reason); 162 void OnGetModemInfoReply(const ResultCallback& callback, 163 const std::string& manufacturer, 164 const std::string& modem, 165 const std::string& version, 166 const Error& error); 167 168 // Method reply callbacks from Modem.Simple interface 169 void OnGetModemStatusReply(const ResultCallback& callback, 170 const KeyValueStore& props, 171 const Error& error); 172 173 Cellular* cellular_; 174 base::WeakPtrFactory<CellularCapabilityClassic> weak_ptr_factory_; 175 std::unique_ptr<ModemProxyInterface> proxy_; 176 std::unique_ptr<ModemGobiProxyInterface> gobi_proxy_; 177 178 DISALLOW_COPY_AND_ASSIGN(CellularCapabilityClassic); 179 }; 180 181 } // namespace shill 182 183 #endif // SHILL_CELLULAR_CELLULAR_CAPABILITY_CLASSIC_H_ 184
