Merge lp:~unity-api-team/indicator-network/second-sim-data-14.09 into lp:indicator-network/14.09

[Pete Woods]

Listen to connection manager powered flag to determine the active modem

Listen to connection manager powered flag to determine the active modem

[lp:~unity-api-team/indicator-network/second-sim-data-14.09]

472. By Pete Woods on 2015-02-16

Listen to connection manager powered flag to determine the active modem

473. By Pete Woods on 2015-02-16

Remove -Werror hack

[Pete Woods (pete-woods)]

Cherry pick!

[Marcus Tomlinson (marcustomlinson)]

Looks good

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-10-09 10:58:30 +0000
+++ CMakeLists.txt	2015-02-16 18:34:52 +0000
@@ -98,9 +98,6 @@
 include_directories(${CMAKE_BINARY_DIR})
 
 set(COMMON_FLAGS "-Wall -Wextra -Wpedantic -fno-permissive -fPIC -fvisibility=hidden -pthread")
-if(NOT build_type_lower MATCHES debug)
-    set(COMMON_FLAGS "${COMMON_FLAGS} -Werror")
-endif()
 
 # "nice bug" in cmake... http://www.cmake.org/Bug/view.php?id=15058
 # let's not set C_FLAGS as it will break pthreads detection \o/

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-08-19 19:55:15 +0000
+++ src/CMakeLists.txt	2015-02-16 18:34:52 +0000
@@ -1,3 +1,8 @@
+
+if(NOT build_type_lower MATCHES debug)
+    set(COMMON_FLAGS "${COMMON_FLAGS} -Werror")
+endif()
+
 add_subdirectory(dbus-cpp)
 add_subdirectory(connectivity-cpp)
 add_subdirectory(indicator)

=== modified file 'src/dbus-cpp/services/ofono.h'
--- src/dbus-cpp/services/ofono.h	2015-02-16 18:34:52 +0000
+++ src/dbus-cpp/services/ofono.h	2015-02-16 18:34:52 +0000
@@ -791,6 +791,226 @@
         core::Property<std::string> subscriberIdentity;
     }; // Interface::SimManager
 
+    struct ConnectionManager
+    {
+        static const std::string& name()
+        {
+            static const std::string s{OFONO_CONNECTION_MANAGER_INTERFACE};
+            return s;
+        }
+
+        struct Method
+        {
+            struct GetProperties
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"GetProperties"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef std::map<std::string, core::dbus::types::Variant> ResultType;
+
+                static std::chrono::milliseconds default_timeout()
+                {
+                    return std::chrono::seconds{30};
+                }
+            };
+
+            struct SetProperty
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"SetProperty"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef void ResultType;
+                typedef std::tuple<std::string, core::dbus::types::Variant> ArgumentType;
+
+                static std::chrono::milliseconds default_timeout()
+                {
+                    return std::chrono::seconds{30};
+                }
+            };
+
+            struct AddContext
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"AddContext"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef core::dbus::types::ObjectPath ResultType;
+                typedef std::string ArgumentType;
+
+                static std::chrono::milliseconds default_timeout()
+                {
+                    return std::chrono::seconds{30};
+                }
+            };
+
+            struct RemoveContext
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"RemoveContext"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef void ResultType;
+                typedef core::dbus::types::ObjectPath ArgumentType;
+
+                static std::chrono::milliseconds default_timeout()
+                {
+                    return std::chrono::seconds{30};
+                }
+            };
+
+            struct DeactivateAll
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"DeactivateAll"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef void ResultType;
+
+                static std::chrono::milliseconds default_timeout()
+                {
+                    return std::chrono::seconds{30};
+                }
+            };
+
+            struct GetContexts
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"GetContexts"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef std::tuple<core::dbus::types::ObjectPath, std::map<std::string, core::dbus::types::Variant>> ResultType;
+
+                static std::chrono::milliseconds default_timeout()
+                {
+                    return std::chrono::seconds{30};
+                }
+            };
+
+        };
+
+        struct Property
+        {
+            struct Powered
+            {
+                static const std::string &name()
+                {
+                    static const std::string s{"Powered"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef bool ValueType;
+                static const bool readable = true;
+                static const bool writable = false;
+            };
+        };
+
+        struct Signal
+        {
+            struct PropertyChanged
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"PropertyChanged"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef std::tuple<std::string, core::dbus::types::Variant> ArgumentType;
+            };
+
+            struct ContextAdded
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"ContextAdded"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef std::tuple<core::dbus::types::ObjectPath, core::dbus::types::Variant> ArgumentType;
+            };
+
+            struct ContextRemoved
+            {
+                static const std::string& name()
+                {
+                    static const std::string s{"ContextRemoved"};
+                    return s;
+                }
+
+                typedef ConnectionManager Interface;
+                typedef core::dbus::types::ObjectPath ArgumentType;
+            };
+        };
+
+
+        std::map<std::string, core::dbus::types::Variant>
+        getProperties()
+        {
+            auto result =
+                    object->invoke_method_synchronously<
+                    ConnectionManager::Method::GetProperties, ConnectionManager::Method::GetProperties::ResultType>();
+
+            if (result.is_error()) {
+                throw std::runtime_error(result.error().print());
+            }
+
+            return result.value();
+        }
+
+        void _updateProperty(std::string property, core::dbus::types::Variant value)
+        {
+            if (property == Property::Powered::name()) {
+                powered.set(value.as<Property::Powered::ValueType>());
+            }
+        }
+
+        typedef std::shared_ptr<ConnectionManager> Ptr;
+        explicit ConnectionManager(const std::shared_ptr<core::dbus::Object>& object)
+            : object(object),
+              propertyChanged(object->get_signal<Signal::PropertyChanged>())
+        {
+            propertyChanged->connect([this](Signal::PropertyChanged::ArgumentType args){
+                _updateProperty(std::get<0>(args), std::get<1>(args));
+            });
+            auto result = getProperties();
+            for (auto element : result)
+            {
+                _updateProperty(element.first, element.second);
+            }
+        }
+
+        ~ConnectionManager()
+        {}
+
+        std::shared_ptr<core::dbus::Object> object;
+        std::shared_ptr<core::dbus::Signal<Signal::PropertyChanged, Signal::PropertyChanged::ArgumentType>> propertyChanged;
+
+        core::Property<bool> powered;
+
+    }; // Interface::ConnectionManager
+
     struct Modem
     {
         static const std::string& name()
@@ -1026,7 +1246,16 @@
                     case Property::Interfaces::Type::CallSettings:
                     case Property::Interfaces::Type::CallVolume:
                     case Property::Interfaces::Type::CellBroadcast:
+                        break;
                     case Property::Interfaces::Type::ConnectionManager:
+                    {
+                        std::unique_lock<std::mutex> lock(_lock);
+                        if (std::find(newInterfaces.begin(), newInterfaces.end(), known) == newInterfaces.end() &&
+                            connectionManager.get()) {
+                            connectionManager.set(std::shared_ptr<ConnectionManager>());
+                        }
+                        break;
+                    }
                     case Property::Interfaces::Type::Handsfree:
                     case Property::Interfaces::Type::LocationReporting:
                     case Property::Interfaces::Type::MessageManager:
@@ -1074,7 +1303,15 @@
                     case Property::Interfaces::Type::CallSettings:
                     case Property::Interfaces::Type::CallVolume:
                     case Property::Interfaces::Type::CellBroadcast:
+                        break;
                     case Property::Interfaces::Type::ConnectionManager:
+                    {
+                        std::unique_lock<std::mutex> lock(_lock);
+                        if (!connectionManager.get()) {
+                            connectionManager.set(std::make_shared<ConnectionManager>(this->object));
+                        }
+                        break;
+                    }
                     case Property::Interfaces::Type::Handsfree:
                     case Property::Interfaces::Type::LocationReporting:
                     case Property::Interfaces::Type::MessageManager:
@@ -1180,6 +1417,7 @@
 
         // this lock must be acquired for any access to networkRegistration or simManager
         std::mutex _lock;
+        core::Property<ConnectionManager::Ptr> connectionManager;
         core::Property<NetworkRegistration::Ptr> networkRegistration;
         core::Property<SimManager::Ptr>          simManager;
 

=== modified file 'src/indicator/modem.cpp'
--- src/indicator/modem.cpp	2015-02-16 18:34:52 +0000
+++ src/indicator/modem.cpp	2015-02-16 18:34:52 +0000
@@ -36,9 +36,12 @@
     core::Property<std::int8_t> m_strength;
     core::Property<org::ofono::Interface::NetworkRegistration::Technology> m_technology;
 
+    core::Property<bool> m_dataEnabled;
+
     core::Property<std::string> m_simIdentifier;
     int m_index = -1;
 
+    void connectionManagerChanged(org::ofono::Interface::ConnectionManager::Ptr conmgr);
     void networkRegistrationChanged(org::ofono::Interface::NetworkRegistration::Ptr netreg);
     void simManagerChanged(org::ofono::Interface::SimManager::Ptr simmgr);
 
@@ -68,6 +71,7 @@
     std::unique_lock<std::mutex> lock(m_ofonoModem->_lock);
     auto simmgr = m_ofonoModem->simManager.get();
     auto netreg = m_ofonoModem->networkRegistration.get();
+    auto conmgr = m_ofonoModem->connectionManager.get();
     lock.unlock();
 
     simManagerChanged(simmgr);
@@ -82,6 +86,12 @@
         that->networkRegistrationChanged(netreg);
     });
 
+    connectionManagerChanged(conmgr);
+    m_ofonoModem->connectionManager.changed().connect([that](org::ofono::Interface::ConnectionManager::Ptr conmgr)
+    {
+        that->connectionManagerChanged(conmgr);
+    });
+
     /// @todo hook up with system-settings to allow changing the identifier.
     ///       for now just provide the defaults
     const auto path = m_ofonoModem->object->path().as_string();
@@ -103,6 +113,7 @@
     std::unique_lock<std::mutex> lock(m_ofonoModem->_lock);
     auto simmgr = m_ofonoModem->simManager.get();
     auto netreg = m_ofonoModem->networkRegistration.get();
+    auto conmgr = m_ofonoModem->connectionManager.get();
     lock.unlock();
 
     if (simmgr) {
@@ -170,6 +181,12 @@
         m_strength.set(-1);
         m_technology.set(org::ofono::Interface::NetworkRegistration::Technology::notAvailable);
     }
+
+    if (conmgr) {
+        m_dataEnabled.set(conmgr->powered.get());
+    } else {
+        m_dataEnabled.set(false);
+    }
 }
 
 void
@@ -201,6 +218,20 @@
     GMainLoopDispatch([that]() { that->update(); });
 }
 
+void
+Modem::Private::connectionManagerChanged(org::ofono::Interface::ConnectionManager::Ptr conmgr)
+{
+    auto that = shared_from_this();
+    if (conmgr) {
+        conmgr->powered.changed().connect([that](bool)
+        {
+            GMainLoopDispatch([that]() { that->update(); });
+        });
+    }
+
+    GMainLoopDispatch([that]() { that->update(); });
+}
+
 
 void
 Modem::Private::simManagerChanged(org::ofono::Interface::SimManager::Ptr simmgr)
@@ -372,6 +403,12 @@
     return d->m_simIdentifier;
 }
 
+const core::Property<bool> &
+Modem::dataEnabled()
+{
+    return d->m_dataEnabled;
+}
+
 int
 Modem::index()
 {

=== modified file 'src/indicator/modem.h'
--- src/indicator/modem.h	2014-12-09 10:05:45 +0000
+++ src/indicator/modem.h	2015-02-16 18:34:52 +0000
@@ -98,6 +98,8 @@
     const core::Property<std::int8_t> &strength();
     const core::Property<org::ofono::Interface::NetworkRegistration::Technology> &technology();
 
+    const core::Property<bool> &dataEnabled();
+
     const core::Property<std::string> &simIdentifier();
     int index();
 

=== modified file 'src/indicator/root-state.cpp'
--- src/indicator/root-state.cpp	2014-10-29 18:12:05 +0000
+++ src/indicator/root-state.cpp	2015-02-16 18:34:52 +0000
@@ -43,6 +43,8 @@
     std::map<Modem::Ptr, std::string> m_cellularIcons;
     std::map<int, std::string>        m_modemTechIcons;
 
+    int m_activeModem = -1;
+
     Private() = delete;
     Private(std::shared_ptr<networking::Manager> manager, ModemManager::Ptr modemManager);
     void ConstructL();
@@ -116,6 +118,7 @@
     for (auto modem : removed)
         m_cellularIcons.erase(modem);
 
+    m_activeModem = -1;
     for (auto modem : added) {
         // modem properties and signals already synced with GMainLoop
         modem->online().changed().connect(std::bind(&Private::updateModem, this, Modem::WeakPtr(modem)));
@@ -123,6 +126,7 @@
         modem->status().changed().connect(std::bind(&Private::updateModem, this, Modem::WeakPtr(modem)));
         modem->technology().changed().connect(std::bind(&Private::updateModem, this, Modem::WeakPtr(modem)));
         modem->strength().changed().connect(std::bind(&Private::updateModem, this, Modem::WeakPtr(modem)));
+        modem->dataEnabled().changed().connect(std::bind(&Private::updateModem, this, Modem::WeakPtr(modem)));
         updateModem(modem);
     }
 }
@@ -136,6 +140,10 @@
         return;
     }
 
+    if (modem->dataEnabled().get())
+    {
+        m_activeModem = modem->index();
+    }
     m_modemTechIcons.erase(modem->index());
     m_cellularIcons[modem] = "";
 
@@ -249,11 +257,13 @@
         }
 
         if (m_networkingIcon.empty()) {
-            // seems we don't have an active wifi connection..
-            // it must be a cellular one then.
-            /// @todo need to revise this once the modems are part of the connectivity-api
-            ///       this might get us wrong results on dual-sim
-            m_networkingIcon = m_modemTechIcons[1];
+            if (m_activeModem != -1) {
+                auto it = m_modemTechIcons.find(m_activeModem);
+                if (it != m_modemTechIcons.end())
+                {
+                    m_networkingIcon = it->second;
+                }
+            }
         }
         break;
     }

=== modified file 'tests/integration/connectivity-cpp/CMakeLists.txt'
--- tests/integration/connectivity-cpp/CMakeLists.txt	2014-08-22 14:56:59 +0000
+++ tests/integration/connectivity-cpp/CMakeLists.txt	2015-02-16 18:34:52 +0000
@@ -16,11 +16,7 @@
 #     Antti Kaijanmäki <[e-mail]>
 
 
-set (OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-# Don't treat warnings as errors in 3rd_party/{gmock,cucumber-cpp}
-string (REPLACE " -Werror " " " CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
 include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
-set (CMAKE_CXX_FLAGS ${OLD_CMAKE_CXX_FLAGS})
 
 if (NOT DEFINED GTEST_ROOT)
     set(GTEST_ROOT /usr/src/gtest)