Merge lp:~ahayzen/music-app/remix-queue-split into lp:music-app/remix

[Andrew Hayzen]

* Split the MusicQueue and MusicNowPlaying into two pages (still act like toggles though)

* Split the MusicQueue and MusicNowPlaying into two pages (still act like toggles though)

Note this is in prep for bottom edge development.

Please test both pages in great detail, remember things like header actions/multiselect etc :)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:741
http://91.189.93.70:8080/job/music-app-ci/1154/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-vivid/235
        deb: http://91.189.93.70:8080/job/generic-mediumtests-vivid/235/artifact/work/output/*zip*/output.zip
    SUCCESS: http://91.189.93.70:8080/job/music-app-vivid-amd64-ci/6

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/music-app-ci/1154/rebuild

review: Needs Fixing (continuous-integration)

[Victor Thompson (vthompson)]

When clicking on the toolbar while in Queue view the following error is produced:

file:///home/victor/Development/remix-queue-split/music-app.qml:1047: Error: Cannot assign to non-existent property "isListView"

review: Needs Fixing

[Victor Thompson (vthompson)]

This also causes the Queue to be rebuilt each time it is shown. Currently it is fairly distracting when it is doing so. Do we need to rebuild it each time?

Unmerged revisions

741. By Andrew Hayzen on 2014-11-15

* Split the MusicQueue and MusicNowPlaying into two pages (still act like toggles though)

=== modified file 'MusicNowPlaying.qml'
--- MusicNowPlaying.qml	2014-11-07 22:51:16 +0000
+++ MusicNowPlaying.qml	2014-11-15 22:18:22 +0000
@@ -17,181 +17,42 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import QtMultimedia 5.0
 import QtQuick 2.3
-import QtQuick.LocalStorage 2.0
 import Ubuntu.Components 1.1
 import Ubuntu.Thumbnailer 0.1
 import "common"
-import "common/ListItemActions"
-import "meta-database.js" as Library
-import "playlists.js" as Playlists
+
 
 MusicPage {
     id: nowPlaying
-    flickable: isListView ? queueListLoader.item : null  // Ensures that the header is shown in fullview
     objectName: "nowPlayingPage"
-    title: isListView ? i18n.tr("Queue") : i18n.tr("Now playing")
-    visible: false
-
-    property bool isListView: false
-
-    onIsListViewChanged: {
-        if (isListView) {  // When changing to the queue positionAt the currentIndex
-            // ensure the loader and listview is ready
-            if (queueListLoader.status === Loader.Ready) {
-                ensureListViewLoaded()
-            } else {
-                queueListLoader.onStatusChanged.connect(function() {
-                    if (queueListLoader.status === Loader.Ready) {
-                        ensureListViewLoaded()
-                    }
-                })
-            }
-        }
-    }
-
-    // Ensure that the listview has loaded before attempting to positionAt
-    function ensureListViewLoaded() {
-        if (queueListLoader.item.count === trackQueue.model.count) {
-            positionAt(player.currentIndex);
-        } else {
-            queueListLoader.item.onCountChanged.connect(function() {
-                if (queueListLoader.item.count === trackQueue.model.count) {
-                    positionAt(player.currentIndex);
-                }
-            })
-        }
-    }
-
-    // Position the view at the index
-    function positionAt(index) {
-        queueListLoader.item.positionViewAtIndex(index, ListView.Center);
-    }
-
-    state: isListView && queueListLoader.item.state === "multiselectable" ? "selection" : "default"
-    states: [
-        PageHeadState {
-            id: defaultState
-
-            name: "default"
-            actions: [
-                Action {
-                    objectName: "toggleView"
-                    iconName: "media-playlist"
-                    onTriggered: {
-                        isListView = !isListView
-                    }
-                },
-                Action {
-                    enabled: trackQueue.model.count > 0
-                    iconName: "add-to-playlist"
-                    text: i18n.tr("Add to playlist")
-                    visible: isListView
-                    onTriggered: {
-                        var items = []
-
-                        for (var i=0; i < trackQueue.model.count; i++) {
-                            items.push(makeDict(trackQueue.model.get(i)));
-                        }
-
-                        var comp = Qt.createComponent("MusicaddtoPlaylist.qml")
-                        var addToPlaylist = comp.createObject(mainPageStack, {"chosenElements": items});
-
-                        if (addToPlaylist == null) {  // Error Handling
-                            console.log("Error creating object");
-                        }
-
-                        mainPageStack.push(addToPlaylist)
-                    }
-                },
-                Action {
-                    enabled: trackQueue.model.count > 0
-                    iconName: "delete"
-                    objectName: "clearQueue"
-                    text: i18n.tr("Clear queue")
-                    visible: isListView
-                    onTriggered: {
-                        pageStack.pop()
-                        trackQueue.clear()
-                    }
-                }
-            ]
-            PropertyChanges {
-                target: nowPlaying.head
-                backAction: defaultState.backAction
-                actions: defaultState.actions
-            }
-        },
-        PageHeadState {
-            id: selectionState
-
-            name: "selection"
-            backAction: Action {
-                text: i18n.tr("Cancel selection")
-                iconName: "back"
-                onTriggered: queueListLoader.item.state = "normal"
-            }
-            actions: [
-                Action {
-                    text: i18n.tr("Select All")
-                    iconName: "select"
-                    onTriggered: {
-                        if (queueListLoader.item.selectedItems.length === trackQueue.model.count) {
-                            queueListLoader.item.clearSelection()
-                        } else {
-                            queueListLoader.item.selectAll()
-                        }
-                    }
-                },
-                Action {
-                    enabled: queueListLoader.item.selectedItems.length > 0
-                    iconName: "add-to-playlist"
-                    text: i18n.tr("Add to playlist")
-                    onTriggered: {
-                        var items = []
-
-                        for (var i=0; i < queueListLoader.item.selectedItems.length; i++) {
-                            items.push(makeDict(trackQueue.model.get(queueListLoader.item.selectedItems[i])));
-                        }
-
-                        var comp = Qt.createComponent("MusicaddtoPlaylist.qml")
-                        var addToPlaylist = comp.createObject(mainPageStack, {"chosenElements": items});
-
-                        if (addToPlaylist == null) {  // Error Handling
-                            console.log("Error creating object");
-                        }
-
-                        mainPageStack.push(addToPlaylist)
-
-                        queueListLoader.item.closeSelection()
-                    }
-                },
-                Action {
-                    enabled: queueListLoader.item.selectedItems.length > 0
-                    iconName: "delete"
-                    text: i18n.tr("Delete")
-                    onTriggered: {
-                        for (var i=0; i < queueListLoader.item.selectedItems.length; i++) {
-                            removeQueue(queueListLoader.item.selectedItems[i])
-                        }
-
-                        queueListLoader.item.closeSelection()
-                    }
-                }
-            ]
-            PropertyChanges {
-                target: nowPlaying.head
-                backAction: selectionState.backAction
-                actions: selectionState.actions
-            }
-        }
-    ]
+    title: i18n.tr("Now playing")
+
+    head {
+        actions: [
+            Action {
+                objectName: "toggleView"
+                iconName: "media-playlist"
+                onTriggered: {
+                    var comp = Qt.createComponent("MusicQueue.qml")
+                    var queue = comp.createObject(mainPageStack, {});
+
+                    if (queue == null) {  // Error Handling
+                        console.log("Error creating object");
+                    }
+
+                    mainPageStack.pop();
+                    mainPageStack.push(queue);
+
+                    queue.positionAtWhenReady();  // runs positionAt once queue is loaded
+                }
+            }
+        ]
+    }
 
     Item {
         id: fullview
         anchors.fill: parent
-        visible: !isListView
 
         BlurredBackground {
             id: blurredBackground
@@ -430,7 +291,7 @@
                     anchors.horizontalCenter: parent.horizontalCenter
                     opacity: emptyPage.noMusic ? .4 : 1
                     color: "white"
-                    name: player.playbackState === MediaPlayer.PlayingState ? "media-playback-pause" : "media-playback-start"
+                    name: player.isPlaying ? "media-playback-pause" : "media-playback-start"
                     objectName: "playShape"
                 }
             }
@@ -484,184 +345,4 @@
             }
         }
     }
-
-    function removeQueue(index)
-    {
-        var removedIndex = index
-
-        if (trackQueue.model.count === 1) {
-            player.stop()
-            musicToolbar.goBack()
-        } else if (index === player.currentIndex) {
-            player.nextSong(player.isPlaying);
-        }
-
-        trackQueue.model.remove(index);
-        Library.removeQueueItem(removedIndex);
-
-        if (removedIndex < player.currentIndex) {
-            // update index as the old has been removed
-            player.currentIndex -= 1;
-            queueIndex -= 1;
-        }
-    }
-
-    Loader {
-        id: queueListLoader
-        anchors {
-            fill: parent
-        }
-        asynchronous: true
-        sourceComponent: ListView {
-            id: queueList
-            anchors {
-                bottomMargin: units.gu(2)
-                fill: parent
-                topMargin: units.gu(2)
-            }
-            delegate: queueDelegate
-            footer: Item {
-                height: mainView.height - (styleMusic.common.expandHeight + queueList.currentHeight) + units.gu(8)
-            }
-            model: trackQueue.model
-            objectName: "nowPlayingqueueList"
-
-            property int normalHeight: units.gu(6)
-            property int transitionDuration: 250  // transition length of animations
-
-            onCountChanged: {
-                customdebug("Queue: Now has: " + queueList.count + " tracks")
-            }
-
-            // Requirements for ListItemWithActions
-            property var selectedItems: []
-
-            signal clearSelection()
-            signal closeSelection()
-            signal selectAll()
-
-            onClearSelection: selectedItems = []
-            onCloseSelection: {
-                clearSelection()
-                state = "normal"
-            }
-            onSelectAll: {
-                var tmp = selectedItems
-
-                for (var i=0; i < model.count; i++) {
-                    if (tmp.indexOf(i) === -1) {
-                        tmp.push(i)
-                    }
-                }
-
-                selectedItems = tmp
-            }
-            onVisibleChanged: {
-                if (!visible) {
-                    clearSelection(true)
-                }
-            }
-
-            Component.onCompleted: {
-                // FIXME: workaround for qtubuntu not returning values depending on the grid unit definition
-                // for Flickable.maximumFlickVelocity and Flickable.flickDeceleration
-                var scaleFactor = units.gridUnit / 8;
-                maximumFlickVelocity = maximumFlickVelocity * scaleFactor;
-                flickDeceleration = flickDeceleration * scaleFactor;
-            }
-
-            Component {
-                id: queueDelegate
-                ListItemWithActions {
-                    id: queueListItem
-                    color: player.currentIndex === index ? "#2c2c34" : "transparent"
-                    height: queueList.normalHeight
-                    objectName: "nowPlayingListItem" + index
-                    state: ""
-
-                    leftSideAction: Remove {
-                        onTriggered: removeQueue(index)
-                    }
-                    multiselectable: true
-                    reorderable: true
-                    rightSideActions: [
-                        AddToPlaylist{
-
-                        }
-                    ]
-
-                    onItemClicked: {
-                        customdebug("File: " + model.filename) // debugger
-                        trackQueueClick(index);  // toggle track state
-                    }
-                    onReorder: {
-                        console.debug("Move: ", from, to);
-
-                        trackQueue.model.move(from, to, 1);
-                        Library.moveQueueItem(from, to);
-
-                        // Maintain currentIndex with current song
-                        if (from === player.currentIndex) {
-                            player.currentIndex = to;
-                        }
-                        else if (from < player.currentIndex && to >= player.currentIndex) {
-                            player.currentIndex -= 1;
-                        }
-                        else if (from > player.currentIndex && to <= player.currentIndex) {
-                            player.currentIndex += 1;
-                        }
-
-                        queueIndex = player.currentIndex
-                    }
-
-                    Item {
-                        id: trackContainer;
-                        anchors {
-                            fill: parent
-                        }
-
-                        NumberAnimation {
-                            id: trackContainerReorderAnimation
-                            target: trackContainer;
-                            property: "anchors.leftMargin";
-                            duration: queueList.transitionDuration;
-                            to: units.gu(2)
-                        }
-
-                        NumberAnimation {
-                            id: trackContainerResetAnimation
-                            target: trackContainer;
-                            property: "anchors.leftMargin";
-                            duration: queueList.transitionDuration;
-                            to: units.gu(0.5)
-                        }
-
-                        MusicRow {
-                            id: musicRow
-                            height: parent.height
-                            column: Column {
-                                Label {
-                                    id: trackTitle
-                                    color: player.currentIndex === index ? UbuntuColors.blue
-                                                                            : styleMusic.common.music
-                                    fontSize: "small"
-                                    objectName: "titleLabel"
-                                    text: model.title
-                                }
-
-                                Label {
-                                    id: trackArtist
-                                    color: styleMusic.common.subtitle
-                                    fontSize: "x-small"
-                                    objectName: "artistLabel"
-                                    text: model.author
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        visible: isListView
-    }
 }

=== added file 'MusicQueue.qml'
--- MusicQueue.qml	1970-01-01 00:00:00 +0000
+++ MusicQueue.qml	2014-11-15 22:18:22 +0000
@@ -0,0 +1,368 @@
+/*
+ * Copyright (C) 2013, 2014
+ *      Andrew Hayzen <[e-mail]>
+ *      Daniel Holm <[e-mail]>
+ *      Victor Thompson <[e-mail]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program 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 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/>.
+ */
+
+import QtQuick 2.3
+import Ubuntu.Components 1.1
+import "common"
+import "common/ListItemActions"
+import "meta-database.js" as Library
+import "playlists.js" as Playlists
+
+
+MusicPage {
+    id: queuePage
+    flickable: queueListLoader.item
+    objectName: "queuePage"
+    title: i18n.tr("Queue")
+    state: queueListLoader.item.state === "multiselectable" ? "selection" : "default"
+    states: [
+        PageHeadState {
+            id: defaultState
+
+            name: "default"
+            actions: [
+                Action {
+                    objectName: "toggleView"
+                    iconName: "media-playlist"
+                    onTriggered: {
+                        var comp = Qt.createComponent("MusicNowPlaying.qml")
+                        var nowPlaying = comp.createObject(mainPageStack, {});
+
+                        if (nowPlaying == null) {  // Error Handling
+                            console.log("Error creating object");
+                        }
+
+                        mainPageStack.pop();
+                        mainPageStack.push(nowPlaying);
+                    }
+                },
+                Action {
+                    enabled: trackQueue.model.count > 0
+                    iconName: "add-to-playlist"
+                    text: i18n.tr("Add to playlist")
+                    onTriggered: {
+                        var items = []
+
+                        for (var i=0; i < trackQueue.model.count; i++) {
+                            items.push(makeDict(trackQueue.model.get(i)));
+                        }
+
+                        var comp = Qt.createComponent("MusicaddtoPlaylist.qml")
+                        var addToPlaylist = comp.createObject(mainPageStack, {"chosenElements": items});
+
+                        if (addToPlaylist == null) {  // Error Handling
+                            console.log("Error creating object");
+                        }
+
+                        mainPageStack.push(addToPlaylist)
+                    }
+                },
+                Action {
+                    enabled: trackQueue.model.count > 0
+                    iconName: "delete"
+                    objectName: "clearQueue"
+                    text: i18n.tr("Clear queue")
+                    onTriggered: {
+                        pageStack.pop()
+                        trackQueue.clear()
+                    }
+                }
+            ]
+            PropertyChanges {
+                target: queuePage.head
+                backAction: defaultState.backAction
+                actions: defaultState.actions
+            }
+        },
+        PageHeadState {
+            id: selectionState
+
+            name: "selection"
+            backAction: Action {
+                text: i18n.tr("Cancel selection")
+                iconName: "back"
+                onTriggered: queueListLoader.item.state = "normal"
+            }
+            actions: [
+                Action {
+                    text: i18n.tr("Select All")
+                    iconName: "select"
+                    onTriggered: {
+                        if (queueListLoader.item.selectedItems.length === trackQueue.model.count) {
+                            queueListLoader.item.clearSelection()
+                        } else {
+                            queueListLoader.item.selectAll()
+                        }
+                    }
+                },
+                Action {
+                    enabled: queueListLoader.item.selectedItems.length > 0
+                    iconName: "add-to-playlist"
+                    text: i18n.tr("Add to playlist")
+                    onTriggered: {
+                        var items = []
+
+                        for (var i=0; i < queueListLoader.item.selectedItems.length; i++) {
+                            items.push(makeDict(trackQueue.model.get(queueListLoader.item.selectedItems[i])));
+                        }
+
+                        var comp = Qt.createComponent("MusicaddtoPlaylist.qml")
+                        var addToPlaylist = comp.createObject(mainPageStack, {"chosenElements": items});
+
+                        if (addToPlaylist == null) {  // Error Handling
+                            console.log("Error creating object");
+                        }
+
+                        mainPageStack.push(addToPlaylist)
+
+                        queueListLoader.item.closeSelection()
+                    }
+                },
+                Action {
+                    enabled: queueListLoader.item.selectedItems.length > 0
+                    iconName: "delete"
+                    text: i18n.tr("Delete")
+                    onTriggered: {
+                        for (var i=0; i < queueListLoader.item.selectedItems.length; i++) {
+                            removeQueue(queueListLoader.item.selectedItems[i])
+                        }
+
+                        queueListLoader.item.closeSelection()
+                    }
+                }
+            ]
+            PropertyChanges {
+                target: queuePage.head
+                backAction: selectionState.backAction
+                actions: selectionState.actions
+            }
+        }
+    ]
+
+    // Ensure that the listview has loaded before attempting to positionAt
+    function ensureListViewLoaded() {
+        if (queueListLoader.item.count === trackQueue.model.count) {
+            positionAt(player.currentIndex);
+        } else {
+            queueListLoader.item.onCountChanged.connect(function() {
+                if (queueListLoader.item.count === trackQueue.model.count) {
+                    positionAt(player.currentIndex);
+                }
+            })
+        }
+    }
+
+    function removeQueue(index)
+    {
+        var removedIndex = index
+
+        if (trackQueue.model.count === 1) {
+            player.stop()
+            musicToolbar.goBack()
+        } else if (index === player.currentIndex) {
+            player.nextSong(player.isPlaying);
+        }
+
+        trackQueue.model.remove(index);
+        Library.removeQueueItem(removedIndex);
+
+        if (removedIndex < player.currentIndex) {
+            // update index as the old has been removed
+            player.currentIndex -= 1;
+            queueIndex -= 1;
+        }
+    }
+
+    // Position the view at the index
+    function positionAt(index) {
+        queueListLoader.item.positionViewAtIndex(index, ListView.Center);
+    }
+
+    // Ensure the loader is ready and the list is ready before positioning at
+    function positionAtWhenReady() {
+        // ensure the loader and listview is ready
+        if (queueListLoader.status === Loader.Ready) {
+            ensureListViewLoaded()
+        } else {
+            queueListLoader.onStatusChanged.connect(function() {
+                if (queueListLoader.status === Loader.Ready) {
+                    ensureListViewLoaded()
+                }
+            })
+        }
+    }
+
+    Loader {
+        id: queueListLoader
+        anchors {
+            fill: parent
+        }
+        asynchronous: true
+        sourceComponent: ListView {
+            id: queueList
+            anchors {
+                bottomMargin: units.gu(2)
+                fill: parent
+                topMargin: units.gu(2)
+            }
+            delegate: queueDelegate
+            footer: Item {
+                height: mainView.height - (styleMusic.common.expandHeight + queueList.currentHeight) + units.gu(8)
+            }
+            model: trackQueue.model
+            objectName: "queueListView"
+
+            property int normalHeight: units.gu(6)
+            property int transitionDuration: 250  // transition length of animations
+
+            onCountChanged: {
+                customdebug("Queue: Now has: " + queueList.count + " tracks")
+            }
+
+            // Requirements for ListItemWithActions
+            property var selectedItems: []
+
+            signal clearSelection()
+            signal closeSelection()
+            signal selectAll()
+
+            onClearSelection: selectedItems = []
+            onCloseSelection: {
+                clearSelection()
+                state = "normal"
+            }
+            onSelectAll: {
+                var tmp = selectedItems
+
+                for (var i=0; i < model.count; i++) {
+                    if (tmp.indexOf(i) === -1) {
+                        tmp.push(i)
+                    }
+                }
+
+                selectedItems = tmp
+            }
+            onVisibleChanged: {
+                if (!visible) {
+                    clearSelection(true)
+                }
+            }
+
+            Component.onCompleted: {
+                // FIXME: workaround for qtubuntu not returning values depending on the grid unit definition
+                // for Flickable.maximumFlickVelocity and Flickable.flickDeceleration
+                var scaleFactor = units.gridUnit / 8;
+                maximumFlickVelocity = maximumFlickVelocity * scaleFactor;
+                flickDeceleration = flickDeceleration * scaleFactor;
+            }
+
+            Component {
+                id: queueDelegate
+                ListItemWithActions {
+                    id: queueListItem
+                    color: player.currentIndex === index ? "#2c2c34" : "transparent"
+                    height: queueList.normalHeight
+                    objectName: "queueListItem" + index
+                    state: ""
+
+                    leftSideAction: Remove {
+                        onTriggered: removeQueue(index)
+                    }
+                    multiselectable: true
+                    reorderable: true
+                    rightSideActions: [
+                        AddToPlaylist{
+
+                        }
+                    ]
+
+                    onItemClicked: {
+                        customdebug("File: " + model.filename) // debugger
+                        trackQueueClick(index);  // toggle track state
+                    }
+                    onReorder: {
+                        console.debug("Move: ", from, to);
+
+                        trackQueue.model.move(from, to, 1);
+                        Library.moveQueueItem(from, to);
+
+                        // Maintain currentIndex with current song
+                        if (from === player.currentIndex) {
+                            player.currentIndex = to;
+                        }
+                        else if (from < player.currentIndex && to >= player.currentIndex) {
+                            player.currentIndex -= 1;
+                        }
+                        else if (from > player.currentIndex && to <= player.currentIndex) {
+                            player.currentIndex += 1;
+                        }
+
+                        queueIndex = player.currentIndex
+                    }
+
+                    Item {
+                        id: trackContainer;
+                        anchors {
+                            fill: parent
+                        }
+
+                        NumberAnimation {
+                            id: trackContainerReorderAnimation
+                            target: trackContainer;
+                            property: "anchors.leftMargin";
+                            duration: queueList.transitionDuration;
+                            to: units.gu(2)
+                        }
+
+                        NumberAnimation {
+                            id: trackContainerResetAnimation
+                            target: trackContainer;
+                            property: "anchors.leftMargin";
+                            duration: queueList.transitionDuration;
+                            to: units.gu(0.5)
+                        }
+
+                        MusicRow {
+                            id: musicRow
+                            height: parent.height
+                            column: Column {
+                                Label {
+                                    id: trackTitle
+                                    color: player.currentIndex === index ? UbuntuColors.blue
+                                                                            : styleMusic.common.music
+                                    fontSize: "small"
+                                    objectName: "titleLabel"
+                                    text: model.title
+                                }
+
+                                Label {
+                                    id: trackArtist
+                                    color: styleMusic.common.subtitle
+                                    fontSize: "x-small"
+                                    objectName: "artistLabel"
+                                    text: model.author
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

=== modified file 'tests/autopilot/music_app/__init__.py'
--- tests/autopilot/music_app/__init__.py	2014-11-07 22:54:20 +0000
+++ tests/autopilot/music_app/__init__.py	2014-11-15 22:18:22 +0000
@@ -21,28 +21,6 @@
     return func_wrapper
 
 
-def ensure_now_playing_full(func):
-    """Wrapper which ensures the now playing is full before clicking"""
-    def func_wrapper(self, *args, **kwargs):
-        if self.isListView:
-            self.click_toggle_view()
-
-        return func(self, *args, **kwargs)
-
-    return func_wrapper
-
-
-def ensure_now_playing_list(func):
-    """Wrapper which ensures the now playing is list before clicking"""
-    def func_wrapper(self, *args, **kwargs):
-        if not self.isListView:
-            self.click_toggle_view()
-
-        return func(self, *args, **kwargs)
-
-    return func_wrapper
-
-
 class MusicApp(object):
     """Autopilot helper object for the Music application."""
 
@@ -89,6 +67,10 @@
         return self.main_view.select_single("LibraryListModel",
                                             objectName="trackQueue").count
 
+    def get_queue_page(self):
+        return self.app.wait_select_single(MusicQueue,
+                                           objectName="queuePage")
+
     def get_songs_page(self):
         return self.app.wait_select_single(SongsPage, objectName="songsPage")
 
@@ -242,27 +224,22 @@
 
         self.visible.wait_for(True)
 
-    @ensure_now_playing_full
     @click_object
     def click_forward_button(self):
         return self.wait_select_single("*", objectName="forwardShape")
 
-    @ensure_now_playing_full
     @click_object
     def click_play_button(self):
         return self.wait_select_single("*", objectName="playShape")
 
-    @ensure_now_playing_full
     @click_object
     def click_previous_button(self):
         return self.wait_select_single("*", objectName="previousShape")
 
-    @ensure_now_playing_full
     @click_object
     def click_repeat_button(self):
         return self.wait_select_single("*", objectName="repeatShape")
 
-    @ensure_now_playing_full
     @click_object
     def click_shuffle_button(self):
         return self.wait_select_single("*", objectName="shuffleShape")
@@ -270,12 +247,6 @@
     def click_toggle_view(self):
         self.main_view.get_header().click_action_button("toggleView")
 
-    @ensure_now_playing_list
-    def get_track(self, i):
-        return (self.wait_select_single(ListItemWithActions,
-                objectName="nowPlayingListItem" + str(i)))
-
-    @ensure_now_playing_full
     def seek_to(self, percentage):
         progress_bar = self.wait_select_single(
             "*", objectName="progressSliderShape")
@@ -300,6 +271,21 @@
         self.player.shuffle.wait_for(state)
 
 
+class MusicQueue(MusicPage):
+    """ Autopilot helper for queue page """
+    def __init__(self, *args):
+        super(MusicPage, self).__init__(*args)
+
+        self.visible.wait_for(True)
+
+    def click_toggle_view(self):
+        self.main_view.get_header().click_action_button("toggleView")
+
+    def get_track(self, i):
+        return (self.wait_select_single(ListItemWithActions,
+                objectName="queueListItem" + str(i)))
+
+
 class AlbumsPage(MusicPage):
     """ Autopilot helper for the albums page """
     def __init__(self, *args):

=== modified file 'tests/autopilot/music_app/tests/test_music.py'
--- tests/autopilot/music_app/tests/test_music.py	2014-11-07 23:08:29 +0000
+++ tests/autopilot/music_app/tests/test_music.py	2014-11-15 22:18:22 +0000
@@ -95,8 +95,13 @@
         # Re get now playing page as it has changed
         now_playing_page = self.app.get_now_playing_page()
 
+        # Switch to the queue
+        now_playing_page.click_toggle_view()
+
         # verify song's metadata matches the item added to the Now Playing view
-        current_track = now_playing_page.get_track(self.player.currentIndex)
+        queue_page = self.app.get_queue_page()
+
+        current_track = queue_page.get_track(self.player.currentIndex)
 
         self.assertThat(current_track.get_label_text("artistLabel"),
                         Equals(self.tracks[0]["artist"]))
@@ -350,8 +355,13 @@
         # Re get now playing page as it has changed
         now_playing_page = self.app.get_now_playing_page()
 
+        # Switch to the queue
+        now_playing_page.click_toggle_view()
+
         # verify song's metadata matches the item added to the Now Playing view
-        current_track = now_playing_page.get_track(self.player.currentIndex)
+        queue_page = self.app.get_queue_page()
+
+        current_track = queue_page.get_track(self.player.currentIndex)
 
         self.assertThat(current_track.get_label_text("artistLabel"),
                         Equals(tracks[0]["artist"]))
@@ -385,8 +395,13 @@
                         Eventually(NotEquals(self.app.get_queue_count())))
         self.assertThat(self.player.isPlaying, Eventually(Equals(True)))
 
+        # Switch to the queue
+        now_playing_page.click_toggle_view()
+
         # verify song's metadata matches the item added to the Now Playing view
-        current_track = now_playing_page.get_track(self.player.currentIndex)
+        queue_page = self.app.get_queue_page()
+
+        current_track = queue_page.get_track(self.player.currentIndex)
 
         self.assertThat(current_track.get_label_text("artistLabel"),
                         Equals(self.tracks[0]["artist"]))
@@ -425,8 +440,13 @@
         # Re get now playing page as it has changed
         now_playing_page = self.app.get_now_playing_page()
 
+        # Switch to the queue
+        now_playing_page.click_toggle_view()
+
         # verify song's metadata matches the item added to the Now Playing view
-        current_track = now_playing_page.get_track(self.player.currentIndex)
+        queue_page = self.app.get_queue_page()
+
+        current_track = queue_page.get_track(self.player.currentIndex)
 
         self.assertThat(current_track.get_label_text("artistLabel"),
                         Equals(self.tracks[0]["artist"]))
@@ -527,8 +547,13 @@
                         Eventually(NotEquals(self.app.get_queue_count())))
         self.assertThat(self.player.isPlaying, Eventually(Equals(True)))
 
+        # Switch to the queue
+        now_playing_page.click_toggle_view()
+
         # verify song's metadata matches the item added to the Now Playing view
-        current_track = now_playing_page.get_track(self.player.currentIndex)
+        queue_page = self.app.get_queue_page()
+
+        current_track = queue_page.get_track(self.player.currentIndex)
 
         self.assertThat(current_track.get_label_text("artistLabel"),
                         Equals(tracks[0]["artist"]))
@@ -546,8 +571,14 @@
         # get initial queue count
         initial_queue_count = self.app.get_queue_count()
 
+        # Switch to the queue
+        now_playing_page.click_toggle_view()
+
+        # verify song's metadata matches the item added to the Now Playing view
+        queue_page = self.app.get_queue_page()
+
         # get track row and swipe to reveal swipe to delete
-        track = now_playing_page.get_track(0)
+        track = queue_page.get_track(0)
         track.swipe_to_delete()
 
         track.confirm_removal()  # confirm delete