Merge lp:~pete-woods/indicator-network/hotspot-management into lp:indicator-network/15.10

[Pete Woods]

Add hotspot management.

Add hotspot management.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:503
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/357/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-amd64-ci/9
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/9
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/9/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/357/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:504
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/360/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/12
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/12/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/360/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:507
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/363/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-amd64-ci/15
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/15
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/15/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/363/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:510
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/371/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-amd64-ci/23/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/23/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/371/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:511
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/372/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-amd64-ci/24
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/24
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/24/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/372/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:512
http://jenkins.qa.ubuntu.com/job/indicator-network-ci/373/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-amd64-ci/25
    SUCCESS: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/25
        deb: http://jenkins.qa.ubuntu.com/job/indicator-network-wily-armhf-ci/25/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/indicator-network-ci/373/rebuild

review: Approve (continuous-integration)

[lp:~pete-woods/indicator-network/hotspot-management]

500. By Charles Kerr on 2015-07-27

drop build-dependency on g++-4.9 Edit Fixes: #1452327
Approved by: Pete Woods, PS Jenkins bot, Rodney Dawes

501. By CI Train Bot Account on 2015-07-27

Releasing 0.5.1+15.10.20150727-0ubuntu1

506. By Pete Woods on 2015-07-13

Only update the initialized property when both interfaces have been initalized

507. By Pete Woods on 2015-07-15

Add HotspotManager

508. By Pete Woods on 2015-07-15

Remove dead method

509. By Pete Woods on 2015-07-15

Initialize Priv data member in HotspotManager

510. By Pete Woods on 2015-07-21

Grab property values from the correct interface

511. By Pete Woods on 2015-07-21

Make HotspotManager more OO, e.g. use member variables instead of passing around state

512. By Pete Woods on 2015-07-28

Wire up reportError signal to public interface

=== modified file 'data/com.ubuntu.connectivity1.NetworkingStatus.xml'
--- data/com.ubuntu.connectivity1.NetworkingStatus.xml	2015-04-23 10:02:23 +0000
+++ data/com.ubuntu.connectivity1.NetworkingStatus.xml	2015-07-28 08:25:09 +0000
@@ -9,6 +9,11 @@
         <property name="FlightMode" type="b" access="read"/>
         <property name="WifiEnabled" type="b" access="read"/>
 
+        <property name="HotspotSsid" type="ay" access="read"/>
+        <property name="HotspotEnabled" type="b" access="read"/>
+        <property name="HotspotMode" type="s" access="read"/>
+        <property name="HotspotStored" type="b" access="read"/>
+
         <property name="UnstoppableOperationHappening" type="b" access="read"/>
 
     </interface>

=== modified file 'data/com.ubuntu.connectivity1.Private.xml'
--- data/com.ubuntu.connectivity1.Private.xml	2015-04-22 10:06:53 +0000
+++ data/com.ubuntu.connectivity1.Private.xml	2015-07-28 08:25:09 +0000
@@ -18,6 +18,28 @@
             <arg type="b" direction="in" name="enabled"/>
         </method>
 
+        <method name="SetHotspotSsid">
+            <arg type="ay" direction="in" name="ssid"/>
+        </method>
+
+        <method name="SetHotspotPassword">
+            <arg type="s" direction="in" name="password"/>
+        </method>
+
+        <method name="SetHotspotEnabled">
+            <arg type="b" direction="in" name="enabled"/>
+        </method>
+
+        <method name="SetHotspotMode">
+            <arg type="s" direction="in" name="mode"/>
+        </method>
+
+        <property name="HotspotPassword" type="s" access="read"/>
+
+        <signal name="ReportError">
+            <arg type="i" direction="out" name="reason"/>
+        </signal>
+
     </interface>
 </node>
 

=== added file 'data/nm-settings.xml'
--- data/nm-settings.xml	1970-01-01 00:00:00 +0000
+++ data/nm-settings.xml	2015-07-28 08:25:09 +0000
@@ -0,0 +1,214 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<node name="/org/freedesktop/NetworkManager/Settings" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
+  <interface name="org.freedesktop.NetworkManager.Settings">
+    <tp:docstring>
+      The Settings interface allows clients to view and administrate the connections stored and used by NetworkManager.
+    </tp:docstring>
+
+    <method name="ListConnections">
+      <tp:docstring>
+        List the saved network connections known to NetworkManager.
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_list_connections"/>
+      <arg name="connections" type="ao" direction="out">
+        <tp:docstring>
+          List of connections.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <method name="GetConnectionByUuid">
+      <tp:docstring>
+        Retrieve the object path of a connection, given that connection's UUID.
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_get_connection_by_uuid"/>
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="uuid" type="s" direction="in">
+        <tp:docstring>
+          The UUID to find the connection object path for.
+        </tp:docstring>
+      </arg>
+      <arg name="connection" type="o" direction="out">
+        <tp:docstring>
+          The connection's object path.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <method name="AddConnection">
+      <tp:docstring>
+        Add new connection and save it to disk.  This operation does not start
+        the network connection unless (1) device is idle and able to connect to
+        the network described by the new connection, and (2) the connection
+        is allowed to be started automatically.
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_add_connection"/>
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QVariantDictMap"/>
+      <arg name="connection" type="a{sa{sv}}" direction="in">
+        <tp:docstring>
+          Connection settings and properties.
+        </tp:docstring>
+      </arg>
+      <arg name="path" type="o" direction="out">
+        <tp:docstring>
+          Object path of the new connection that was just added.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <method name="AddConnectionUnsaved">
+      <tp:docstring>
+        Add new connection but do not save it to disk immediately.  This
+        operation does not start the network connection unless (1) device is
+        idle and able to connect to the network described by the new connection,
+        and (2) the connection is allowed to be started automatically.
+
+        Use the 'Save' method on the connection to save these changes
+        to disk. Note that unsaved changes will be lost if the
+        connection is reloaded from disk (either automatically on file
+        change or due to an explicit ReloadConnections call).
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_add_connection_unsaved"/>
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QVariantDictMap"/>
+      <arg name="connection" type="a{sa{sv}}" direction="in">
+        <tp:docstring>
+          Connection settings and properties.
+        </tp:docstring>
+      </arg>
+      <arg name="path" type="o" direction="out">
+        <tp:docstring>
+          Object path of the new connection that was just added.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <method name="LoadConnections">
+      <tp:docstring>
+        Loads or reloads the indicated connections from disk. You
+        should call this after making changes directly to an on-disk
+        connection file to make sure that NetworkManager sees the
+        changes. (If "monitor-connection-files" in NetworkManager.conf
+        is "true", then this will have no real effect, but is
+        harmless.) As with AddConnection(), this operation does not
+        necessarily start the network connection.
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_load_connections"/>
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="filenames" type="as" direction="in">
+        <tp:docstring>
+          Array of paths to on-disk connection profiles in directories
+          monitored by NetworkManager.
+        </tp:docstring>
+      </arg>
+      <arg name="status" type="b" direction="out">
+        <tp:docstring>
+          Success or failure of the operation as a whole. True if
+          NetworkManager at least tried to load the indicated
+          connections, even if it did not succeed. False if an error
+          occurred before trying to load the connections (eg,
+          permission denied).
+        </tp:docstring>
+      </arg>
+      <arg name="failures" type="as" direction="out">
+        <tp:docstring>
+          Paths of connection files that could not be loaded.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <method name="ReloadConnections">
+      <tp:docstring>
+        Tells NetworkManager to reload all connection files from disk,
+        including noticing any added or deleted connection files. By
+        default, connections are re-read automatically any time they
+        change, so you only need to use this command if you have set
+        "monitor-connection-files=false" in NetworkManager.conf.
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_reload_connections"/>
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="status" type="b" direction="out">
+        <tp:docstring>
+          Success or failure.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <method name="SaveHostname">
+      <tp:docstring>
+        Save the hostname to persistent configuration.
+      </tp:docstring>
+      <annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_settings_save_hostname"/>
+      <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+      <arg name="hostname" type="s" direction="in">
+        <tp:docstring>
+          The hostname to save to persistent configuration.  If blank, the persistent hostname is cleared.
+        </tp:docstring>
+      </arg>
+    </method>
+
+    <property name="Connections" type="ao" access="read">
+      <tp:docstring>
+        List of object paths of available network connection profiles.
+      </tp:docstring>
+    </property>
+
+    <property name="Hostname" type="s" access="read">
+      <tp:docstring>
+        The machine hostname stored in persistent configuration.
+      </tp:docstring>
+    </property>
+
+    <property name="CanModify" type="b" access="read">
+      <tp:docstring>
+        If true, adding and modifying connections is supported.
+      </tp:docstring>
+    </property>
+
+    <signal name="PropertiesChanged">
+        <annotation name="org.qtproject.QtDBus.QtTypeName.In0" value="QVariantMap"/>
+        <arg name="properties" type="a{sv}" tp:type="String_Variant_Map">
+            <tp:docstring>
+                A dictionary mapping property names to variant boxed values
+            </tp:docstring>
+        </arg>
+    </signal>
+
+    <signal name="NewConnection">
+      <tp:docstring>
+        Emitted when a new connection has been added after NetworkManager has
+        started up and initialized.  This signal is not emitted for connections
+        read while starting up, because NetworkManager's D-Bus service is only
+        available after all connections have been read, and to prevent spamming
+        listeners with too many signals at one time.  To retrieve the initial
+        connection list, call the ListConnections() method once, and then listen
+        for individual Settings.NewConnection and Settings.Connection.Deleted
+        signals for further updates.
+      </tp:docstring>
+      <arg name="connection" type="o">
+        <tp:docstring>
+          Object path of the new connection.
+        </tp:docstring>
+      </arg>
+    </signal>
+
+    <signal name="ConnectionRemoved">
+      <tp:docstring>
+        Emitted when a connection is no longer available.  This happens when
+        the connection is deleted or if it is no longer accessible by any of
+        the system's logged-in users.  After receipt of this signal, the
+        connection no longer exists and cannot be used.  Also see the
+        Settings.Connection.Removed signal.
+      </tp:docstring>
+      <arg name="connection" type="o">
+        <tp:docstring>
+          Object path of the removed connection.
+        </tp:docstring>
+      </arg>
+    </signal>
+
+  </interface>
+</node>
+

=== modified file 'debian/changelog'
--- debian/changelog	2015-07-27 18:07:08 +0000
+++ debian/changelog	2015-07-28 08:25:09 +0000
@@ -1,3 +1,10 @@
+indicator-network (0.5.2-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Pete Woods ]
+  * Add hotspot management.
+
+ -- Pete Woods <[e-mail]>  Fri, 10 Jul 2015 15:44:04 +0100
+
 indicator-network (0.5.1+15.10.20150727-0ubuntu1) wily; urgency=medium
 
   [ CI Train Bot ]

=== modified file 'src/connectivity-api/connectivity-qt/connectivityqt/connectivity.cpp'
--- src/connectivity-api/connectivity-qt/connectivityqt/connectivity.cpp	2015-05-06 08:24:47 +0000
+++ src/connectivity-api/connectivity-qt/connectivityqt/connectivity.cpp	2015-07-28 08:25:09 +0000
@@ -45,6 +45,8 @@
 
     shared_ptr<internal::DBusPropertyCache> m_propertyCache;
 
+    shared_ptr<internal::DBusPropertyCache> m_writePropertyCache;
+
     shared_ptr<ComUbuntuConnectivity1NetworkingStatusInterface> m_readInterface;
 
     shared_ptr<ComUbuntuConnectivity1PrivateInterface> m_writeInterface;
@@ -85,6 +87,14 @@
     }
 
 public Q_SLOTS:
+    void interfaceInitialized()
+    {
+        // If both interfaces have been initialized then we're good to go
+        if (p.isInitialized())
+        {
+            Q_EMIT p.initialized();
+        }
+    }
 
     void propertyChanged(const QString& name, const QVariant& value)
     {
@@ -112,6 +122,26 @@
             Q_EMIT p.statusUpdated(status);
             Q_EMIT p.onlineUpdated(status == Status::Online);
         }
+        else if (name == "HotspotEnabled")
+        {
+            Q_EMIT p.hotspotEnabledUpdated(value.toBool());
+        }
+        else if (name == "HotspotSsid")
+        {
+            Q_EMIT p.hotspotSsidUpdated(value.toByteArray());
+        }
+        else if (name == "HotspotPassword")
+        {
+            Q_EMIT p.hotspotPasswordUpdated(value.toString());
+        }
+        else if (name == "HotspotMode")
+        {
+            Q_EMIT p.hotspotModeUpdated(value.toString());
+        }
+        else if (name == "HotspotStored")
+        {
+            Q_EMIT p.hotspotStoredUpdated(value.toBool());
+        }
     }
 };
 
@@ -136,6 +166,16 @@
             DBusTypes::DBUS_NAME, DBusTypes::PRIVATE_PATH,
             d->m_sessionConnection);
 
+    d->m_writePropertyCache = make_shared<internal::DBusPropertyCache>(
+                DBusTypes::DBUS_NAME, DBusTypes::PRIVATE_INTERFACE,
+                DBusTypes::PRIVATE_PATH, sessionConnection);
+    connect(d->m_writePropertyCache.get(),
+            &internal::DBusPropertyCache::propertyChanged, d.get(),
+            &Priv::propertyChanged);
+    connect(d->m_writePropertyCache.get(),
+            &internal::DBusPropertyCache::initialized, d.get(),
+            &Connectivity::Priv::interfaceInitialized);
+
     d->m_propertyCache = make_shared<internal::DBusPropertyCache>(
             DBusTypes::DBUS_NAME, DBusTypes::SERVICE_INTERFACE,
             DBusTypes::SERVICE_PATH, sessionConnection);
@@ -143,8 +183,12 @@
             &internal::DBusPropertyCache::propertyChanged, d.get(),
             &Priv::propertyChanged);
     connect(d->m_propertyCache.get(),
-            &internal::DBusPropertyCache::initialized, this,
-            &Connectivity::initialized);
+            &internal::DBusPropertyCache::initialized, d.get(),
+            &Connectivity::Priv::interfaceInitialized);
+
+    connect(d->m_writeInterface.get(),
+            &ComUbuntuConnectivity1PrivateInterface::ReportError, this,
+            &Connectivity::reportError);
 }
 
 Connectivity::~Connectivity()
@@ -188,7 +232,8 @@
 
 bool Connectivity::isInitialized() const
 {
-    return d->m_propertyCache->isInitialized();
+    return d->m_propertyCache->isInitialized()
+            && d->m_writePropertyCache->isInitialized();
 }
 
 void Connectivity::setFlightMode(bool enabled)
@@ -201,6 +246,51 @@
     d->m_writeInterface->SetWifiEnabled(enabled);
 }
 
+QByteArray Connectivity::hotspotSsid() const
+{
+    return d->m_propertyCache->get("HotspotSsid").toByteArray();
+}
+
+QString Connectivity::hotspotPassword() const
+{
+    return d->m_writePropertyCache->get("HotspotPassword").toString();
+}
+
+bool Connectivity::hotspotEnabled() const
+{
+    return d->m_propertyCache->get("HotspotEnabled").toBool();
+}
+
+QString Connectivity::hotspotMode() const
+{
+    return d->m_propertyCache->get("HotspotMode").toString();
+}
+
+bool Connectivity::hotspotStored() const
+{
+    return d->m_propertyCache->get("HotspotStored").toBool();
+}
+
+void Connectivity::setHotspotSsid(const QByteArray& ssid)
+{
+    d->m_writeInterface->SetHotspotSsid(ssid);
+}
+
+void Connectivity::setHotspotPassword(const QString& password)
+{
+    d->m_writeInterface->SetHotspotPassword(password);
+}
+
+void Connectivity::setHotspotEnabled(bool enabled)
+{
+    d->m_writeInterface->SetHotspotEnabled(enabled);
+}
+
+void Connectivity::setHotspotMode(const QString& mode)
+{
+    d->m_writeInterface->SetHotspotMode(mode);
+}
+
 }
 
 #include "connectivity.moc"

=== modified file 'src/connectivity-api/connectivity-qt/connectivityqt/connectivity.h'
--- src/connectivity-api/connectivity-qt/connectivityqt/connectivity.h	2015-05-06 08:24:47 +0000
+++ src/connectivity-api/connectivity-qt/connectivityqt/connectivity.h	2015-07-28 08:25:09 +0000
@@ -94,6 +94,21 @@
     Q_PROPERTY(bool UnstoppableOperationHappening READ unstoppableOperationHappening NOTIFY unstoppableOperationHappeningUpdated)
     bool unstoppableOperationHappening() const;
 
+    Q_PROPERTY(QByteArray hotspotSsid READ hotspotSsid WRITE setHotspotSsid NOTIFY hotspotSsidUpdated)
+    QByteArray hotspotSsid() const;
+
+    Q_PROPERTY(QString hotspotPassword READ hotspotPassword WRITE setHotspotPassword NOTIFY hotspotPasswordUpdated)
+    QString hotspotPassword() const;
+
+    Q_PROPERTY(bool hotspotEnabled READ hotspotEnabled WRITE setHotspotEnabled NOTIFY hotspotEnabledUpdated)
+    bool hotspotEnabled() const;
+
+    Q_PROPERTY(QString hotspotMode READ hotspotMode WRITE setHotspotMode NOTIFY hotspotModeUpdated)
+    QString hotspotMode() const;
+
+    Q_PROPERTY(bool hotspotStored READ hotspotStored NOTIFY hotspotStoredUpdated)
+    bool hotspotStored() const;
+
     Q_PROPERTY(bool Initialized READ isInitialized NOTIFY initialized)
     bool isInitialized() const;
 
@@ -102,6 +117,14 @@
 
     void setwifiEnabled(bool enabled);
 
+    void setHotspotEnabled(bool active);
+
+    void setHotspotSsid(const QByteArray& ssid);
+
+    void setHotspotPassword(const QString& password);
+
+    void setHotspotMode(const QString& mode);
+
 Q_SIGNALS:
     void flightModeUpdated(bool);
 
@@ -117,6 +140,18 @@
 
     void unstoppableOperationHappeningUpdated(bool);
 
+    void hotspotSsidUpdated(const QByteArray& name);
+
+    void hotspotPasswordUpdated(const QString& password);
+
+    void hotspotEnabledUpdated(bool);
+
+    void hotspotModeUpdated(const QString& mode);
+
+    void hotspotStoredUpdated(bool);
+
+    void reportError(int reason);
+
     void initialized();
 
 protected:

=== modified file 'src/indicator/CMakeLists.txt'
--- src/indicator/CMakeLists.txt	2015-05-12 09:07:46 +0000
+++ src/indicator/CMakeLists.txt	2015-07-28 08:25:09 +0000
@@ -26,6 +26,7 @@
 set(NETWORK_SERVICE_SOURCES
     ${NETWORK_SERVICE_HEADERS}
 
+    nmofono/hotspot-manager.cpp
     nmofono/kill-switch.cpp
     nmofono/manager.cpp
     nmofono/manager-impl.cpp

=== modified file 'src/indicator/connectivity-service/connectivity-service.cpp'
--- src/indicator/connectivity-service/connectivity-service.cpp	2015-05-06 08:24:47 +0000
+++ src/indicator/connectivity-service/connectivity-service.cpp	2015-07-28 08:25:09 +0000
@@ -49,7 +49,8 @@
     {
     }
 
-    void notifyPropertyChanged( const QString& path,
+    void notifyPropertyChanged( const QObject& o,
+                                const QString& path,
                                 const QString& interface,
                                 const QStringList& propertyNames )
     {
@@ -61,7 +62,7 @@
         QVariantMap changedProps;
         for(const auto& propertyName: propertyNames)
         {
-            changedProps.insert(propertyName, p.property(qPrintable(propertyName)));
+            changedProps.insert(propertyName, o.property(qPrintable(propertyName)));
         }
         signal << changedProps;
         signal << QStringList();
@@ -71,25 +72,69 @@
 public Q_SLOTS:
     void flightModeUpdated()
     {
-        notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
                               DBusTypes::SERVICE_INTERFACE,
                               { "FlightMode" });
     }
 
     void wifiEnabledUpdated()
     {
-        notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
                               DBusTypes::SERVICE_INTERFACE,
                               { "WifiEnabled" });
     }
 
     void unstoppableOperationHappeningUpdated()
     {
-        notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
                               DBusTypes::SERVICE_INTERFACE,
                               { "UnstoppableOperationHappening" });
     }
 
+    void hotspotSsidUpdated()
+    {
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "HotspotSsid" });
+    }
+
+    void hotspotEnabledUpdated()
+    {
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "HotspotEnabled" });
+    }
+
+    void hotspotPasswordUpdated()
+    {
+        // Note that this is on the private object
+        notifyPropertyChanged(*m_privateService,
+                              DBusTypes::PRIVATE_PATH,
+                              DBusTypes::PRIVATE_INTERFACE,
+                              { "HotspotPassword" });
+    }
+
+    void hotspotModeUpdated()
+    {
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "HotspotMode" });
+    }
+
+    void hotspotStoredUpdated()
+    {
+        notifyPropertyChanged(p,
+                              DBusTypes::SERVICE_PATH,
+                              DBusTypes::SERVICE_INTERFACE,
+                              { "HotspotStored" });
+    }
+
     void updateNetworkingStatus()
     {
         QStringList changed;
@@ -129,7 +174,8 @@
 
         if (!changed.empty())
         {
-            notifyPropertyChanged(DBusTypes::SERVICE_PATH,
+            notifyPropertyChanged(p,
+                                  DBusTypes::SERVICE_PATH,
                                   DBusTypes::SERVICE_INTERFACE,
                                   changed);
         }
@@ -151,6 +197,15 @@
     connect(d->m_manager.get(), &Manager::wifiEnabledUpdated, d.get(), &Private::wifiEnabledUpdated);
     connect(d->m_manager.get(), &Manager::unstoppableOperationHappeningUpdated, d.get(), &Private::unstoppableOperationHappeningUpdated);
 
+    auto hotspotManager = d->m_manager->hotspotManager();
+    connect(hotspotManager.get(), &HotspotManager::enabledChanged, d.get(), &Private::hotspotEnabledUpdated);
+    connect(hotspotManager.get(), &HotspotManager::ssidChanged, d.get(), &Private::hotspotSsidUpdated);
+    connect(hotspotManager.get(), &HotspotManager::passwordChanged, d.get(), &Private::hotspotPasswordUpdated);
+    connect(hotspotManager.get(), &HotspotManager::modeChanged, d.get(), &Private::hotspotModeUpdated);
+    connect(hotspotManager.get(), &HotspotManager::storedChanged, d.get(), &Private::hotspotStoredUpdated);
+
+    connect(hotspotManager.get(), &HotspotManager::reportError, d->m_privateService.get(), &PrivateService::ReportError);
+
     d->updateNetworkingStatus();
 
     if (!d->m_connection.registerObject(DBusTypes::SERVICE_PATH, this))
@@ -200,6 +255,26 @@
     return d->m_manager->unstoppableOperationHappening();
 }
 
+bool ConnectivityService::hotspotEnabled() const
+{
+    return d->m_manager->hotspotManager()->enabled();
+}
+
+QByteArray ConnectivityService::hotspotSsid() const
+{
+    return d->m_manager->hotspotManager()->ssid();
+}
+
+QString ConnectivityService::hotspotMode() const
+{
+    return d->m_manager->hotspotManager()->mode();
+}
+
+bool ConnectivityService::hotspotStored() const
+{
+    return d->m_manager->hotspotManager()->stored();
+}
+
 PrivateService::PrivateService(ConnectivityService& parent) :
         p(parent)
 {
@@ -227,6 +302,31 @@
     p.d->m_manager->setWifiEnabled(enabled);
 }
 
+void PrivateService::SetHotspotEnabled(bool enabled)
+{
+    p.d->m_manager->hotspotManager()->setEnabled(enabled);
+}
+
+void PrivateService::SetHotspotSsid(const QByteArray &ssid)
+{
+    p.d->m_manager->hotspotManager()->setSsid(ssid);
+}
+
+void PrivateService::SetHotspotPassword(const QString &password)
+{
+    p.d->m_manager->hotspotManager()->setPassword(password);
+}
+
+void PrivateService::SetHotspotMode(const QString &mode)
+{
+    p.d->m_manager->hotspotManager()->setMode(mode);
+}
+
+QString PrivateService::hotspotPassword() const
+{
+    return p.d->m_manager->hotspotManager()->password();
+}
+
 }
 
 #include "connectivity-service.moc"

=== modified file 'src/indicator/connectivity-service/connectivity-service.h'
--- src/indicator/connectivity-service/connectivity-service.h	2015-04-23 10:02:23 +0000
+++ src/indicator/connectivity-service/connectivity-service.h	2015-07-28 08:25:09 +0000
@@ -59,6 +59,18 @@
     Q_PROPERTY(bool UnstoppableOperationHappening READ unstoppableOperationHappening)
     bool unstoppableOperationHappening() const;
 
+    Q_PROPERTY(bool HotspotEnabled READ hotspotEnabled)
+    bool hotspotEnabled() const;
+
+    Q_PROPERTY(QByteArray HotspotSsid READ hotspotSsid)
+    QByteArray hotspotSsid() const;
+
+    Q_PROPERTY(bool HotspotStored READ hotspotStored)
+    bool hotspotStored() const;
+
+    Q_PROPERTY(QString HotspotMode READ hotspotMode)
+    QString hotspotMode() const;
+
 Q_SIGNALS:
     void unlockAllModems();
 
@@ -80,6 +92,9 @@
 
     ~PrivateService() = default;
 
+    Q_PROPERTY(QString HotspotPassword READ hotspotPassword)
+    QString hotspotPassword() const;
+
 protected Q_SLOTS:
     void UnlockAllModems();
 
@@ -89,6 +104,17 @@
 
     void SetWifiEnabled(bool enabled);
 
+    void SetHotspotEnabled(bool enabled);
+
+    void SetHotspotSsid(const QByteArray &ssid);
+
+    void SetHotspotPassword(const QString &password);
+
+    void SetHotspotMode(const QString &mode);
+
+Q_SIGNALS:
+    void ReportError(int reason);
+
 protected:
     ConnectivityService& p;
 };

=== added file 'src/indicator/nmofono/hotspot-manager.cpp'
--- src/indicator/nmofono/hotspot-manager.cpp	1970-01-01 00:00:00 +0000
+++ src/indicator/nmofono/hotspot-manager.cpp	2015-07-28 08:25:09 +0000
@@ -0,0 +1,826 @@
+/*
+ * Copyright (C) 2014, 2015 Canonical, Ltd.
+ *
+ * Authors:
+ *    Jussi Pakkanen <[e-mail]>
+ *    Jonas G. Drange <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <nmofono/hotspot-manager.h>
+#include <NetworkManagerActiveConnectionInterface.h>
+#include <NetworkManagerDeviceInterface.h>
+#include <NetworkManagerInterface.h>
+#include <NetworkManagerSettingsInterface.h>
+#include <NetworkManagerSettingsConnectionInterface.h>
+#include <URfkillInterface.h>
+
+#include <QStringList>
+#include <QDBusReply>
+#include <QtDebug>
+#include <QDBusInterface>
+#include <QDBusMetaType>
+#include <NetworkManager.h>
+
+using namespace std;
+
+namespace
+{
+const static QString wpa_supplicant_service = "fi.w1.wpa_supplicant1";
+const static QString wpa_supplicant_interface = "fi.w1.wpa_supplicant1";
+const static QString wpa_supplicant_path = "/fi/w1/wpa_supplicant1";
+}
+
+class HotspotManager::Priv: public QObject
+{
+    Q_SLOTS
+public:
+    Priv(HotspotManager& parent) :
+        p(parent)
+    {
+    }
+
+    /**
+     * Disables a hotspot.
+     */
+    void disable()
+    {
+        getHotspot();
+        if (!m_hotspot)
+        {
+            qWarning() << "Could not find a hotspot setup to disable.\n";
+            return;
+        }
+
+        // Get new settings
+        QVariantDictMap new_settings = createConnectionSettings(m_ssid,
+                                                                m_password,
+                                                                m_device_path,
+                                                                m_mode, false);
+        auto updating = m_hotspot->Update(new_settings);
+        updating.waitForFinished();
+        if (!updating.isValid())
+        {
+            qCritical()
+                    << "Could not update connection with autoconnect=false: "
+                    << updating.error().message();
+        }
+
+        auto active_connections = m_manager->activeConnections();
+        for (const auto &active_connection : active_connections)
+        {
+            OrgFreedesktopNetworkManagerConnectionActiveInterface iface(
+                    NM_DBUS_SERVICE, active_connection.path(),
+                    m_manager->connection());
+
+            // Cast the property to a object path.
+            QDBusObjectPath backingConnection = iface.connection();
+
+            // This active connection's Connection property was our hotspot,
+            // so we will deactivate it. Note that we do not remove the hotspot,
+            // as we are storing the ssid, password and mode on the connection.
+            if (backingConnection.path() == m_hotspot->path())
+            {
+                // Deactivate the connection.
+                auto deactivation = m_manager->DeactivateConnection(
+                        active_connection);
+                deactivation.waitForFinished();
+                if (!deactivation.isValid())
+                {
+                    qCritical() << "Could not get deactivate connection: "
+                            << deactivation.error().message();
+                }
+                return;
+            }
+        }
+    }
+
+    bool destroy()
+    {
+        if (!m_hotspot)
+        {
+            qCritical() << __PRETTY_FUNCTION__ << "Failed to destroy hotspot because it didn't exist";
+            return false;
+        }
+
+        // Subscribe to the connection proxy's Removed signal.
+        connect(m_hotspot.get(),
+                &OrgFreedesktopNetworkManagerSettingsConnectionInterface::Removed,
+                this, &Priv::onRemoved);
+
+        auto del = m_hotspot->Delete();
+        del.waitForFinished();
+        if (del.isError())
+        {
+            qWarning() << __PRETTY_FUNCTION__ << "Failed to delete connection:" << del.error().message();
+    }
+        return !del.isError();
+    }
+
+    void setStored(bool value)
+    {
+        if (m_stored != value)
+        {
+            m_stored = value;
+            Q_EMIT p.storedChanged(value);
+        }
+    }
+
+    void setEnable(bool value)
+    {
+        if (m_enabled != value)
+        {
+            m_enabled = value;
+            Q_EMIT p.enabledChanged(value);
+        }
+    }
+
+    void updateSettingsFromDbus()
+    {
+        bool active = isHotspotActive();
+        setEnable(active);
+
+        QVariantDictMap settings = getConnectionSettings(*m_hotspot);
+        const char wifi_key[] = "802-11-wireless";
+        const char security_key[] = "802-11-wireless-security";
+
+        if (settings.find(wifi_key) != settings.end())
+        {
+            QByteArray ssid = settings[wifi_key]["ssid"].toByteArray();
+            if (!ssid.isEmpty())
+            {
+                p.setSsid(ssid);
+            }
+
+            QString mode = settings[wifi_key]["mode"].toString();
+            if (!mode.isEmpty())
+            {
+                p.setMode(mode);
+            }
+        }
+
+        QVariantDictMap secrets = getConnectionSecrets(*m_hotspot,
+                                                       security_key);
+
+        if (secrets.find(security_key) != secrets.end())
+        {
+            QString pwd = secrets[security_key]["psk"].toString();
+            if (!pwd.isEmpty())
+            {
+                p.setPassword(pwd);
+            }
+        }
+    }
+
+    // wpa_supplicant interaction
+
+    bool isHybrisWlan()
+    {
+        QString program("getprop");
+        QStringList arguments;
+        arguments << "urfkill.hybris.wlan";
+
+        QProcess *getprop = new QProcess();
+        getprop->start(program, arguments);
+
+        if (!getprop->waitForFinished())
+        {
+            qCritical() << "getprop process failed:" << getprop->errorString();
+            delete getprop;
+            return false;
+        }
+
+        int index = getprop->readAllStandardOutput().indexOf("1");
+        delete getprop;
+
+        // A non-negative integer means getprop returned 1
+        return index >= 0;
+    }
+
+    /**
+     * True if changed successfully, or there was no need. Otherwise false.
+     * Supported modes are 'p2p', 'sta' and 'ap'.
+     */
+    bool changeInterfaceFirmware(const QString& interface, const QString& mode)
+    {
+        // Not supported.
+        if (mode == "adhoc")
+        {
+            return true;
+        }
+
+        if (isHybrisWlan())
+        {
+            QDBusInterface wpasIface(wpa_supplicant_service,
+                                     wpa_supplicant_path,
+                                     wpa_supplicant_interface,
+                                     m_manager->connection());
+
+            const QDBusObjectPath interface_path(interface);
+
+            // TODO(jgdx): We need to guard against calling this
+            // when the interface is not soft blocked.
+            auto set_interface = wpasIface.call(
+                    "SetInterfaceFirmware", QVariant::fromValue(interface_path),
+                    QVariant(mode));
+
+            if (set_interface.type() == QDBusMessage::ErrorMessage)
+            {
+                qCritical() << "Failed to change interface firmware:"
+                        << set_interface.errorMessage();
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        // We had no need to change the firmware.
+        return true;
+    }
+
+    // wpa_supplicant interaction
+
+    // UrfKill interaction
+
+    /*
+     * True if call went through and returned true.
+     */
+    bool setWifiBlock(bool block)
+    {
+        OrgFreedesktopURfkillInterface urfkill_dbus_interface(
+                DBusTypes::URFKILL_BUS_NAME, DBusTypes::URFKILL_OBJ_PATH,
+                m_manager->connection());
+
+        const unsigned int device_type = 1; /* wifi type */
+        auto reply = urfkill_dbus_interface.Block(device_type, block);
+        reply.waitForFinished();
+
+        if (reply.isError())
+        {
+            qCritical() << "Failed to block wifi" << reply.error().message();
+            return false;
+        }
+
+        if (!reply)
+        {
+            qCritical() << "URfkill Block call did not succeed";
+        }
+
+        return reply;
+    }
+
+    // UrfKill interaction
+
+    /**
+     * Helper that maps QStrings to other QVariantMaps, i.e.
+     * QMap<QString, QVariantMap>. QVariantMap is an alias for
+     * QMap<QString, QVariant>.
+     * See http://doc.qt.io/qt-5/qvariant.html#QVariantMap-typedef and
+     * https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #type-String_String_Variant_Map_Map
+     */
+    QVariantDictMap createConnectionSettings(
+        const QByteArray &ssid, const QString &password,
+        const QDBusObjectPath &devicePath, QString mode, bool autoConnect = true)
+    {
+        Q_UNUSED(devicePath);
+        QVariantDictMap connection;
+
+        QString s_ssid = QString::fromLatin1(ssid);
+        QString s_uuid = QUuid().createUuid().toString();
+        // Remove {} from the generated uuid.
+        s_uuid.remove(0, 1);
+        s_uuid.remove(s_uuid.size() - 1, 1);
+
+        QVariantMap wireless;
+        wireless[QStringLiteral("security")] = QVariant(QStringLiteral("802-11-wireless-security"));
+        wireless[QStringLiteral("ssid")] = QVariant(ssid);
+        wireless[QStringLiteral("mode")] = QVariant(mode);
+
+        connection["802-11-wireless"] = wireless;
+
+        QVariantMap connsettings;
+        connsettings[QStringLiteral("autoconnect")] = QVariant(autoConnect);
+        connsettings[QStringLiteral("id")] = QVariant(s_ssid);
+        connsettings[QStringLiteral("uuid")] = QVariant(s_uuid);
+        connsettings[QStringLiteral("type")] = QVariant(QStringLiteral("802-11-wireless"));
+        connection["connection"] = connsettings;
+
+        QVariantMap ipv4;
+        ipv4[QStringLiteral("addressess")] = QVariant(QStringList());
+        ipv4[QStringLiteral("dns")] = QVariant(QStringList());
+        ipv4[QStringLiteral("method")] = QVariant(QStringLiteral("shared"));
+        ipv4[QStringLiteral("routes")] = QVariant(QStringList());
+        connection["ipv4"] = ipv4;
+
+        QVariantMap ipv6;
+        ipv6[QStringLiteral("method")] = QVariant(QStringLiteral("ignore"));
+        connection["ipv6"] = ipv6;
+
+        QVariantMap security;
+        security[QStringLiteral("proto")] = QVariant(QStringList{ "rsn" });
+        security[QStringLiteral("pairwise")] = QVariant(QStringList{ "ccmp" });
+        security[QStringLiteral("group")] = QVariant(QStringList{ "ccmp" });
+        security[QStringLiteral("key-mgmt")] = QVariant(QStringLiteral("wpa-psk"));
+        security[QStringLiteral("psk")] = QVariant(password);
+        connection["802-11-wireless-security"] = security;
+
+        return connection;
+    }
+
+    /**
+     * Helper that returns a QMap<QString, QVariantMap> given a QDBusObjectPath.
+     * See https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager.Settings.Connection.GetSettings
+     */
+    QVariantDictMap getConnectionSettings (OrgFreedesktopNetworkManagerSettingsConnectionInterface& conn) {
+        auto connection_settings = conn.GetSettings();
+        connection_settings.waitForFinished();
+        return connection_settings.value();
+    }
+
+
+    /**
+     * Helper that returns a QMap<QString, QVariantMap> given a QDBusObjectPath.
+     * See https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager.Settings.Connection.GetSettings
+     */
+    QVariantDictMap getConnectionSecrets (OrgFreedesktopNetworkManagerSettingsConnectionInterface& conn,
+        const QString key)
+    {
+        auto connection_secrets = conn.GetSecrets(key);
+        connection_secrets.waitForFinished();
+        return connection_secrets.value();
+    }
+
+    /**
+     * Helper that adds a connection and returns the QDBusObjectPath
+     * of the newly created connection.
+     * See https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager.Settings.AddConnection
+     */
+    void addConnection()
+    {
+        QVariantDictMap connection = createConnectionSettings(m_ssid, m_password,
+                                                              m_device_path, m_mode);
+
+        auto add_connection_reply = m_settings->AddConnection(connection);
+        add_connection_reply.waitForFinished();
+
+        if (add_connection_reply.isError())
+        {
+            qCritical() << "Failed to add connection: "
+                    << add_connection_reply.error().message();
+            m_hotspot.reset();
+            return;
+        }
+        QDBusObjectPath connectionPath(add_connection_reply);
+
+        m_hotspot = make_shared<
+                OrgFreedesktopNetworkManagerSettingsConnectionInterface>(
+                NM_DBUS_SERVICE, connectionPath.path(), m_manager->connection());
+    }
+
+    /**
+     * Returns a QDBusObjectPath of a hotspot given a mode.
+     * Valid modes are 'p2p', 'ap' and 'adhoc'.
+     */
+    void getHotspot()
+    {
+        const char wifi_key[] = "802-11-wireless";
+
+        auto listed_connections = m_settings->ListConnections();
+        listed_connections.waitForFinished();
+
+        for (const auto &connection : listed_connections.value())
+        {
+            auto conn = make_shared<OrgFreedesktopNetworkManagerSettingsConnectionInterface>(
+                    NM_DBUS_SERVICE, connection.path(),
+                    m_manager->connection());
+
+            auto connection_settings = getConnectionSettings(*conn);
+
+            if (connection_settings.find(wifi_key) != connection_settings.end())
+            {
+                auto wifi_setup = connection_settings[wifi_key];
+                QString wifi_mode = wifi_setup["mode"].toString();
+
+                if (wifi_mode == m_mode)
+                {
+                    m_hotspot = conn;
+                    return;
+                }
+            }
+        }
+        m_hotspot.reset();
+    }
+
+    /**
+     * Returns a QDBusObjectPath of a wireless device. For now
+     * it returns the first device.
+     */
+    void getWirelessDevice ()
+    {
+        // find the first wlan adapter for now
+        auto reply1 = m_manager->GetDevices();
+        reply1.waitForFinished();
+
+        if(!reply1.isValid()) {
+            qCritical() << "Could not get network device: "
+                << reply1.error().message();
+            m_device_path = QDBusObjectPath();
+            return;
+        }
+        auto devices = reply1.value();
+
+        QDBusObjectPath dev;
+        for (const auto &d : devices) {
+            OrgFreedesktopNetworkManagerDeviceInterface iface(NM_DBUS_SERVICE, d.path(), m_manager->connection());
+            auto type_v = iface.deviceType();
+
+            if (type_v == NM_DEVICE_TYPE_WIFI)
+            {
+                m_device_path = d;
+                return;
+            }
+        }
+        qCritical() << "Wireless device not found, hotspot functionality is inoperative.";
+        m_device_path = dev;
+    }
+
+    /**
+     * Helper to check if the hotspot on a given QDBusObjectPath is active
+     * or not. It checks if the Connection.Active [1] for the given
+     * path is in NetworkManager's ActiveConnections property [2].
+     * [1] https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager.Connection.Active
+     * [2] https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager
+     */
+    bool isHotspotActive ()
+    {
+        if (!m_hotspot)
+        {
+            return false;
+        }
+
+        QSet<QDBusObjectPath> active_relevant_connections;
+        auto active_connections = m_manager->activeConnections();
+        for (const auto &active_connection : active_connections)
+        {
+
+            // Active connection interface proxy. It might have a connection
+            // property we can use to deduce if this active connection represents
+            // our active hotspot.
+            OrgFreedesktopNetworkManagerConnectionActiveInterface active_connection_dbus_interface(
+                    NM_DBUS_SERVICE, active_connection.path(),
+                    m_manager->connection());
+
+            // Get the Connection property, if any.
+            auto connection_path =
+                    active_connection_dbus_interface.connection();
+
+            // The object path is the same as the given hotspot path.
+            if (m_hotspot->path() == connection_path.path())
+            {
+                return true;
+            }
+        }
+
+        // No active connection had a Connection property equal to the
+        // given path, so return false.
+        return false;
+    }
+
+    void generatePassword()
+    {
+        static const std::string items("abcdefghijklmnopqrstuvwxyz01234567890");
+        const int password_length = 8;
+        std::string result;
+
+        for (int i = 0; i < password_length; i++)
+        {
+            result.push_back(items[std::rand() % items.length()]);
+        }
+
+        m_password = QString::fromStdString(result);
+    }
+
+public Q_SLOTS:
+    void onNewConnection(const QDBusObjectPath& path)
+    {
+        if (!m_hotspot)
+        {
+            return;
+        }
+
+        // The new connection is the same as the stored hotspot path.
+        if (path.path() == m_hotspot->path())
+        {
+            // If a new hotspot was added, it is also given that
+            // Wi-Fi has been soft blocked. We can now unblock Wi-Fi
+            // and let NetworkManager pick up the newly created
+            // connection.
+            bool unblocked = setWifiBlock(false);
+            if (!unblocked)
+            {
+                // "The device could not be readied for configuration"
+                Q_EMIT p.reportError(5);
+            }
+            else
+            {
+                // We successfully unblocked the Wi-Fi, so set m_enable to true.
+                setEnable(true);
+            }
+
+            // This also mean we have successfully created a hotspot connection
+            // object in NetworkManager, so m_stored should now be true.
+            setStored(true);
+        }
+    }
+
+
+    void onRemoved()
+    {
+        m_hotspot.reset();
+
+        // The UI does not support direct deletion of a hotspot, and given how
+        // hotspots currently work, every time we want to re-use a hotspot, we
+        // delete it an add a new one.
+        // Thus, if a hotspot was deleted, we now create a new one.
+        addConnection();
+
+        // We could not add a connection, so report, disable and unblock.
+        if (!m_hotspot)
+        {
+            qWarning() << __PRETTY_FUNCTION__ << "  Adding connection failed";
+            // Emit "Unknown Error".
+            Q_EMIT p.reportError(0);
+            setEnable(false);
+            setWifiBlock(false);
+        }
+    }
+
+    void onPropertiesChanged(const QVariantMap& properties)
+    {
+        // If we have no hotspot path, ignore changes in NetworkManager.
+        if (!m_hotspot)
+        {
+            return;
+        }
+
+        // Set flag so we know that ActiveConnections changed.
+        bool active_connection_changed = false;
+
+        for (QVariantMap::const_iterator iter = properties.begin();
+                iter != properties.end(); ++iter)
+        {
+            if (iter.key() == "ActiveConnections")
+            {
+                active_connection_changed = true;
+
+                const QDBusArgument args = qvariant_cast<QDBusArgument>(
+                        iter.value());
+                if (args.currentType() == QDBusArgument::ArrayType)
+                {
+                    args.beginArray();
+
+                    while (!args.atEnd())
+                    {
+                        QDBusObjectPath path = qdbus_cast<QDBusObjectPath>(
+                                args);
+
+                        OrgFreedesktopNetworkManagerConnectionActiveInterface active_connection_dbus_interface(
+                                NM_DBUS_SERVICE, path.path(),
+                                m_manager->connection());
+
+                        QDBusObjectPath connection_path =
+                                active_connection_dbus_interface.connection();
+
+                        // We see our connection as being active, so we emit that is
+                        // enabled and return.
+                        if (connection_path.path() == m_hotspot->path())
+                        {
+                            setEnable(true);
+                            return;
+                        }
+                    }
+                    args.endArray();
+                }
+            }
+        }
+
+        // At this point ActiveConnections changed, but
+        // our hotspot was not in that list.
+        if (active_connection_changed)
+        {
+            setEnable(false);
+        }
+    }
+
+    // NetworkManager interaction
+
+public:
+    HotspotManager& p;
+
+    QString m_mode = "ap";
+    bool m_enabled = false;
+    bool m_stored = false;
+    QString m_password;
+    QByteArray m_ssid = "Ubuntu";
+
+    QDBusObjectPath m_device_path;
+
+    /**
+     * NetworkManager dbus interface proxy we will use to query
+     * against NetworkManager. See
+     * https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager
+     */
+    unique_ptr<OrgFreedesktopNetworkManagerInterface> m_manager;
+
+    /**
+     * NetworkManager Settings interface proxy we use to get
+     * the list of connections, as well as adding connections.
+     * See https://developer.gnome.org/NetworkManager/0.9/spec.html
+     *     #org.freedesktop.NetworkManager.Settings
+     */
+    unique_ptr<OrgFreedesktopNetworkManagerSettingsInterface> m_settings;
+
+    shared_ptr<OrgFreedesktopNetworkManagerSettingsConnectionInterface> m_hotspot;
+};
+
+HotspotManager::HotspotManager(const QDBusConnection& connection, QObject *parent) :
+        QObject(parent), d(new Priv(*this))
+{
+    d->m_manager = make_unique<OrgFreedesktopNetworkManagerInterface>(
+            NM_DBUS_SERVICE, NM_DBUS_PATH, connection);
+    d->m_settings = make_unique<OrgFreedesktopNetworkManagerSettingsInterface>(
+            NM_DBUS_SERVICE, NM_DBUS_PATH_SETTINGS, connection);
+
+    d->generatePassword();
+    d->getWirelessDevice();
+
+    // Stored is false if hotspot path is empty.
+    d->getHotspot();
+    d->setStored(bool(d->m_hotspot));
+
+    if (d->m_stored)
+    {
+        d->updateSettingsFromDbus();
+    }
+
+    // Watches for new connections added to NetworkManager's Settings
+    // interface.
+    connect(d->m_settings.get(),
+            &OrgFreedesktopNetworkManagerSettingsInterface::NewConnection,
+            d.get(), &Priv::onNewConnection);
+
+    // Watches changes in NetworkManager
+    connect(d->m_manager.get(),
+            &OrgFreedesktopNetworkManagerInterface::PropertiesChanged, d.get(),
+            &Priv::onPropertiesChanged);
+}
+
+void HotspotManager::setEnabled(bool value)
+{
+    if (enabled() == value)
+    {
+        return;
+    }
+
+    bool blocked = d->setWifiBlock(true);
+
+    // Failed to soft block, here we revert the enabled setting.
+    if (!blocked)
+    {
+        // "The device could not be readied for configuration"
+        Q_EMIT reportError(5);
+        d->setEnable(false);
+        return;
+    }
+
+    // We are enabling a hotspot
+    if (value)
+    {
+        // If the SSID is empty, we report an error.
+        if (d->m_ssid.isEmpty())
+        {
+            qWarning() << __PRETTY_FUNCTION__ << "  SSID was empty";
+            Q_EMIT reportError(1);
+            d->setEnable(false);
+            return;
+        }
+
+        bool changed = d->changeInterfaceFirmware("/", d->m_mode);
+        if (!changed)
+        {
+            // Necessary firmware for the device may be missing
+            qWarning() << __PRETTY_FUNCTION__ << "  Could not change interface firmware";
+            Q_EMIT reportError(35);
+            d->setEnable(false);
+            d->setWifiBlock(false);
+            return;
+        }
+
+        if (d->m_stored)
+        {
+            // we defer enabling until old hotspot is deleted
+            // if we can delete the old one
+            // If not, unset stored flag and call this method.
+            if (!d->destroy())
+            {
+                d->setStored(false);
+                // recurse?
+                setEnabled(true);
+                d->setEnable(true);
+            }
+        }
+        else
+        {
+            // we defer enabling until new hotspot is created
+            d->addConnection();
+            if (!d->m_hotspot)
+            {
+                // Emit "Unknown Error".
+                qWarning() << __PRETTY_FUNCTION__ << "  Could not create hotspot connection";
+                Q_EMIT reportError(0);
+                d->setEnable(false);
+                d->setWifiBlock(false);
+            }
+        }
+
+    }
+    else
+    {
+        // Disabling the hotspot.
+        d->disable();
+        d->setEnable(false);
+
+        bool unblocked = d->setWifiBlock(false);
+        if (!unblocked)
+        {
+            qWarning() << __PRETTY_FUNCTION__ << "  Could not unblock WiFi";
+            // "The device could not be readied for configuration"
+            Q_EMIT reportError(5);
+        }
+    }
+
+}
+
+bool HotspotManager::enabled() const {
+    return d->m_enabled;
+}
+
+bool HotspotManager::stored() const {
+    return d->m_stored;
+}
+
+QByteArray HotspotManager::ssid() const {
+    return d->m_ssid;
+}
+
+void HotspotManager::setSsid(const QByteArray& value) {
+    if (d->m_ssid != value)
+    {
+        d->m_ssid = value;
+        Q_EMIT ssidChanged(value);
+    }
+}
+
+QString HotspotManager::password() const {
+    return d->m_password;
+}
+
+void HotspotManager::setPassword(const QString& value) {
+    if (d->m_password != value)
+    {
+        d->m_password = value;
+        Q_EMIT passwordChanged(value);
+    }
+}
+
+QString HotspotManager::mode() const {
+    return d->m_mode;
+}
+
+void HotspotManager::setMode(const QString& value) {
+    if (d->m_mode != value)
+    {
+        d->m_mode = value;
+        Q_EMIT modeChanged(value);
+    }
+}

=== added file 'src/indicator/nmofono/hotspot-manager.h'
--- src/indicator/nmofono/hotspot-manager.h	1970-01-01 00:00:00 +0000
+++ src/indicator/nmofono/hotspot-manager.h	2015-07-28 08:25:09 +0000
@@ -0,0 +1,167 @@
+/*
+ * Copyright (C) 2014, 2015 Canonical, Ltd.
+ *
+ * Authors:
+ *    Jussi Pakkanen <[e-mail]>
+ *    Jonas G. Drange <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include <QObject>
+#include <QDBusConnection>
+#include <memory>
+
+ /**
+ * HotspotManager API
+ * ==============================
+ *
+ * Methods
+ *
+ * Signals
+ *   enabledChanged(bool enabled)
+ *     Signal that gets emitted when the hotspot is disabled or enabled.
+ *
+ *   storedChanged(bool stored)
+ *     Signal that gets emitted when a hotspot was stored.
+ *
+ *   ssidChanged(QByteArray ssid)
+ *     Signal that gets emitted when the ssid of the hotspot was changed.
+ *
+ *   passwordChanged(QString password)
+ *     Signal that gets emitted when the password of the hotspot was changed.
+ *
+ *   modeChanged(QString mode)
+ *     Signal that gets emitted when the mode was changed.
+ *
+ *   authChanged(QString auth)
+ *
+ *   Note that none of these signal will be emitted if a change to the hotspot
+ *   was made by anyone else than the HotspotManager. Right now, the canonical
+ *   way to edit a hotspot, is through the hotspot manager.
+ *
+ *
+ *   reportError(int reason)
+ *     The reasons correspond to https://developer.gnome.org/
+ *         NetworkManager/0.9/spec.html#type-NM_DEVICE_STATE_REASON
+ *
+ * Properties
+ *   bool enabled [readwrite]
+ *     Whether or not the hotspot is enabled.
+ *
+ *   bool stored [readonly]
+ *     Whether or not a hotspot is known to the hotspotmanager.
+ *
+ *   QByteArray ssid [readwrite]
+ *     The current SSID of the hotspot.
+ *
+ *   QString auth [readwrite]
+ *     The current authentication of the hotspot. The default for this property
+ *     is "wpa-psk" and is currently the only supported scheme. WEP is unsupported
+ *     by design, as is no scheme at all.
+ *
+ *     TODO: Check/add support for wpa-eap
+ *
+ *   QString password [readwrite]
+ *     The current Pre-Shared-Key for the hotspot. If the key is 64-characters
+ *     long, it must contain only hexadecimal characters and is interpreted as a
+ *     hexadecimal WPA key. Otherwise, the key must be between 8 and 63 ASCII
+ *     characters and is interpreted as a WPA passphrase.
+ *
+ *   QString mode [readwrite, optional]
+ *     The current hotspot mode. The default of this value is "ap", but can be
+ *     set to "p2p" or "adhoc". "p2p" and "adhoc" is currently not fully supported.
+ *
+ *     TODO: Complete support for adhoc and p2p modes.
+ */
+class HotspotManager : public QObject
+{
+    Q_OBJECT
+
+    Q_PROPERTY( bool enabled
+        READ enabled
+        WRITE setEnabled
+        NOTIFY enabledChanged)
+
+    Q_PROPERTY( QByteArray ssid
+        READ ssid
+        WRITE setSsid
+        NOTIFY ssidChanged)
+
+    Q_PROPERTY( QString password
+        READ password
+        WRITE setPassword
+        NOTIFY passwordChanged)
+
+    Q_PROPERTY( QString mode
+        READ mode
+        WRITE setMode
+        NOTIFY modeChanged)
+
+    Q_PROPERTY( bool stored
+        READ stored
+        NOTIFY storedChanged)
+
+public:
+    typedef std::shared_ptr<HotspotManager> SPtr;
+
+    explicit HotspotManager(const QDBusConnection& connection, QObject *parent = nullptr);
+
+    ~HotspotManager() = default;
+
+    bool enabled() const;
+
+    void setEnabled(bool);
+
+    bool stored() const;
+
+    QByteArray ssid() const;
+
+    QString password() const;
+
+    QString mode() const;
+
+Q_SIGNALS:
+    void enabledChanged(bool enabled);
+
+    void storedChanged(bool stored);
+
+    void ssidChanged(const QByteArray& ssid);
+
+    void passwordChanged(const QString& password);
+
+    void modeChanged(const QString& mode);
+
+    /*
+     * The mapping of code to string is taken from
+     *  http://bazaar.launchpad.net/~vcs-imports/
+     *  network-manager/trunk/view/head:/cli/src/common.c
+     *
+     * NetworkManager documentation: https://developer.gnome.org/
+     *  NetworkManager/0.9/spec.html#type-NM_DEVICE_STATE_REASON
+     */
+    void reportError(int reason);
+
+public Q_SLOTS:
+    void setSsid(const QByteArray&);
+
+    void setPassword(const QString&);
+
+    void setMode(const QString&);
+
+private:
+    class Priv;
+    std::shared_ptr<Priv> d;
+};

=== modified file 'src/indicator/nmofono/manager-impl.cpp'
--- src/indicator/nmofono/manager-impl.cpp	2015-06-18 12:28:05 +0000
+++ src/indicator/nmofono/manager-impl.cpp	2015-07-28 08:25:09 +0000
@@ -20,8 +20,11 @@
 
 #include <nmofono/manager-impl.h>
 #include <nmofono/wifi/wifi-link-impl.h>
+#include <NetworkManagerActiveConnectionInterface.h>
+#include <NetworkManagerDeviceInterface.h>
 #include <NetworkManagerInterface.h>
-#include <NetworkManagerDeviceInterface.h>
+#include <NetworkManagerSettingsInterface.h>
+#include <NetworkManagerSettingsConnectionInterface.h>
 
 #define slots
 #include <qofono-qt5/qofonomanager.h>
@@ -67,6 +70,8 @@
     SimUnlockDialog::Ptr m_unlockDialog;
     QList<wwan::Modem::Ptr> m_pendingUnlocks;
 
+    HotspotManager::SPtr m_hotspotManager;
+
     Private(Manager& parent) :
         p(parent)
     {
@@ -238,6 +243,8 @@
     d->m_killSwitch = make_shared<KillSwitch>(systemConnection);
     connect(d->m_killSwitch.get(), &KillSwitch::stateChanged, d.get(), &Private::updateHasWifi);
 
+    d->m_hotspotManager = make_shared<HotspotManager>(systemConnection);
+
     connect(d->nm.get(), &OrgFreedesktopNetworkManagerInterface::DeviceAdded, this, &ManagerImpl::device_added);
     QList<QDBusObjectPath> devices(d->nm->GetDevices());
     for(const auto &path : devices) {
@@ -550,6 +557,11 @@
     return d->m_ofonoLinks.values().toSet();
 }
 
+HotspotManager::SPtr ManagerImpl::hotspotManager() const
+{
+    return d->m_hotspotManager;
+}
+
 }
 
 #include "manager-impl.moc"

=== modified file 'src/indicator/nmofono/manager-impl.h'
--- src/indicator/nmofono/manager-impl.h	2015-04-24 08:47:08 +0000
+++ src/indicator/nmofono/manager-impl.h	2015-07-28 08:25:09 +0000
@@ -66,6 +66,8 @@
     void unlockAllModems() override;
     void unlockModemByName(const QString &name) override;
 
+    HotspotManager::SPtr hotspotManager() const;
+
 private Q_SLOTS:
     void device_added(const QDBusObjectPath &path);
     void device_removed(const QDBusObjectPath &path);

=== modified file 'src/indicator/nmofono/manager.h'
--- src/indicator/nmofono/manager.h	2015-04-24 08:47:08 +0000
+++ src/indicator/nmofono/manager.h	2015-07-28 08:25:09 +0000
@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include <nmofono/hotspot-manager.h>
 #include <nmofono/link.h>
 #include <nmofono/wifi/wifi-link.h>
 #include <nmofono/wwan/modem.h>
@@ -86,6 +87,8 @@
     Q_PROPERTY(bool unstoppableOperationHappening READ unstoppableOperationHappening NOTIFY unstoppableOperationHappeningUpdated)
     virtual bool unstoppableOperationHappening() const = 0;
 
+    virtual HotspotManager::SPtr hotspotManager() const = 0;
+
     /// @private
     Q_PROPERTY(QSet<Link::Ptr> links READ links NOTIFY linksUpdated)
     virtual QSet<Link::Ptr> links() const = 0;

=== modified file 'src/qdbus-stubs/CMakeLists.txt'
--- src/qdbus-stubs/CMakeLists.txt	2015-04-21 10:59:52 +0000
+++ src/qdbus-stubs/CMakeLists.txt	2015-07-28 08:25:09 +0000
@@ -29,6 +29,7 @@
 )
 
 set_source_files_properties(
+    "${DATA_DIR}/nm-settings.xml"
     "${DATA_DIR}/nm-settings-connection.xml"
     "${DATA_DIR}/nm-manager.xml"
     "${DATA_DIR}/org.freedesktop.Notifications.xml"
@@ -99,6 +100,18 @@
 
 qt5_add_dbus_interface(
     CONNECTIVITY_BACKEND_SRC
+    "${DATA_DIR}/nm-settings-connection.xml"
+    NetworkManagerSettingsConnectionInterface
+)
+
+qt5_add_dbus_interface(
+    CONNECTIVITY_BACKEND_SRC
+    "${DATA_DIR}/nm-settings.xml"
+    NetworkManagerSettingsInterface
+)
+
+qt5_add_dbus_interface(
+    CONNECTIVITY_BACKEND_SRC
     "${DATA_DIR}/org.freedesktop.Notifications.xml"
     NotificationsInterface
 )

=== modified file 'tests/integration/indicator-network-test-base.cpp'
--- tests/integration/indicator-network-test-base.cpp	2015-07-07 08:29:34 +0000
+++ tests/integration/indicator-network-test-base.cpp	2015-07-28 08:25:09 +0000
@@ -180,7 +180,7 @@
 QString IndicatorNetworkTestBase::createAccessPoint(const QString& id, const QString& ssid, const QString& device, uchar strength,
                           Secure secure, ApMode apMode, const QString& mac)
 {
-    int secflags;
+    int secflags(NM_802_11_AP_SEC_NONE);
     if (secure == Secure::insecure)
     {
         secflags = NM_802_11_AP_SEC_NONE;