Merge lp:~gerboland/qtmir/exposeOrientation into lp:qtmir

[Gerry Boland]

Expose Mir surface orientation property to QML

Expose Mir surface orientation property to QML

 * Are there any related MPs required for this MP to build/function as expected? Please list.
https://code.launchpad.net/~gerboland/unity8/orientationLock/+merge/232484
https://code.launchpad.net/~gerboland/qtubuntu/exposeOrientation/+merge/232252
https://code.launchpad.net/~gerboland/platform-api/exposeOrientation/+merge/232250

 * Did you perform an exploratory manual test run of your code change and any related functionality?
Y

 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:236
http://jenkins.qa.ubuntu.com/job/qtmir-ci/42/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/42
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/42

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/42/rebuild

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

Now that prompts-in-prompts has landed, there are merge conflicts in:
src/modules/Unity/Application/mirsurfaceitem.cpp
src/modules/Unity/Application/mirsurfaceitem.h

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:237
http://jenkins.qa.ubuntu.com/job/qtmir-ci/57/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/57/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/57/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/57/rebuild

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

In src/modules/Unity/Application/mirsurfaceitem.cpp:

"""
    case Qt::PortraitOrientation:
        mirOrientation = mir_orientation_normal;
"""

Here you're assuming that the screen aspect-ratio is portrait, which is not always the case.

Qt::ScreenOrientation values do not map directly to MirOrientation ones. The two enums express orientation differently. Trying to shoehorn one into the other is no good.

Either do a proper translation between the two or make MirSurfaceItem::orientation use an enum that does match with MirOrientation.

------------------------

In src/platforms/mirserver/screen.cpp:

Who's calling Screen::toggleSensors()?
It was supposed to be called whenever the display goes on and off.

---------------------------

In src/platforms/mirserver/screen.cpp:

"""
    QCoreApplication::postEvent(this, new OrientationReadingEvent(
                                    OrientationReadingEvent::m_type, m_orientationSensor->reading()->orientation()));
"""

Weird indentation.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:238
http://jenkins.qa.ubuntu.com/job/qtmir-ci/58/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/58
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/58

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/58/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

> In src/modules/Unity/Application/mirsurfaceitem.cpp:
>
> """
> case Qt::PortraitOrientation:
> mirOrientation = mir_orientation_normal;
> """
>
> Here you're assuming that the screen aspect-ratio is portrait, which is not
> always the case.

Why would we care here? This is just the shell telling an application: this is your orientation now.

> Qt::ScreenOrientation values do not map directly to MirOrientation ones. The
> two enums express orientation differently. Trying to shoehorn one into the
> other is no good.

I think it's a bad idea that there are 2 ways to express orientation, and we should just use one. You don't like that I ignore PrimaryOrientation?

> Either do a proper translation between the two or make
> MirSurfaceItem::orientation use an enum that does match with MirOrientation.

I prefer using a subset of an existing enum than creating a new enum. QML already knows about Qt::*Orientation - it would be a waste to duplicate it IMO.

> ------------------------
>
> In src/platforms/mirserver/screen.cpp:
>
> Who's calling Screen::toggleSensors()?
> It was supposed to be called whenever the display goes on and off.

Nobody yet. I had hoped to wire it up to the hide/show window event for display off/on, but that event doesn't happen. I'm not sure what signal to wire it up to still. Will be later MR.

> ---------------------------
>
> In src/platforms/mirserver/screen.cpp:
>
> """
> QCoreApplication::postEvent(this, new OrientationReadingEvent(
> OrientationReadingEvent::m_type,
> m_orientationSensor->reading()->orientation()));
> """
>
> Weird indentation.
done

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:239
http://jenkins.qa.ubuntu.com/job/qtmir-ci/59/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/59
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/59

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/59/rebuild

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

> > In src/modules/Unity/Application/mirsurfaceitem.cpp:
> >
> > """
> > case Qt::PortraitOrientation:
> > mirOrientation = mir_orientation_normal;
> > """
> >
> > Here you're assuming that the screen aspect-ratio is portrait, which is not
> > always the case.
>
> Why would we care here? This is just the shell telling an application: this is
> your orientation now.

Because the code is wrong. If it's a main stage tablet app and shell says "surface.orientation = Landscape" it means mir_orientation_normal, not mir_orientation_left.

>
> > Qt::ScreenOrientation values do not map directly to MirOrientation ones. The
> > two enums express orientation differently. Trying to shoehorn one into the
> > other is no good.
>
> I think it's a bad idea that there are 2 ways to express orientation, and we
> should just use one.

But that's what we have in your patch. There's Qt::ScreenOrientation and MirOrientation. Ignoring it will not make it go away. :)

So I will more explicitly: I see two ways of fixing it:
1 - Doing the proper translation from Qt::ScreenOrientation to MirOrientation in MirSurfaceItem::setOrientation
2 - Using an enum semantically equivalent to MirOrientation in MirSurfaceItem.orientation.

> You don't like that I ignore PrimaryOrientation?

It's not about that. But now that you mentioned it, there should be at least a warning if unity8 uses it if it's explicitly not supported. Otherwise we would be hiding an implementation bug in unity8.

>
> > Either do a proper translation between the two or make
> > MirSurfaceItem::orientation use an enum that does match with MirOrientation.
>
> I prefer using a subset of an existing enum than creating a new enum. QML
> already knows about Qt::*Orientation - it would be a waste to duplicate it
> IMO.

I suppose you're talking about going for the option 2 above. We wouldn't be duplicating Qt::ScreenOrientation as it would be a semantically different enum.

>
>
>
> > ------------------------
> >
> > In src/platforms/mirserver/screen.cpp:
> >
> > Who's calling Screen::toggleSensors()?
> > It was supposed to be called whenever the display goes on and off.
>
> Nobody yet. I had hoped to wire it up to the hide/show window event for
> display off/on, but that event doesn't happen. I'm not sure what signal to
> wire it up to still. Will be later MR.

If not body uses it then it's dead code. I think it would be better to only add it once we have use for it.

Btw, I think we should have a big FIXME somewhere saying that we must turn off the orientation sensor when the display is off.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:241
http://jenkins.qa.ubuntu.com/job/qtmir-ci/63/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/63
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/63

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/63/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:242
http://jenkins.qa.ubuntu.com/job/qtmir-ci/64/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/64
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/64

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/64/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

> > I think it's a bad idea that there are 2 ways to express orientation, and we
> > should just use one.
>
> But that's what we have in your patch. There's Qt::ScreenOrientation and
> MirOrientation. Ignoring it will not make it go away. :)
>
> So I will more explicitly: I see two ways of fixing it:
> 1 - Doing the proper translation from Qt::ScreenOrientation to MirOrientation
> in MirSurfaceItem::setOrientation

I finally saw what you mean. I'm not such a big fan of it, and it relies other toolkits to deal with orientation in the same way Qt does (i.e. compare supplied orientation with a deduced native orientation), but anyway: it's done.

> > You don't like that I ignore PrimaryOrientation?
>
> It's not about that. But now that you mentioned it, there should be at least a
> warning if unity8 uses it if it's explicitly not supported. Otherwise we would
> be hiding an implementation bug in unity8.

I implemented it properly, PrimaryOrientation = native orientation.

> > > ------------------------
> > >
> > > In src/platforms/mirserver/screen.cpp:
> > >
> > > Who's calling Screen::toggleSensors()?
> > > It was supposed to be called whenever the display goes on and off.
> >
> > Nobody yet. I had hoped to wire it up to the hide/show window event for
> > display off/on, but that event doesn't happen. I'm not sure what signal to
> > wire it up to still. Will be later MR.
>
> If not body uses it then it's dead code. I think it would be better to only
> add it once we have use for it.
>
> Btw, I think we should have a big FIXME somewhere saying that we must turn off
> the orientation sensor when the display is off.

It's not dead if we'll use it soon :) I added a FIXME on top of the method. Will that do?

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:243
http://jenkins.qa.ubuntu.com/job/qtmir-ci/65/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/65
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/65

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/65/rebuild

review: Approve (continuous-integration)

[Daniel d'Andrada (dandrader)]

> [...]
>
> I finally saw what you mean. I'm not such a big fan of it, and it relies other
> toolkits to deal with orientation in the same way Qt does (i.e. compare
> supplied orientation with a deduced native orientation), but anyway: it's
> done.

Didn't get your comment. It relies on other toolkits dealing with MirOrientation the way it's defined. e.g. "rotate UI left by 90 if mir_orientation_left", "right by 90 if mir_orientation_right" and so on. Regardless of the aspect ratio.

But anyway, glad you did the change so I'm happy with it now. :)

--------------------------------

In src/modules/Unity/Application/mirsurfaceitem.cpp:

"""
    default:
        qWarning("Unrecognized Qt::ScreenOrientation!");
        return;
"""

It should use qCWarning(QTMIR_SURFACES), but I won't block this MP because of that as this review has been going on for too long now.

review: Approve

[Michael Zanetti (mzanetti)]

Text conflict in src/modules/Unity/Application/mirsurfaceitem.h
1 conflicts encountered.

review: Needs Fixing

[lp:~gerboland/qtmir/exposeOrientation]

244. By Gerry Boland on 2014-09-16

Merge trunk and resolve conflict

[Michael Zanetti (mzanetti)]

conflicts fixed.

review: Abstain

[lp:~gerboland/qtmir/exposeOrientation]

245. By Gerry Boland on 2014-09-19

Merge trunk

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2014-09-11 20:21:47 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2014-09-19 12:20:29 +0000
@@ -30,8 +30,10 @@
 
 // Qt
 #include <QDebug>
+#include <QGuiApplication>
 #include <QQmlEngine>
 #include <QQuickWindow>
+#include <QScreen>
 #include <QSGSimpleTextureNode>
 #include <QSGTextureProvider>
 #include <QTimer>
@@ -243,6 +245,7 @@
     , m_session(session)
     , m_firstFrameDrawn(false)
     , m_live(true)
+    , m_orientation(Qt::PortraitOrientation)
     , m_textureProvider(nullptr)
     , m_lastTouchEvent(nullptr)
 {
@@ -349,6 +352,51 @@
     return static_cast<MirSurfaceItem::State>(m_surface->state());
 }
 
+Qt::ScreenOrientation MirSurfaceItem::orientation() const
+{
+    return m_orientation;
+}
+
+void MirSurfaceItem::setOrientation(const Qt::ScreenOrientation orientation)
+{
+    qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::setOrientation - orientation=" << orientation;
+
+    if (m_orientation == orientation)
+        return;
+
+    MirOrientation mirOrientation;
+    Qt::ScreenOrientation nativeOrientation = QGuiApplication::primaryScreen()->nativeOrientation();
+    const bool landscapeNativeOrientation = (nativeOrientation == Qt::LandscapeOrientation);
+
+    Qt::ScreenOrientation requestedOrientation = orientation;
+    if (orientation == Qt::PrimaryOrientation) { // means orientation equals native orientation, set it as such
+        requestedOrientation = nativeOrientation;
+    }
+
+    switch(requestedOrientation) {
+    case Qt::PortraitOrientation:
+        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_right : mir_orientation_normal;
+        break;
+    case Qt::LandscapeOrientation:
+        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_normal : mir_orientation_left;
+        break;
+    case Qt::InvertedPortraitOrientation:
+        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_left : mir_orientation_inverted;
+        break;
+    case Qt::InvertedLandscapeOrientation:
+        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_inverted : mir_orientation_right;
+        break;
+    default:
+        qWarning("Unrecognized Qt::ScreenOrientation!");
+        return;
+    }
+
+    m_surface->set_orientation(mirOrientation);
+
+    m_orientation = orientation;
+    Q_EMIT orientationChanged();
+}
+
 QString MirSurfaceItem::name() const
 {
     //FIXME - how to listen to change in this property?
 
=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2014-09-11 20:21:47 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2014-09-19 12:20:29 +0000
@@ -75,6 +75,7 @@
     Q_PROPERTY(State state READ state NOTIFY stateChanged)
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
     Q_PROPERTY(bool live READ live NOTIFY liveChanged)
+    Q_PROPERTY(Qt::ScreenOrientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged DESIGNABLE false)
 
 public:
     explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
@@ -107,6 +108,7 @@
     State state() const;
     QString name() const;
     bool live() const;
+    Qt::ScreenOrientation orientation() const;
     SessionInterface *session() const;
 
     Q_INVOKABLE void release();
@@ -120,6 +122,7 @@
 
     bool isFirstFrameDrawn() const { return m_firstFrameDrawn; }
 
+    void setOrientation(const Qt::ScreenOrientation orientation);
     void setSession(SessionInterface *app);
 
     // to allow easy touch event injection from tests
@@ -132,6 +135,7 @@
     void typeChanged();
     void stateChanged();
     void nameChanged();
+    void orientationChanged();
     void liveChanged(bool live);
     void firstFrameDrawn(MirSurfaceItem *item);
 
@@ -191,6 +195,7 @@
     QPointer<SessionInterface> m_session;
     bool m_firstFrameDrawn;
     bool m_live;
+    Qt::ScreenOrientation m_orientation; //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
 
     QMirSurfaceTextureProvider *m_textureProvider;
 
 
=== modified file 'src/platforms/mirserver/logging.h'
--- src/platforms/mirserver/logging.h	2014-09-07 19:42:14 +0000
+++ src/platforms/mirserver/logging.h	2014-09-19 12:20:29 +0000
@@ -22,6 +22,7 @@
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SESSIONS)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SURFACES)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_MESSAGES)
+Q_DECLARE_LOGGING_CATEGORY(QTMIR_SENSOR_MESSAGES)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_INPUT)
 
 #endif // UBUNTU_APPLICATION_PLUGIN_LOGGING_H
 
=== modified file 'src/platforms/mirserver/mirserverintegration.cpp'
--- src/platforms/mirserver/mirserverintegration.cpp	2014-07-08 18:23:45 +0000
+++ src/platforms/mirserver/mirserverintegration.cpp	2014-09-19 12:20:29 +0000
@@ -80,6 +80,17 @@
     }
     argv[args.size()] = '\0';
 
+    // For access to sensors, qtmir uses qtubuntu-sensors. qtubuntu-sensors reads the
+    // UBUNTU_PLATFORM_API_BACKEND variable to decide if to load a valid sensor backend or not.
+    // For it to function we need to ensure a valid backend has been specified
+    if (qEnvironmentVariableIsEmpty("UBUNTU_PLATFORM_API_BACKEND")) {
+        if (qgetenv("DESKTOP_SESSION").contains("mir")) {
+            qputenv("UBUNTU_PLATFORM_API_BACKEND", "desktop_mirserver");
+        } else {
+            qputenv("UBUNTU_PLATFORM_API_BACKEND", "touch_mirserver");
+        }
+    }
+
     m_mirConfig = QSharedPointer<MirServerConfiguration>(
                       new MirServerConfiguration(args.length(), const_cast<const char**>(argv)));
 
 
=== modified file 'src/platforms/mirserver/screen.cpp'
--- src/platforms/mirserver/screen.cpp	2014-07-08 18:31:50 +0000
+++ src/platforms/mirserver/screen.cpp	2014-09-19 12:20:29 +0000
@@ -18,8 +18,11 @@
  *   Gerry Boland <[e-mail]>
  */
 
+// local
 #include "screen.h"
+#include "logging.h"
 
+// Mir
 #include "mir/geometry/size.h"
 
 // Qt
@@ -29,8 +32,14 @@
 #include <QtSensors/QOrientationReading>
 #include <QThread>
 
+// Qt sensors
+#include <QtSensors/QOrientationReading>
+#include <QtSensors/QOrientationSensor>
+
 namespace mg = mir::geometry;
 
+Q_LOGGING_CATEGORY(QTMIR_SENSOR_MESSAGES, "qtmir.sensor")
+
 namespace {
 bool isLittleEndian() {
     unsigned int i = 1;
@@ -80,16 +89,42 @@
 
 } // namespace {
 
+
+class OrientationReadingEvent : public QEvent {
+public:
+    OrientationReadingEvent(QEvent::Type type, QOrientationReading::Orientation orientation)
+        : QEvent(type)
+        , m_orientation(orientation) {
+    }
+
+    static const QEvent::Type m_type;
+    QOrientationReading::Orientation m_orientation;
+};
+
+const QEvent::Type OrientationReadingEvent::m_type =
+        static_cast<QEvent::Type>(QEvent::registerEventType());
+
+
+
 Screen::Screen(mir::graphics::DisplayConfigurationOutput const &screen)
     : QObject(nullptr)
+    , m_orientationSensor(new QOrientationSensor(this))
 {
     readMirDisplayConfiguration(screen);
 
     // Set the default orientation based on the initial screen dimmensions.
     m_nativeOrientation = (m_geometry.width() >= m_geometry.height())
         ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
-
-    m_currentOrientation = m_nativeOrientation;
+    qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen - nativeOrientation is:" << m_nativeOrientation;
+
+    // If it's a landscape device (i.e. some tablets), start in landscape, otherwise portrait
+    m_currentOrientation = (m_nativeOrientation == Qt::LandscapeOrientation)
+            ? Qt::LandscapeOrientation : Qt::PortraitOrientation;
+    qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen - initial currentOrientation is:" << m_currentOrientation;
+
+    QObject::connect(m_orientationSensor, &QOrientationSensor::readingChanged,
+                     this, &Screen::onOrientationReadingChanged);
+    m_orientationSensor->start();
 }
 
 void Screen::readMirDisplayConfiguration(mir::graphics::DisplayConfigurationOutput const &screen)
@@ -111,3 +146,61 @@
 
     m_refreshRate = mode.vrefresh_hz;
 }
+
+// FIXME: nothing is using this method yet, but we should turn off sensors when display is off.
+void Screen::toggleSensors(const bool enable) const
+{
+    qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen::toggleSensors - enable=" << enable;
+    if (enable) {
+        m_orientationSensor->start();
+    } else {
+        m_orientationSensor->stop();
+    }
+}
+
+void Screen::customEvent(QEvent* event)
+{
+    OrientationReadingEvent* oReadingEvent = static_cast<OrientationReadingEvent*>(event);
+    switch (oReadingEvent->m_orientation) {
+        case QOrientationReading::LeftUp: {
+            m_currentOrientation = (m_nativeOrientation == Qt::LandscapeOrientation) ?
+                        Qt::InvertedPortraitOrientation : Qt::LandscapeOrientation;
+            break;
+        }
+        case QOrientationReading::TopUp: {
+            m_currentOrientation = (m_nativeOrientation == Qt::LandscapeOrientation) ?
+                        Qt::LandscapeOrientation : Qt::PortraitOrientation;
+            break;
+        }
+        case QOrientationReading::RightUp: {
+            m_currentOrientation = (m_nativeOrientation == Qt::LandscapeOrientation) ?
+                        Qt::PortraitOrientation : Qt::InvertedLandscapeOrientation;
+            break;
+        }
+        case QOrientationReading::TopDown: {
+            m_currentOrientation = (m_nativeOrientation == Qt::LandscapeOrientation) ?
+                        Qt::InvertedLandscapeOrientation : Qt::InvertedPortraitOrientation;
+            break;
+        }
+        default: {
+            qWarning("Unknown orientation.");
+            event->accept();
+            return;
+        }
+    }
+
+    // Raise the event signal so that client apps know the orientation changed
+    QWindowSystemInterface::handleScreenOrientationChange(screen(), m_currentOrientation);
+    event->accept();
+    qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen::customEvent - new orientation" << m_currentOrientation << "handled";
+}
+
+void Screen::onOrientationReadingChanged()
+{
+    qCDebug(QTMIR_SENSOR_MESSAGES) << "Screen::onOrientationReadingChanged";
+
+    // Make sure to switch to the main Qt thread context
+    QCoreApplication::postEvent(this, new OrientationReadingEvent(
+                                              OrientationReadingEvent::m_type,
+                                              m_orientationSensor->reading()->orientation()));
+}
 
=== modified file 'src/platforms/mirserver/screen.h'
--- src/platforms/mirserver/screen.h	2014-06-30 16:13:01 +0000
+++ src/platforms/mirserver/screen.h	2014-09-19 12:20:29 +0000
@@ -23,6 +23,7 @@
 #include <QObject>
 #include <QTimer>
 #include <qpa/qplatformscreen.h>
+
 #include "mir/graphics/display_configuration.h"
 
 class QOrientationSensor;
@@ -42,6 +43,14 @@
     Qt::ScreenOrientation nativeOrientation() const override { return m_nativeOrientation; }
     Qt::ScreenOrientation orientation() const override { return m_currentOrientation; }
 
+    void toggleSensors(const bool enable) const;
+
+    // QObject methods.
+    void customEvent(QEvent* event) override;
+
+public Q_SLOTS:
+   void onOrientationReadingChanged();
+
 private:
     void readMirDisplayConfiguration(mir::graphics::DisplayConfigurationOutput const&);
 
@@ -53,6 +62,7 @@
 
     Qt::ScreenOrientation m_nativeOrientation;
     Qt::ScreenOrientation m_currentOrientation;
+    QOrientationSensor *m_orientationSensor;
 };
 
 #endif // SCREEN_H