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_MODEM_MANAGER_H_ 18 #define SHILL_CELLULAR_MODEM_MANAGER_H_ 19 20 #include <map> 21 #include <memory> 22 #include <string> 23 #include <vector> 24 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/dbus_objectmanager_proxy_interface.h" 30 #include "shill/cellular/modem_info.h" 31 #include "shill/dbus_properties_proxy_interface.h" 32 33 namespace shill { 34 35 class ControlInterface; 36 class DBusObjectManagerProxyInterface; 37 class DBusPropertiesProxyInterface; 38 class Modem1; 39 class Modem; 40 class ModemClassic; 41 class ModemManagerProxyInterface; 42 43 // Handles a modem manager service and creates and destroys modem instances. 44 class ModemManager { 45 public: 46 ModemManager(ControlInterface* control_interface, 47 const std::string& service, 48 const std::string& path, 49 ModemInfo* modem_info); 50 virtual ~ModemManager(); 51 52 // Starts watching for and handling the DBus modem manager service. 53 virtual void Start() = 0; 54 55 // Stops watching for the DBus modem manager service and destroys any 56 // associated modems. 57 virtual void Stop() = 0; 58 59 void OnDeviceInfoAvailable(const std::string& link_name); 60 61 protected: 62 typedef std::map<std::string, std::shared_ptr<Modem>> Modems; 63 64 const std::string& service() const { return service_; } 65 const std::string& path() const { return path_; } 66 ControlInterface* control_interface() const { return control_interface_; } 67 ModemInfo* modem_info() const { return modem_info_; } 68 69 // Service availability callbacks. 70 void OnAppeared(); 71 void OnVanished(); 72 73 // Connect/Disconnect to a modem manager service. 74 // Inheriting classes must call this superclass method. 75 virtual void Connect(); 76 // Inheriting classes must call this superclass method. 77 virtual void Disconnect(); 78 79 bool ModemExists(const std::string& path) const; 80 // Put the modem into our modem map 81 void RecordAddedModem(std::shared_ptr<Modem> modem); 82 83 // Removes a modem on |path|. 84 void RemoveModem(const std::string& path); 85 86 private: 87 friend class ModemManagerCoreTest; 88 friend class ModemManagerClassicTest; 89 friend class ModemManager1Test; 90 91 FRIEND_TEST(ModemInfoTest, RegisterModemManager); 92 FRIEND_TEST(ModemManager1Test, AddRemoveInterfaces); 93 FRIEND_TEST(ModemManager1Test, Connect); 94 FRIEND_TEST(ModemManagerClassicTest, Connect); 95 FRIEND_TEST(ModemManagerCoreTest, AddRemoveModem); 96 FRIEND_TEST(ModemManagerCoreTest, ConnectDisconnect); 97 FRIEND_TEST(ModemManagerCoreTest, OnAppearVanish); 98 99 ControlInterface* control_interface_; 100 101 const std::string service_; 102 const std::string path_; 103 bool service_connected_; 104 105 Modems modems_; // Maps a modem |path| to a modem instance. 106 107 ModemInfo* modem_info_; 108 109 DISALLOW_COPY_AND_ASSIGN(ModemManager); 110 }; 111 112 class ModemManagerClassic : public ModemManager { 113 public: 114 ModemManagerClassic(ControlInterface* control_interface, 115 const std::string& service, 116 const std::string& path, 117 ModemInfo* modem_info); 118 119 ~ModemManagerClassic() override; 120 121 void Start() override; 122 void Stop() override; 123 124 // Called by our dbus proxy 125 void OnDeviceAdded(const std::string& path); 126 void OnDeviceRemoved(const std::string& path); 127 128 protected: 129 void Connect() override; 130 void Disconnect() override; 131 132 virtual void AddModemClassic(const std::string& path); 133 virtual void InitModemClassic(std::shared_ptr<ModemClassic> modem); 134 135 private: 136 std::unique_ptr<ModemManagerProxyInterface> proxy_; // DBus service proxy 137 std::unique_ptr<DBusPropertiesProxyInterface> dbus_properties_proxy_; 138 139 FRIEND_TEST(ModemManagerClassicTest, Connect); 140 FRIEND_TEST(ModemManagerClassicTest, StartStop); 141 142 DISALLOW_COPY_AND_ASSIGN(ModemManagerClassic); 143 }; 144 145 class ModemManager1 : public ModemManager { 146 public: 147 ModemManager1(ControlInterface* control_interface, 148 const std::string& service, 149 const std::string& path, 150 ModemInfo* modem_info); 151 152 ~ModemManager1() override; 153 154 void Start() override; 155 void Stop() override; 156 157 protected: 158 void AddModem1(const std::string& path, 159 const InterfaceToProperties& properties); 160 virtual void InitModem1(std::shared_ptr<Modem1> modem, 161 const InterfaceToProperties& properties); 162 163 // ModemManager methods 164 void Connect() override; 165 void Disconnect() override; 166 167 // DBusObjectManagerProxyDelegate signal methods 168 virtual void OnInterfacesAddedSignal( 169 const std::string& object_path, 170 const InterfaceToProperties& properties); 171 virtual void OnInterfacesRemovedSignal( 172 const std::string& object_path, 173 const std::vector<std::string>& interfaces); 174 175 // DBusObjectManagerProxyDelegate method callbacks 176 virtual void OnGetManagedObjectsReply( 177 const ObjectsWithProperties& objects_with_properties, 178 const Error& error); 179 180 private: 181 friend class ModemManager1Test; 182 FRIEND_TEST(ModemManager1Test, Connect); 183 FRIEND_TEST(ModemManager1Test, AddRemoveInterfaces); 184 FRIEND_TEST(ModemManager1Test, StartStop); 185 186 std::unique_ptr<DBusObjectManagerProxyInterface> proxy_; 187 base::WeakPtrFactory<ModemManager1> weak_ptr_factory_; 188 189 DISALLOW_COPY_AND_ASSIGN(ModemManager1); 190 }; 191 192 } // namespace shill 193 194 #endif // SHILL_CELLULAR_MODEM_MANAGER_H_ 195
