Merge lp:~afrantzis/unity-system-compositor/dbus-active-outputs into lp:unity-system-compositor

[Alexandros Frantzis]

Update the Unity.Display DBus interface to support multiple outputs better

Update the Unity.Display DBus interface to support multiple outputs better

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:307
https://mir-jenkins.ubuntu.com/job/usc-ci/49/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-usc/70/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/3983
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/3973
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/3973
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/3973
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=amd64,release=xenial+overlay/74/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=amd64,release=zesty/74/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=armhf,release=vivid+overlay/74/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=i386,release=xenial+overlay/74/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=i386,release=zesty/74/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/usc-ci/49/rebuild

review: Needs Fixing (continuous-integration)

[Mir CI Bot (mir-ci-bot)]

PASSED: Continuous integration, rev:307
https://mir-jenkins.ubuntu.com/job/usc-ci/53/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-usc/75
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/3988
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/3978
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/3978
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=zesty/3978
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=amd64,release=xenial+overlay/79
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=amd64,release=xenial+overlay/79/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=amd64,release=zesty/79
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=amd64,release=zesty/79/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=armhf,release=vivid+overlay/79
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=armhf,release=vivid+overlay/79/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=i386,release=xenial+overlay/79
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=i386,release=xenial+overlay/79/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=i386,release=zesty/79
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-usc/arch=i386,release=zesty/79/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/usc-ci/53/rebuild

review: Approve (continuous-integration)

=== modified file 'src/com.canonical.Unity.Display.xml'
--- src/com.canonical.Unity.Display.xml	2016-04-15 08:40:54 +0000
+++ src/com.canonical.Unity.Display.xml	2017-02-06 11:51:56 +0000
@@ -2,9 +2,39 @@
 <node>
   <interface name='com.canonical.Unity.Display'>
     <method name='TurnOn'>
+      <arg type="s" name="what" direction="in"/>
     </method>
     <method name='TurnOff'>
+      <arg type="s" name="what" direction="in"/>
+    </method>
+    <property name='ActiveOutputs' type='(ii)' access='read'/>
+  </interface>
+
+  <interface name="org.freedesktop.DBus.Properties">
+    <method name="Get">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="s" name="property_name" direction="in"/>
+      <arg type="v" name="value" direction="out"/>
+    </method>
+    <method name="GetAll">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="a{sv}" name="properties" direction="out"/>
+    </method>
+    <method name="Set">
+      <arg type="s" name="interface_name" direction="in"/>
+      <arg type="s" name="property_name" direction="in"/>
+      <arg type="v" name="value" direction="in"/>
+    </method>
+    <signal name="PropertiesChanged">
+      <arg type="s" name="interface_name"/>
+      <arg type="a{sv}" name="changed_properties"/>
+      <arg type="as" name="invalidated_properties"/>
+    </signal>
+  </interface>
+
+  <interface name="org.freedesktop.DBus.Introspectable">
+    <method name="Introspect">
+      <arg type="s" name="xml_data" direction="out"/>
     </method>
   </interface>
 </node>
-

=== modified file 'src/mir_screen.cpp'
--- src/mir_screen.cpp	2016-08-12 14:08:22 +0000
+++ src/mir_screen.cpp	2017-02-06 11:51:56 +0000
@@ -42,6 +42,82 @@
     mir::report_exception(buffer);
     mir::log(::mir::logging::Severity::warning, "usc::MirScreen", warning_format, func, buffer.str().c_str());
 }
+
+bool is_external(mir::graphics::DisplayConfigurationOutputType type)
+{
+    using mir::graphics::DisplayConfigurationOutputType;
+
+    return type == DisplayConfigurationOutputType::vga ||
+           type == DisplayConfigurationOutputType::dvii ||
+           type == DisplayConfigurationOutputType::dvid ||
+           type == DisplayConfigurationOutputType::dvia ||
+           type == DisplayConfigurationOutputType::composite ||
+           type == DisplayConfigurationOutputType::svideo ||
+           type == DisplayConfigurationOutputType::component ||
+           type == DisplayConfigurationOutputType::ninepindin ||
+           type == DisplayConfigurationOutputType::displayport ||
+           type == DisplayConfigurationOutputType::hdmia ||
+           type == DisplayConfigurationOutputType::hdmib ||
+           type == DisplayConfigurationOutputType::tv;
+}
+
+usc::ActiveOutputs count_active_outputs(
+    mir::graphics::DisplayConfiguration const& display_configuration)
+{
+    usc::ActiveOutputs active_outputs{};
+
+    display_configuration.for_each_output(
+        [&active_outputs](mir::graphics::DisplayConfigurationOutput const& output)
+        {
+            if (output.connected &&
+                output.used &&
+                output.power_mode == MirPowerMode::mir_power_mode_on)
+            {
+                if (is_external(output.type))
+                    ++active_outputs.external;
+                else
+                    ++active_outputs.internal;
+            }
+        });
+
+    return active_outputs;
+}
+
+bool has_active_outputs(
+    mir::graphics::DisplayConfiguration const& display_configuration)
+{
+    auto const active_outputs = count_active_outputs(display_configuration);
+    return active_outputs.internal + active_outputs.external > 0;
+}
+
+bool all_outputs_filter(mir::graphics::UserDisplayConfigurationOutput const&)
+{
+    return true;
+}
+
+bool internal_outputs_filter(mir::graphics::UserDisplayConfigurationOutput const& output)
+{
+    return !is_external(output.type);
+}
+
+bool external_outputs_filter(mir::graphics::UserDisplayConfigurationOutput const& output)
+{
+    return is_external(output.type);
+}
+
+auto get_power_mode_filter_for_output_filter(usc::OutputFilter output_filter)
+{
+    switch (output_filter)
+    {
+        case usc::OutputFilter::all: return all_outputs_filter;
+        case usc::OutputFilter::internal: return internal_outputs_filter;
+        case usc::OutputFilter::external: return external_outputs_filter;
+        default: return all_outputs_filter;
+    }
+
+    return all_outputs_filter;
+}
+
 }
 
 usc::MirScreen::MirScreen(
@@ -49,7 +125,7 @@
     std::shared_ptr<mir::graphics::Display> const& display)
     : compositor{compositor},
       display{display},
-      current_power_mode{MirPowerMode::mir_power_mode_on}
+      active_outputs_handler{[](ActiveOutputs const&){}}
 {
     try
     {
@@ -69,27 +145,87 @@
 
 usc::MirScreen::~MirScreen() = default;
 
-void usc::MirScreen::turn_on()
-{
-    set_power_mode(MirPowerMode::mir_power_mode_on);
-}
-
-void usc::MirScreen::turn_off()
-{
-    set_power_mode(MirPowerMode::mir_power_mode_off);
-}
-
-void usc::MirScreen::set_power_mode(MirPowerMode mode)
+void usc::MirScreen::turn_on(OutputFilter output_filter)
+{
+    auto const filter_func = get_power_mode_filter_for_output_filter(output_filter);
+    set_power_mode(MirPowerMode::mir_power_mode_on, filter_func);
+}
+
+void usc::MirScreen::turn_off(OutputFilter output_filter)
+{
+    auto const filter_func = get_power_mode_filter_for_output_filter(output_filter);
+    set_power_mode(MirPowerMode::mir_power_mode_off, filter_func);
+}
+
+void usc::MirScreen::register_active_outputs_handler(
+    ActiveOutputsHandler const& handler)
+{
+    // It's not ideal to call the handler under lock, but we need this to
+    // guarantee that after this function returns no invocation of the old
+    // handler will be in progress. Alternatively, we would need to implement
+    // an event loop.
+    std::lock_guard<std::mutex> lock{active_outputs_mutex};
+    active_outputs_handler = handler;
+    active_outputs_handler(active_outputs);
+}
+
+void usc::MirScreen::initial_configuration(
+    std::shared_ptr<mir::graphics::DisplayConfiguration const> const& display_configuration)
+{
+    std::lock_guard<std::mutex> lock{active_outputs_mutex};
+    active_outputs = count_active_outputs(*display_configuration);
+    active_outputs_handler(active_outputs);
+}
+
+void usc::MirScreen::configuration_applied(
+    std::shared_ptr<mir::graphics::DisplayConfiguration const> const& display_configuration)
+{
+    std::lock_guard<std::mutex> lock{active_outputs_mutex};
+    active_outputs = count_active_outputs(*display_configuration);
+    active_outputs_handler(active_outputs);
+}
+
+void usc::MirScreen::base_configuration_updated(
+    std::shared_ptr<mir::graphics::DisplayConfiguration const> const&)
+{
+}
+
+void usc::MirScreen::session_configuration_applied(
+    std::shared_ptr<mir::frontend::Session> const&,
+    std::shared_ptr<mir::graphics::DisplayConfiguration> const&)
+{
+}
+
+void usc::MirScreen::session_configuration_removed(
+    std::shared_ptr<mir::frontend::Session> const&)
+{
+}
+
+void usc::MirScreen::configuration_failed(
+    std::shared_ptr<mir::graphics::DisplayConfiguration const> const&,
+    std::exception const&)
+{
+}
+
+void usc::MirScreen::catastrophic_configuration_error(
+    std::shared_ptr<mir::graphics::DisplayConfiguration const> const&,
+    std::exception const&)
+{
+}
+
+void usc::MirScreen::set_power_mode(MirPowerMode mode, SetPowerModeFilter const& filter)
 try
 {
-    if (current_power_mode == mode)
-        return;
-
     std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
 
     displayConfig->for_each_output(
         [&](const mg::UserDisplayConfigurationOutput displayConfigOutput) {
-            displayConfigOutput.power_mode = mode;
+            if (displayConfigOutput.connected &&
+                displayConfigOutput.used &&
+                filter(displayConfigOutput))
+            {
+                displayConfigOutput.power_mode = mode;
+            }
         }
     );
 
@@ -97,10 +233,8 @@
 
     display->configure(*displayConfig.get());
 
-    if (mode == MirPowerMode::mir_power_mode_on)
+    if (has_active_outputs(*displayConfig))
         compositor->start();
-
-    current_power_mode = mode;
 }
 catch (std::exception const&)
 {

=== modified file 'src/mir_screen.h'
--- src/mir_screen.h	2016-08-12 14:08:22 +0000
+++ src/mir_screen.h	2017-02-06 11:51:56 +0000
@@ -17,6 +17,7 @@
 #ifndef USC_MIR_SCREEN_H_
 #define USC_MIR_SCREEN_H_
 
+#include <mir/graphics/display_configuration_observer.h>
 #include "screen.h"
 
 #include <chrono>
@@ -26,29 +27,54 @@
 namespace mir
 {
 namespace compositor { class Compositor; }
-namespace graphics {class Display;}
+namespace graphics {class Display; struct UserDisplayConfigurationOutput;}
 }
 
 namespace usc
 {
 
-class MirScreen: public Screen
+class MirScreen: public Screen, public mir::graphics::DisplayConfigurationObserver
 {
 public:
     MirScreen(std::shared_ptr<mir::compositor::Compositor> const& compositor,
               std::shared_ptr<mir::graphics::Display> const& display);
     ~MirScreen();
 
-    void turn_on();
-    void turn_off();
+    // From Screen
+    void turn_on(OutputFilter output_filter) override;
+    void turn_off(OutputFilter output_filter) override;
+    void register_active_outputs_handler(ActiveOutputsHandler const& handler) override;
+
+    // From DisplayConfigurationObserver
+    void initial_configuration(
+        std::shared_ptr<mir::graphics::DisplayConfiguration const> const& display_configuration) override;
+    void configuration_applied(
+        std::shared_ptr<mir::graphics::DisplayConfiguration const> const& display_configuration) override;
+
+    void base_configuration_updated(
+        std::shared_ptr<mir::graphics::DisplayConfiguration const> const&) override;
+    void session_configuration_applied(
+        std::shared_ptr<mir::frontend::Session> const&,
+        std::shared_ptr<mir::graphics::DisplayConfiguration> const&) override;
+    void session_configuration_removed(
+        std::shared_ptr<mir::frontend::Session> const&) override;
+    void configuration_failed(
+        std::shared_ptr<mir::graphics::DisplayConfiguration const> const&,
+        std::exception const&) override;
+    void catastrophic_configuration_error(
+        std::shared_ptr<mir::graphics::DisplayConfiguration const> const&,
+        std::exception const&) override;
 
 private:
-    void set_power_mode(MirPowerMode mode);
+    using SetPowerModeFilter = bool(*)(mir::graphics::UserDisplayConfigurationOutput const&);
+    void set_power_mode(MirPowerMode mode, SetPowerModeFilter const& filter);
 
     std::shared_ptr<mir::compositor::Compositor> const compositor;
     std::shared_ptr<mir::graphics::Display> const display;
 
-    MirPowerMode current_power_mode;
+    std::mutex active_outputs_mutex;
+    ActiveOutputsHandler active_outputs_handler;
+    ActiveOutputs active_outputs;
 };
 
 }

=== modified file 'src/screen.h'
--- src/screen.h	2016-04-15 08:40:54 +0000
+++ src/screen.h	2017-02-06 11:51:56 +0000
@@ -23,13 +23,34 @@
 namespace usc
 {
 
+struct ActiveOutputs
+{
+    ActiveOutputs(int i, int e) : internal{i}, external{e} {}
+    ActiveOutputs() : ActiveOutputs{0, 0} {}
+
+    bool operator==(ActiveOutputs const& other) const
+    {
+        return internal == other.internal &&
+               external == other.external;
+    }
+
+    int internal;
+    int external;
+};
+
+using ActiveOutputsHandler = std::function<void(ActiveOutputs const&)>;
+
+enum class OutputFilter { all, internal, external };
+
 class Screen
 {
 public:
     virtual ~Screen() = default;
 
-    virtual void turn_on() = 0;
-    virtual void turn_off() = 0;
+    virtual void turn_on(OutputFilter filter) = 0;
+    virtual void turn_off(OutputFilter filter) = 0;
+    virtual void register_active_outputs_handler(
+        ActiveOutputsHandler const& handler) = 0;
 
 protected:
     Screen() = default;

=== modified file 'src/server.cpp'
--- src/server.cpp	2016-11-09 19:12:16 +0000
+++ src/server.cpp	2017-02-06 11:51:56 +0000
@@ -43,6 +43,7 @@
 #include <mir/log.h>
 #include <mir/abnormal_exit.h>
 #include <mir/main_loop.h>
+#include <mir/observer_registrar.h>
 
 #include <boost/exception/all.hpp>
 
@@ -292,9 +293,13 @@
     return screen(
         [this]
         {
-            return std::make_shared<MirScreen>(
+            auto mir_screen = std::make_shared<MirScreen>(
                 the_compositor(),
                 the_display());
+
+            the_display_configuration_observer_registrar()->register_interest(mir_screen);
+
+            return mir_screen;
         });
 }
 

=== modified file 'src/unity_display_service.cpp'
--- src/unity_display_service.cpp	2016-04-15 08:40:54 +0000
+++ src/unity_display_service.cpp	2017-02-06 11:51:56 +0000
@@ -32,6 +32,48 @@
 char const* const dbus_display_path = "/com/canonical/Unity/Display";
 char const* const dbus_display_service_name = "com.canonical.Unity.Display";
 
+void usc_dbus_message_iter_append_active_outputs_variant(
+    DBusMessageIter* iter, usc::ActiveOutputs const& active_outputs)
+{
+    DBusMessageIter iter_variant;
+    dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, "(ii)", &iter_variant);
+
+    {
+        DBusMessageIter iter_struct;
+        dbus_message_iter_open_container(&iter_variant, DBUS_TYPE_STRUCT, nullptr, &iter_struct);
+
+        dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_INT32, &active_outputs.internal);
+        dbus_message_iter_append_basic(&iter_struct, DBUS_TYPE_INT32, &active_outputs.external);
+
+        dbus_message_iter_close_container(&iter_variant, &iter_struct);
+    }
+
+    dbus_message_iter_close_container(iter, &iter_variant);
+}
+
+void usc_dbus_message_iter_append_active_outputs_dict_entry(
+    DBusMessageIter* iter, usc::ActiveOutputs const& active_outputs)
+{
+    char const* key = "ActiveOutputs";
+    DBusMessageIter iter_entry;
+    dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, nullptr, &iter_entry);
+
+    dbus_message_iter_append_basic(&iter_entry, DBUS_TYPE_STRING, &key);
+    usc_dbus_message_iter_append_active_outputs_variant(&iter_entry, active_outputs);
+
+    dbus_message_iter_close_container(iter, &iter_entry);
+}
+
+usc::OutputFilter output_filter_from_string(std::string const& filter_str)
+{
+    if (filter_str == "internal")
+        return usc::OutputFilter::internal;
+    else if (filter_str == "external")
+        return usc::OutputFilter::external;
+
+    return usc::OutputFilter::all;
+}
+
 }
 
 usc::UnityDisplayService::UnityDisplayService(
@@ -45,6 +87,22 @@
     loop->add_connection(connection);
     connection->request_name(dbus_display_service_name);
     connection->add_filter(handle_dbus_message_thunk, this);
+
+    screen->register_active_outputs_handler(
+        [this] (ActiveOutputs const& active_outputs_arg)
+        {
+            this->loop->enqueue(
+                [this, active_outputs_arg]
+                {
+                    active_outputs = active_outputs_arg;
+                    dbus_emit_ActiveOutputs();
+                });
+        });
+}
+
+usc::UnityDisplayService::~UnityDisplayService()
+{
+    screen->register_active_outputs_handler([](ActiveOutputs const&){});
 }
 
 ::DBusHandlerResult usc::UnityDisplayService::handle_dbus_message_thunk(
@@ -70,16 +128,69 @@
     }
     else if (dbus_message_is_method_call(message, dbus_display_interface, "TurnOn"))
     {
-        dbus_TurnOn();
+        char const* filter{""};
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_STRING, &filter,
+            DBUS_TYPE_INVALID);
+
+        // For backward compatibility
+        if (args_error)
+            filter = "all";
+
+        dbus_TurnOn(filter);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
         dbus_connection_send(connection, reply, nullptr);
     }
     else if (dbus_message_is_method_call(message, dbus_display_interface, "TurnOff"))
     {
-        dbus_TurnOff();
-
-        DBusMessageHandle reply{dbus_message_new_method_return(message)};
+        char const* filter{""};
+
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_STRING, &filter,
+            DBUS_TYPE_INVALID);
+
+        // For backward compatibility
+        if (args_error)
+            filter = "all";
+
+        dbus_TurnOff(filter);
+
+        DBusMessageHandle reply{dbus_message_new_method_return(message)};
+        dbus_connection_send(connection, reply, nullptr);
+    }
+    else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "Get"))
+    {
+        char const* interface{""};
+        char const* property{""};
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_STRING, &interface,
+            DBUS_TYPE_STRING, &property,
+            DBUS_TYPE_INVALID);
+
+        DBusMessageHandle reply{dbus_message_new_method_return(message)};
+
+        if (!args_error && std::string{interface} == dbus_display_interface)
+            dbus_properties_Get(reply, property);
+
+        dbus_connection_send(connection, reply, nullptr);
+    }
+    else if (dbus_message_is_method_call(message, "org.freedesktop.DBus.Properties", "GetAll"))
+    {
+        char const* interface{""};
+        dbus_message_get_args(
+            message, &args_error,
+            DBUS_TYPE_STRING, &interface,
+            DBUS_TYPE_INVALID);
+
+        DBusMessageHandle reply{dbus_message_new_method_return(message)};
+
+        if (!args_error && std::string{interface} == dbus_display_interface)
+            dbus_properties_GetAll(reply);
+
         dbus_connection_send(connection, reply, nullptr);
     }
     else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL)
@@ -101,12 +212,68 @@
     return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-void usc::UnityDisplayService::dbus_TurnOn()
-{
-    screen->turn_on();
-}
-
-void usc::UnityDisplayService::dbus_TurnOff()
-{
-    screen->turn_off();
+void usc::UnityDisplayService::dbus_TurnOn(std::string const& filter)
+{
+    screen->turn_on(output_filter_from_string(filter));
+}
+
+void usc::UnityDisplayService::dbus_TurnOff(std::string const& filter)
+{
+    screen->turn_off(output_filter_from_string(filter));
+}
+
+void usc::UnityDisplayService::dbus_emit_ActiveOutputs()
+{
+    DBusMessageHandle signal{
+        dbus_message_new_signal(
+            dbus_display_path,
+            "org.freedesktop.DBus.Properties",
+            "PropertiesChanged")};
+
+    DBusMessageIter iter;
+    dbus_message_iter_init_append(signal, &iter);
+
+    dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &dbus_display_interface);
+
+    {
+        DBusMessageIter iter_dict;
+        dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict);
+
+        usc_dbus_message_iter_append_active_outputs_dict_entry(&iter_dict, active_outputs);
+
+        dbus_message_iter_close_container(&iter, &iter_dict);
+    }
+
+    {
+        DBusMessageIter iter_array;
+        dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &iter_array);
+        dbus_message_iter_close_container(&iter, &iter_array);
+    }
+
+    dbus_connection_send(*connection, signal, nullptr);
+    dbus_connection_flush(*connection);
+}
+
+void usc::UnityDisplayService::dbus_properties_Get(DBusMessage* reply, std::string const& property)
+{
+    DBusMessageIter iter;
+    dbus_message_iter_init_append(reply, &iter);
+
+    if (property == "ActiveOutputs")
+        usc_dbus_message_iter_append_active_outputs_variant(&iter, active_outputs);
+}
+
+void usc::UnityDisplayService::dbus_properties_GetAll(DBusMessage* reply)
+{
+    DBusMessageIter iter;
+    dbus_message_iter_init_append(reply, &iter);
+
+    {
+        DBusMessageIter iter_dict;
+        dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "{sv}", &iter_dict);
+
+        usc_dbus_message_iter_append_active_outputs_dict_entry(&iter_dict, active_outputs);
+
+        dbus_message_iter_close_container(&iter, &iter_dict);
+    }
 }

=== modified file 'src/unity_display_service.h'
--- src/unity_display_service.h	2016-04-15 08:40:54 +0000
+++ src/unity_display_service.h	2017-02-06 11:51:56 +0000
@@ -20,8 +20,10 @@
 #define USC_UNITY_DISPLAY_SERVICE_H_
 
 #include "dbus_connection_handle.h"
+#include "screen.h"
 
 #include <memory>
+#include <string>
 
 namespace usc
 {
@@ -35,6 +37,7 @@
         std::shared_ptr<usc::DBusEventLoop> const& loop,
         std::string const& address,
         std::shared_ptr<usc::Screen> const& screen);
+    ~UnityDisplayService();
 
 private:
     static ::DBusHandlerResult handle_dbus_message_thunk(
@@ -42,12 +45,16 @@
     ::DBusHandlerResult handle_dbus_message(
         DBusConnection* connection, DBusMessage* message, void* user_data);
 
-    void dbus_TurnOn();
-    void dbus_TurnOff();
+    void dbus_TurnOn(std::string const& filter);
+    void dbus_TurnOff(std::string const& filter);
+    void dbus_emit_ActiveOutputs();
+    void dbus_properties_Get(DBusMessage* reply, std::string const& property);
+    void dbus_properties_GetAll(DBusMessage* reply);
 
     std::shared_ptr<usc::Screen> const screen;
     std::shared_ptr<DBusEventLoop> const loop;
     std::shared_ptr<DBusConnectionHandle> connection;
+    ActiveOutputs active_outputs;
 };
 
 }

=== modified file 'tests/include/usc/test/mock_screen.h'
--- tests/include/usc/test/mock_screen.h	2016-04-18 14:58:36 +0000
+++ tests/include/usc/test/mock_screen.h	2017-02-06 11:51:56 +0000
@@ -31,8 +31,9 @@
 
 struct MockScreen : usc::Screen
 {
-    MOCK_METHOD0(turn_on, void());
-    MOCK_METHOD0(turn_off, void());
+    MOCK_METHOD1(turn_on, void(OutputFilter));
+    MOCK_METHOD1(turn_off, void(OutputFilter));
+    MOCK_METHOD1(register_active_outputs_handler, void(ActiveOutputsHandler const&));
 };
 
 }

=== modified file 'tests/include/usc/test/stub_display_configuration.h'
--- tests/include/usc/test/stub_display_configuration.h	2015-11-12 14:21:24 +0000
+++ tests/include/usc/test/stub_display_configuration.h	2017-02-06 11:51:56 +0000
@@ -28,12 +28,36 @@
 {
     StubDisplayConfiguration()
     {
-        conf_output.power_mode = MirPowerMode::mir_power_mode_on;
+        internal_active_conf_output.power_mode = MirPowerMode::mir_power_mode_on;
+        internal_active_conf_output.type = mir::graphics::DisplayConfigurationOutputType::lvds;
+        internal_active_conf_output.used = true;
+        internal_active_conf_output.connected = true;
+
+        external_active_conf_output.power_mode = MirPowerMode::mir_power_mode_on;
+        external_active_conf_output.type = mir::graphics::DisplayConfigurationOutputType::dvid;
+        external_active_conf_output.used = true;
+        external_active_conf_output.connected = true;
+
+        inactive_conf_output.power_mode = MirPowerMode::mir_power_mode_off;
+        inactive_conf_output.used = false;
+        inactive_conf_output.connected = false;
+    }
+
+    StubDisplayConfiguration(
+        int num_internal_active_outputs,
+        int num_external_active_outputs,
+        int num_inactive_outputs)
+        : StubDisplayConfiguration{}
+    {
+          this->num_internal_active_outputs = num_internal_active_outputs;
+          this->num_external_active_outputs = num_external_active_outputs;
+          this->num_inactive_outputs = num_inactive_outputs;
     }
 
     StubDisplayConfiguration(mir::graphics::DisplayConfigurationOutput const& output)
-        : conf_output(output)
+        : StubDisplayConfiguration{}
     {
+          internal_active_conf_output = output;
     }
 
     void for_each_card(std::function<void(mir::graphics::DisplayConfigurationCard const&)>) const override
@@ -42,21 +66,45 @@
 
     void for_each_output(std::function<void(mir::graphics::DisplayConfigurationOutput const&)> f) const override
     {
-        f(conf_output);
+        for (int i = 0; i < num_internal_active_outputs; ++i)
+            f(internal_active_conf_output);
+        for (int i = 0; i < num_external_active_outputs; ++i)
+            f(external_active_conf_output);
+        for (int i = 0; i < num_inactive_outputs; ++i)
+            f(inactive_conf_output);
     }
 
     void for_each_output(std::function<void(mir::graphics::UserDisplayConfigurationOutput&)> f)
     {
-        mir::graphics::UserDisplayConfigurationOutput user{conf_output};
-        f(user);
+        for (int i = 0; i < num_internal_active_outputs; ++i)
+        {
+            mir::graphics::UserDisplayConfigurationOutput user{internal_active_conf_output};
+            f(user);
+        }
+        for (int i = 0; i < num_external_active_outputs; ++i)
+        {
+            mir::graphics::UserDisplayConfigurationOutput user{external_active_conf_output};
+            f(user);
+        }
+        for (int i = 0; i < num_inactive_outputs; ++i)
+        {
+            mir::graphics::UserDisplayConfigurationOutput user{inactive_conf_output};
+            f(user);
+        }
     }
 
     std::unique_ptr<mir::graphics::DisplayConfiguration> clone() const override
     {
-        return std::make_unique<StubDisplayConfiguration>(conf_output);
+        return std::make_unique<StubDisplayConfiguration>(internal_active_conf_output);
     }
 
-    mir::graphics::DisplayConfigurationOutput conf_output;
+    int num_internal_active_outputs{1};
+    int num_external_active_outputs{0};
+    int num_inactive_outputs{0};
+
+    mir::graphics::DisplayConfigurationOutput internal_active_conf_output;
+    mir::graphics::DisplayConfigurationOutput external_active_conf_output;
+    mir::graphics::DisplayConfigurationOutput inactive_conf_output;
 };
 
 }

=== modified file 'tests/integration-tests/test_unity_display_service.cpp'
--- tests/integration-tests/test_unity_display_service.cpp	2016-04-18 14:58:36 +0000
+++ tests/integration-tests/test_unity_display_service.cpp	2017-02-06 11:51:56 +0000
@@ -40,16 +40,34 @@
 namespace
 {
 
+struct FakeScreen : ut::MockScreen
+{
+    void register_active_outputs_handler(usc::ActiveOutputsHandler const& handler)
+    {
+        std::lock_guard<std::mutex> lock{active_outputs_mutex};
+        active_outputs_handler = handler;
+    }
+
+    void notify_active_outputs(usc::ActiveOutputs const& active_outputs)
+    {
+        std::lock_guard<std::mutex> lock{active_outputs_mutex};
+        active_outputs_handler(active_outputs);
+    }
+
+    std::mutex active_outputs_mutex;
+    usc::ActiveOutputsHandler active_outputs_handler{[](usc::ActiveOutputs const&){}};
+};
+
 struct AUnityDisplayService : testing::Test
 {
     ut::DBusBus bus;
 
-    std::shared_ptr<ut::MockScreen> const mock_screen =
-        std::make_shared<testing::NiceMock<ut::MockScreen>>();
+    std::shared_ptr<FakeScreen> const fake_screen =
+        std::make_shared<testing::NiceMock<FakeScreen>>();
     ut::UnityDisplayDBusClient client{bus.address()};
     std::shared_ptr<usc::DBusEventLoop> const dbus_loop =
         std::make_shared<usc::DBusEventLoop>();
-    usc::UnityDisplayService service{dbus_loop, bus.address(), mock_screen};
+    usc::UnityDisplayService service{dbus_loop, bus.address(), fake_screen};
     std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
         std::make_shared<usc::DBusConnectionThread>(dbus_loop);
 };
@@ -66,16 +84,137 @@
 
 TEST_F(AUnityDisplayService, forwards_turn_on_request)
 {
-    EXPECT_CALL(*mock_screen, turn_on());
-
-    client.request_turn_on();
+    using namespace testing;
+
+    InSequence s;
+    EXPECT_CALL(*fake_screen, turn_on(usc::OutputFilter::all));
+    EXPECT_CALL(*fake_screen, turn_on(usc::OutputFilter::internal));
+    EXPECT_CALL(*fake_screen, turn_on(usc::OutputFilter::external));
+
+    client.request_turn_on("all");
+    client.request_turn_on("internal");
+    client.request_turn_on("external");
 }
 
 TEST_F(AUnityDisplayService, forwards_turn_off_request)
 {
-    EXPECT_CALL(*mock_screen, turn_off());
-
-    client.request_turn_off();
+    using namespace testing;
+
+    InSequence s;
+    EXPECT_CALL(*fake_screen, turn_off(usc::OutputFilter::all));
+    EXPECT_CALL(*fake_screen, turn_off(usc::OutputFilter::internal));
+    EXPECT_CALL(*fake_screen, turn_off(usc::OutputFilter::external));
+
+    client.request_turn_off("all");
+    client.request_turn_off("internal");
+    client.request_turn_off("external");
+}
+
+TEST_F(AUnityDisplayService, emits_active_outputs_property_change)
+{
+    using namespace testing;
+
+    usc::ActiveOutputs expected_active_outputs;
+    expected_active_outputs.internal = 2;
+    expected_active_outputs.external = 3;
+
+    fake_screen->notify_active_outputs(expected_active_outputs);
+    // Received messages are queued at the destination, so it doesn't
+    // matter that we start listening after the signal has been sent
+    auto message = client.listen_for_properties_changed();
+
+    DBusMessageIter iter;
+    dbus_message_iter_init(message, &iter);
+    dbus_message_iter_next(&iter);
+    DBusMessageIter iter_properties;
+    dbus_message_iter_recurse(&iter, &iter_properties);
+    DBusMessageIter iter_property;
+    dbus_message_iter_recurse(&iter_properties, &iter_property);
+
+    char const* property_name{""};
+    usc::ActiveOutputs active_outputs{-1, -1};
+
+    dbus_message_iter_get_basic(&iter_property, &property_name);
+
+    dbus_message_iter_next(&iter_property);
+    DBusMessageIter iter_variant;
+    DBusMessageIter iter_values;
+    dbus_message_iter_recurse(&iter_property, &iter_variant);
+    dbus_message_iter_recurse(&iter_variant, &iter_values);
+
+    dbus_message_iter_get_basic(&iter_values, &active_outputs.internal);
+    dbus_message_iter_next(&iter_values);
+    dbus_message_iter_get_basic(&iter_values, &active_outputs.external);
+
+    EXPECT_THAT(property_name, StrEq("ActiveOutputs"));
+    EXPECT_THAT(active_outputs, Eq(expected_active_outputs));
+}
+
+TEST_F(AUnityDisplayService, returns_active_outputs_property)
+{
+    using namespace testing;
+
+    usc::ActiveOutputs expected_active_outputs;
+    expected_active_outputs.internal = 2;
+    expected_active_outputs.external = 3;
+
+    fake_screen->notify_active_outputs(expected_active_outputs);
+
+    auto message = client.request_active_outputs_property().get();
+
+    DBusMessageIter iter;
+    dbus_message_iter_init(message, &iter);
+
+    DBusMessageIter iter_variant;
+    dbus_message_iter_recurse(&iter, &iter_variant);
+    DBusMessageIter iter_values;
+    dbus_message_iter_recurse(&iter_variant, &iter_values);
+
+    usc::ActiveOutputs active_outputs{-1, -1};
+
+    dbus_message_iter_get_basic(&iter_values, &active_outputs.internal);
+    dbus_message_iter_next(&iter_values);
+    dbus_message_iter_get_basic(&iter_values, &active_outputs.external);
+
+    EXPECT_THAT(active_outputs, Eq(expected_active_outputs));
+}
+
+TEST_F(AUnityDisplayService, returns_all_properties)
+{
+    using namespace testing;
+
+    usc::ActiveOutputs expected_active_outputs;
+    expected_active_outputs.internal = 2;
+    expected_active_outputs.external = 3;
+
+    fake_screen->notify_active_outputs(expected_active_outputs);
+
+    auto message = client.request_all_properties().get();
+
+    DBusMessageIter iter;
+    dbus_message_iter_init(message, &iter);
+    DBusMessageIter iter_properties;
+    dbus_message_iter_recurse(&iter, &iter_properties);
+    DBusMessageIter iter_property;
+    dbus_message_iter_recurse(&iter_properties, &iter_property);
+
+    char const* property_name{""};
+    usc::ActiveOutputs active_outputs{-1, -1};
+
+    dbus_message_iter_get_basic(&iter_property, &property_name);
+
+    dbus_message_iter_next(&iter_property);
+    DBusMessageIter iter_variant;
+    DBusMessageIter iter_values;
+    dbus_message_iter_recurse(&iter_property, &iter_variant);
+    dbus_message_iter_recurse(&iter_variant, &iter_values);
+
+    dbus_message_iter_get_basic(&iter_values, &active_outputs.internal);
+    dbus_message_iter_next(&iter_values);
+    dbus_message_iter_get_basic(&iter_values, &active_outputs.external);
+
+    EXPECT_THAT(property_name, StrEq("ActiveOutputs"));
+    EXPECT_THAT(active_outputs, Eq(expected_active_outputs));
 }
 
 TEST_F(AUnityDisplayService, returns_error_reply_for_unsupported_method)

=== modified file 'tests/integration-tests/unity_display_dbus_client.cpp'
--- tests/integration-tests/unity_display_dbus_client.cpp	2016-04-18 14:58:36 +0000
+++ tests/integration-tests/unity_display_dbus_client.cpp	2017-02-06 11:51:56 +0000
@@ -17,6 +17,7 @@
  */
 
 #include "unity_display_dbus_client.h"
+#include "src/dbus_message_handle.h"
 
 namespace ut = usc::test;
 
@@ -26,6 +27,9 @@
         "com.canonical.Unity.Display",
         "/com/canonical/Unity/Display"}
 {
+        connection.add_match(
+            "type='signal',"
+            "interface='org.freedesktop.DBus.Properties'");
 }
 
 ut::DBusAsyncReplyString ut::UnityDisplayDBusClient::request_introspection()
@@ -35,17 +39,25 @@
         DBUS_TYPE_INVALID);
 }
 
-ut::DBusAsyncReplyVoid ut::UnityDisplayDBusClient::request_turn_on()
+ut::DBusAsyncReplyVoid ut::UnityDisplayDBusClient::request_turn_on(
+    std::string const& filter)
 {
+    auto const filter_cstr = filter.c_str();
+
     return invoke_with_reply<ut::DBusAsyncReplyVoid>(
         unity_display_interface, "TurnOn",
+        DBUS_TYPE_STRING, &filter_cstr,
         DBUS_TYPE_INVALID);
 }
 
-ut::DBusAsyncReplyVoid ut::UnityDisplayDBusClient::request_turn_off()
+ut::DBusAsyncReplyVoid ut::UnityDisplayDBusClient::request_turn_off(
+    std::string const& filter)
 {
+    auto const filter_cstr = filter.c_str();
+
     return invoke_with_reply<ut::DBusAsyncReplyVoid>(
         unity_display_interface, "TurnOff",
+        DBUS_TYPE_STRING, &filter_cstr,
         DBUS_TYPE_INVALID);
 }
 
@@ -54,3 +66,36 @@
     return invoke_with_reply<ut::DBusAsyncReply>(
         unity_display_interface, "invalidMethod", DBUS_TYPE_INVALID);
 }
+
+ut::DBusAsyncReply ut::UnityDisplayDBusClient::request_active_outputs_property()
+{
+    char const* const active_outputs_cstr = "ActiveOutputs";
+
+    return invoke_with_reply<ut::DBusAsyncReply>(
+        "org.freedesktop.DBus.Properties", "Get",
+        DBUS_TYPE_STRING, &unity_display_interface,
+        DBUS_TYPE_STRING, &active_outputs_cstr,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReply ut::UnityDisplayDBusClient::request_all_properties()
+{
+    return invoke_with_reply<ut::DBusAsyncReply>(
+        "org.freedesktop.DBus.Properties", "GetAll",
+        DBUS_TYPE_STRING, &unity_display_interface,
+        DBUS_TYPE_INVALID);
+}
+
+usc::DBusMessageHandle ut::UnityDisplayDBusClient::listen_for_properties_changed()
+{
+    while (true)
+    {
+        dbus_connection_read_write(connection, 1);
+        auto msg = usc::DBusMessageHandle{dbus_connection_pop_message(connection)};
+
+        if (msg && dbus_message_is_signal(msg, "org.freedesktop.DBus.Properties", "PropertiesChanged"))
+        {
+            return msg;
+        }
+    }
+}

=== modified file 'tests/integration-tests/unity_display_dbus_client.h'
--- tests/integration-tests/unity_display_dbus_client.h	2016-04-18 14:58:36 +0000
+++ tests/integration-tests/unity_display_dbus_client.h	2017-02-06 11:51:56 +0000
@@ -32,10 +32,14 @@
     UnityDisplayDBusClient(std::string const& address);
 
     DBusAsyncReplyString request_introspection();
-    DBusAsyncReplyVoid request_turn_on();
-    DBusAsyncReplyVoid request_turn_off();
+    DBusAsyncReplyVoid request_turn_on(std::string const& filter);
+    DBusAsyncReplyVoid request_turn_off(std::string const& filter);
+    DBusAsyncReply request_active_outputs_property();
+    DBusAsyncReply request_all_properties();
     DBusAsyncReply request_invalid_method();
 
+    DBusMessageHandle listen_for_properties_changed();
+
     char const* const unity_display_interface = "com.canonical.Unity.Display";
 };
 

=== modified file 'tests/unit-tests/test_mir_screen.cpp'
--- tests/unit-tests/test_mir_screen.cpp	2016-11-09 19:12:16 +0000
+++ tests/unit-tests/test_mir_screen.cpp	2017-02-06 11:51:56 +0000
@@ -19,6 +19,8 @@
 #include "src/mir_screen.h"
 
 #include "usc/test/mock_display.h"
+#include "usc/test/stub_display_configuration.h"
+#include "fake_shared.h"
 
 #include <mir/compositor/compositor.h>
 #include <mir/graphics/display_configuration.h>
@@ -40,17 +42,31 @@
     MOCK_METHOD0(stop, void());
 };
 
+struct MockDisplayWithExternalOutputs : ut::MockDisplay
+{
+    std::unique_ptr<mir::graphics::DisplayConfiguration> configuration() const override
+    {
+        return std::make_unique<usc::test::StubDisplayConfiguration>(2, 3, 1);
+    }
+};
+
 struct AMirScreen : testing::Test
 {
-    void turn_screen_off()
-    {
-        mir_screen.turn_off();
-        verify_and_clear_expectations();
-    }
-
-    void turn_screen_on()
-    {
-        mir_screen.turn_on();
+    void turn_all_displays_off()
+    {
+        mir_screen->turn_off(usc::OutputFilter::all);
+        verify_and_clear_expectations();
+    }
+
+    void turn_all_displays_on()
+    {
+        mir_screen->turn_on(usc::OutputFilter::all);
+        verify_and_clear_expectations();
+    }
+
+    void turn_internal_displays_off()
+    {
+        mir_screen->turn_off(usc::OutputFilter::internal);
         verify_and_clear_expectations();
     }
 
@@ -60,14 +76,33 @@
         Mock::VerifyAndClearExpectations(compositor.get());
     }
 
+    void use_mir_screen_with_external_outputs()
+    {
+        display = std::make_shared<testing::NiceMock<MockDisplayWithExternalOutputs>>();
+        mir_screen = std::make_shared<usc::MirScreen>(compositor, display);
+    }
+
     std::shared_ptr<MockCompositor> compositor{
         std::make_shared<testing::NiceMock<MockCompositor>>()};
     std::shared_ptr<ut::MockDisplay> display{
         std::make_shared<testing::NiceMock<ut::MockDisplay>>()};
 
-    usc::MirScreen mir_screen{
-        compositor,
-        display};
+    usc::ActiveOutputs const config_active_outputs{1, 3};
+    int const config_inactive_outputs = 2;
+    ut::StubDisplayConfiguration stub_display_configuration{
+        config_active_outputs.internal,
+        config_active_outputs.external,
+        config_inactive_outputs};
+
+    usc::ActiveOutputs active_outputs{-1,-1};
+    usc::ActiveOutputsHandler active_outputs_handler =
+        [this] (usc::ActiveOutputs const& active_outputs_arg)
+        {
+            active_outputs = active_outputs_arg;
+        };
+
+    std::shared_ptr<usc::MirScreen> mir_screen{
+        std::make_shared<usc::MirScreen>(compositor, display)};
 };
 
 }
@@ -78,17 +113,63 @@
     EXPECT_CALL(*compositor, stop());
     EXPECT_CALL(*display, configure(_));
 
-    turn_screen_off();
+    turn_all_displays_off();
 }
 
 TEST_F(AMirScreen, starts_compositing_and_turns_on_display_when_turning_on)
 {
-    turn_screen_off();
-
-    InSequence s;
-    EXPECT_CALL(*compositor, stop());
-    EXPECT_CALL(*display, configure(_));
-    EXPECT_CALL(*compositor, start());
-
-    turn_screen_on();
+    turn_all_displays_off();
+
+    InSequence s;
+    EXPECT_CALL(*compositor, stop());
+    EXPECT_CALL(*display, configure(_));
+    EXPECT_CALL(*compositor, start());
+
+    turn_all_displays_on();
+}
+
+TEST_F(AMirScreen, stops_compositing_and_turns_off_internal_when_only_internal)
+{
+    InSequence s;
+    EXPECT_CALL(*compositor, stop());
+    EXPECT_CALL(*display, configure(_));
+
+    turn_internal_displays_off();
+}
+
+TEST_F(AMirScreen, restarts_compositing_after_turn_off_internal_if_active_outputs_remain)
+{
+    use_mir_screen_with_external_outputs();
+
+    InSequence s;
+    EXPECT_CALL(*compositor, stop());
+    EXPECT_CALL(*display, configure(_));
+    EXPECT_CALL(*compositor, start());
+
+    turn_internal_displays_off();
+}
+
+TEST_F(AMirScreen, registered_handler_is_called_immediately)
+{
+    mir_screen->register_active_outputs_handler(active_outputs_handler);
+
+    EXPECT_THAT(active_outputs, Eq(usc::ActiveOutputs{}));
+}
+
+TEST_F(AMirScreen, initial_configuration_calls_handler)
+{
+    mir_screen->register_active_outputs_handler(active_outputs_handler);
+
+    mir_screen->initial_configuration(ut::fake_shared(stub_display_configuration));
+
+    EXPECT_THAT(active_outputs, Eq(config_active_outputs));
+}
+
+TEST_F(AMirScreen, configuration_applied_calls_handler)
+{
+    mir_screen->register_active_outputs_handler(active_outputs_handler);
+
+    mir_screen->configuration_applied(ut::fake_shared(stub_display_configuration));
+
+    EXPECT_THAT(active_outputs, Eq(config_active_outputs));
 }