Merge lp:~jhodapp/media-hub/fix-1421620-rtm into lp:media-hub

[Jim Hodapp]

Fix the bug which caused music playback to start playing again after a phonecall hung up after being auto-paused by disconnecting a headphone jack

Fix the bug which caused music playback to start playing again after a phonecall hung up after being auto-paused by disconnecting a headphone jack

Unmerged revisions

88. By Jim Hodapp on 2015-03-31

Fix the bug which caused music playback to start playing again after a phonecall hung up after being auto-paused by disconnecting a headphone jack.

87. By Ricardo Salveti on 2015-03-31

releasing package media-hub version 2.0.0+15.04.20150120~rtm-0ubuntu1

=== modified file 'CMakeLists.txt'
=== modified file 'debian/changelog'
--- debian/changelog	2015-03-12 03:06:40 +0000
+++ debian/changelog	2015-03-31 21:19:24 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 media-hub (2.0.0+15.04.20150303-0ubuntu2) vivid; urgency=medium
 
   * debian/control:
@@ -122,6 +123,104 @@
 
  -- Ubuntu daily release <[e-mail]>  Tue, 04 Nov 2014 06:10:54 +0000
 
+=======
+media-hub (2.0.0+15.04.20150120~rtm-0ubuntu1) 14.09; urgency=low
+
+  [ Jim Hodapp ]
+  * Error reporting all the way up to the app level from the playbin
+    pipeline (LP: #1413824).
+
+  [ Ubuntu daily release ]
+  * New rebuild forced
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 20 Jan 2015 01:21:47 +0000
+
+media-hub (2.0.0+15.04.20150116-0ubuntu1) vivid; urgency=low
+
+  [ Jim Hodapp ]
+  * Don't auto-resume playback of videos after a phone call ends. (LP:
+    #1411273)
+
+ -- Ubuntu daily release <[e-mail]>  Fri, 16 Jan 2015 18:17:56 +0000
+
+media-hub (2.0.0+15.04.20150112.2-0ubuntu1) vivid; urgency=low
+
+  [ Ubuntu daily release ]
+  * New rebuild forced
+
+  [ Ricardo Salveti de Araujo ]
+  * service_implementation: adding debug for call started/ended signals.
+    Make sure account and connection are available when setting up
+    account manager (patch from Gustavo Boiko). call_monitor: don't
+    check caps when hooking up on/off signals, until bug 1409125 is
+    fixed. Enable parallel building . (LP: #1409125)
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 12 Jan 2015 21:38:39 +0000
+
+media-hub (2.0.0+15.04.20150108-0ubuntu1) vivid; urgency=low
+
+  [ Jim Hodapp ]
+  * Pause playback when recording begins. (LP: #1398047)
+
+  [ Ricardo Salveti de Araujo ]
+  * call_monitor.cpp: waiting for bridge to be up, and also protecting
+    the on_change call (LP: #1408137)
+
+ -- Ubuntu daily release <[e-mail]>  Thu, 08 Jan 2015 12:58:01 +0000
+
+media-hub (2.0.0+15.04.20141120.1-0ubuntu1) vivid; urgency=low
+
+  [ Jim Hodapp ]
+  * Pause playback when a headphone is unplugged or an A2DP device is
+    unpaired (LP: #1368300)
+
+  [ Ricardo Mendoza ]
+  * Pause playback when a headphone is unplugged or an A2DP device is
+    unpaired (LP: #1368300)
+
+ -- Ubuntu daily release <[e-mail]>  Thu, 20 Nov 2014 18:33:08 +0000
+
+media-hub (2.0.0+15.04.20141111-0ubuntu1) vivid; urgency=low
+
+  [ Ubuntu daily release ]
+  * New rebuild forced
+
+  [ Justin McPherson ]
+  * #1239432 Music fails to pause on incoming/outgoing calls (LP:
+    #1239432)
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 11 Nov 2014 20:18:50 +0000
+
+media-hub (2.0.0+15.04.20141110.1-0ubuntu1) vivid; urgency=low
+
+  [ thomas-voss ]
+  * Bump build dependency on dbus-cpp to pull in exception safe dtor.
+    (LP: #1390618)
+
+ -- Ubuntu daily release <[e-mail]>  Mon, 10 Nov 2014 11:53:11 +0000
+
+media-hub (2.0.0+15.04.20141105.1-0ubuntu1) vivid; urgency=low
+
+  [ Ricardo Mendoza ]
+  * Use new hybris interface to correctly register for client deaths.
+    (LP: #1380848)
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 05 Nov 2014 20:41:14 +0000
+
+media-hub (2.0.0+15.04.20141105-0ubuntu1) vivid; urgency=low
+
+  [ thomas-voss ]
+  * Disconnect signal translation layer on destruction. (LP: #1386803)
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 05 Nov 2014 08:24:08 +0000
+
+media-hub (2.0.0+15.04.20141104-0ubuntu1) vivid; urgency=low
+
+  * New rebuild forced
+
+ -- Ubuntu daily release <[e-mail]>  Tue, 04 Nov 2014 06:10:54 +0000
+
+>>>>>>> MERGE-SOURCE
 media-hub (2.0.0+14.10.20141030~rtm-0ubuntu1) 14.09; urgency=low
 
   [ thomas-voss ]

=== modified file 'debian/control'
--- debian/control	2015-03-12 03:06:29 +0000
+++ debian/control	2015-03-31 21:19:24 +0000
@@ -26,10 +26,17 @@
                libproperties-cpp-dev,
                libgstreamer1.0-dev,
                pkg-config,
+<<<<<<< TREE
                libpulse-dev,
                qtbase5-dev,
                libtelepathy-qt5-dev,
 Standards-Version: 3.9.6
+=======
+               libpulse-dev,
+               qtbase5-dev,
+               libtelepathy-qt5-dev,
+Standards-Version: 3.9.5
+>>>>>>> MERGE-SOURCE
 Homepage: https://launchpad.net/media-hub
 # If you aren't a member of ~phablet-team but need to upload packaging changes,
 # just go ahead.  ~phablet-team will notice and sync up the code again.

=== modified file 'include/core/media/player.h'
--- include/core/media/player.h	2015-01-19 21:48:01 +0000
+++ include/core/media/player.h	2015-03-31 21:19:24 +0000
@@ -95,6 +95,7 @@
         rotate270
     };
 
+<<<<<<< TREE
     enum Lifetime
     {
         normal,
@@ -111,6 +112,18 @@
         service_missing_error
     };
 
+=======
+    enum Error
+    {
+        no_error,
+        resource_error,
+        format_error,
+        network_error,
+        access_denied_error,
+        service_missing_error
+    };
+
+>>>>>>> MERGE-SOURCE
     Player(const Player&) = delete;
     virtual ~Player();
 

=== added directory 'src/core/media/call-monitor'
=== renamed directory 'src/core/media/call-monitor' => 'src/core/media/call-monitor.moved'
=== added file 'src/core/media/call-monitor/CMakeLists.txt'
--- src/core/media/call-monitor/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ src/core/media/call-monitor/CMakeLists.txt	2015-03-31 21:19:24 +0000
@@ -0,0 +1,23 @@
+SET (CMAKE_INCLUDE_CURRENT_DIR ON)
+SET (CMAKE_AUTOMOC ON)
+
+find_package(Qt5Core REQUIRED)
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(TP_QT5 REQUIRED TelepathyQt5)
+
+#set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -pedantic -Wextra -fPIC -pthread")
+
+include_directories(
+    ${TP_QT5_INCLUDE_DIRS}
+)
+
+add_library(call-monitor STATIC
+    call_monitor.cpp
+    qtbridge.cpp
+)
+
+target_link_libraries(call-monitor
+    ${TP_QT5_LIBRARIES}
+)
+
+qt5_use_modules(call-monitor Core DBus)

=== added file 'src/core/media/call-monitor/call_monitor.cpp'
--- src/core/media/call-monitor/call_monitor.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/call-monitor/call_monitor.cpp	2015-03-31 21:19:24 +0000
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *      Author: Justin McPherson <[e-mail]>
+ */
+
+
+#include "call_monitor.h"
+
+#include "qtbridge.h"
+#include <TelepathyQt/AccountManager>
+#include <TelepathyQt/SimpleCallObserver>
+#include <TelepathyQt/PendingOperation>
+#include <TelepathyQt/PendingReady>
+#include <TelepathyQt/PendingAccount>
+
+#include <list>
+#include <mutex>
+
+
+namespace {
+class TelepathyCallMonitor : public QObject
+{
+    Q_OBJECT
+public:
+    TelepathyCallMonitor(const Tp::AccountPtr& account):
+        mAccount(account),
+        mCallObserver(Tp::SimpleCallObserver::create(mAccount)) {
+        connect(mCallObserver.data(), SIGNAL(callStarted(Tp::CallChannelPtr)), SIGNAL(offHook()));
+        connect(mCallObserver.data(), SIGNAL(callEnded(Tp::CallChannelPtr,QString,QString)), SIGNAL(onHook()));
+        connect(mCallObserver.data(), SIGNAL(streamedMediaCallStarted(Tp::StreamedMediaChannelPtr)), SIGNAL(offHook()));
+        connect(mCallObserver.data(), SIGNAL(streamedMediaCallEnded(Tp::StreamedMediaChannelPtr,QString,QString)), SIGNAL(onHook()));
+    }
+
+Q_SIGNALS:
+    void offHook();
+    void onHook();
+
+private:
+    Tp::AccountPtr mAccount;
+    Tp::SimpleCallObserverPtr mCallObserver;
+};
+
+
+class TelepathyBridge : public QObject
+{
+    Q_OBJECT
+public:
+    TelepathyBridge():
+        QObject(0) {
+        Tp::registerTypes();
+
+        QTimer::singleShot(0, this, SLOT(accountManagerSetup()));
+    }
+
+    ~TelepathyBridge() {
+        for (std::list<TelepathyCallMonitor*>::iterator it = mCallMonitors.begin();
+            it != mCallMonitors.end();
+            ++it) {
+            delete *it;
+        }
+    }
+
+    void on_change(const std::function<void(CallMonitor::State)>& func) {
+        std::lock_guard<std::mutex> l(cb_lock);
+        cb = func;
+    }
+
+private Q_SLOTS:
+    void accountManagerSetup() {
+        mAccountManager = Tp::AccountManager::create(Tp::AccountFactory::create(QDBusConnection::sessionBus(),
+                                                                                Tp::Account::FeatureCore),
+                                                     Tp::ConnectionFactory::create(QDBusConnection::sessionBus(),
+                                                                                   Tp::Connection::FeatureCore));
+        connect(mAccountManager->becomeReady(),
+                SIGNAL(finished(Tp::PendingOperation*)),
+                SLOT(accountManagerReady(Tp::PendingOperation*)));
+    }
+
+    void accountManagerReady(Tp::PendingOperation* operation) {
+        if (operation->isError()) {
+            std::cerr << "TelepathyBridge: Operation failed (accountManagerReady)" << std::endl;
+            QTimer::singleShot(1000, this, SLOT(accountManagerSetup())); // again
+            return;
+        }
+
+        Q_FOREACH(const Tp::AccountPtr& account, mAccountManager->allAccounts()) {
+            connect(account->becomeReady(Tp::Account::FeatureCapabilities),
+                    SIGNAL(finished(Tp::PendingOperation*)),
+                    SLOT(accountReady(Tp::PendingOperation*)));
+        }
+
+        connect(mAccountManager.data(), SIGNAL(newAccount(Tp::AccountPtr)), SLOT(newAccount(Tp::AccountPtr)));
+    }
+
+    void newAccount(const Tp::AccountPtr& account)
+    {
+        connect(account->becomeReady(Tp::Account::FeatureCapabilities),
+                SIGNAL(finished(Tp::PendingOperation*)),
+                SLOT(accountReady(Tp::PendingOperation*)));
+    }
+
+    void accountReady(Tp::PendingOperation* operation) {
+        if (operation->isError()) {
+            std::cerr << "TelepathyAccount: Operation failed (accountReady)" << std::endl;
+            return;
+        }
+
+        Tp::PendingReady* pendingReady = qobject_cast<Tp::PendingReady*>(operation);
+        if (pendingReady == 0) {
+            std::cerr << "Rejecting account because could not understand ready status" << std::endl;
+            return;
+        }
+
+        checkAndAddAccount(Tp::AccountPtr::qObjectCast(pendingReady->proxy()));
+    }
+
+    void offHook()
+    {
+        std::lock_guard<std::mutex> l(cb_lock);
+        if (cb)
+            cb(CallMonitor::OffHook);
+    }
+
+    void onHook()
+    {
+        std::lock_guard<std::mutex> l(cb_lock);
+        if (cb)
+            cb(CallMonitor::OnHook);
+    }
+
+private:
+    std::mutex cb_lock;
+    std::function<void (CallMonitor::State)>   cb;
+    Tp::AccountManagerPtr mAccountManager;
+    std::list<TelepathyCallMonitor*> mCallMonitors;
+
+    void checkAndAddAccount(const Tp::AccountPtr& account)
+    {
+        Tp::ConnectionCapabilities caps = account->capabilities();
+        // TODO: Later on we will need to filter for the right capabilities, and also allow dynamic account detection
+        // Don't check caps for now as a workaround for https://bugs.launchpad.net/ubuntu/+source/media-hub/+bug/1409125
+        // at least until we are able to find out the root cause of it (check rev 107 for the caps check)
+        auto tcm = new TelepathyCallMonitor(account);
+        connect(tcm, SIGNAL(offHook()), SLOT(offHook()));
+        connect(tcm, SIGNAL(onHook()), SLOT(onHook()));
+        mCallMonitors.push_back(tcm);
+    }
+};
+}
+
+class CallMonitorPrivate
+{
+public:
+    CallMonitorPrivate() {
+        mBridge = nullptr;
+        try {
+            std::thread([this]() {
+                qt::core::world::build_and_run(0, nullptr, [this]() {
+                    qt::core::world::enter_with_task([this]() {
+                        std::cout << "CallMonitor: Creating TelepathyBridge" << std::endl;
+                        mBridge = new TelepathyBridge();
+                        cv.notify_all();
+                    });
+                });
+            }).detach();
+        } catch(const std::system_error& error) {
+            std::cerr << "exception(std::system_error) in CallMonitor thread start" << error.what() << std::endl;
+        } catch(...) {
+            std::cerr << "exception(...) in CallMonitor thread start" << std::endl;
+        }
+        // Wait until telepathy bridge is set, so we can hook up the change signals
+        std::unique_lock<std::mutex> lck(mtx);
+        cv.wait_for(lck, std::chrono::seconds(3));
+    }
+
+    ~CallMonitorPrivate() {
+        qt::core::world::destroy();
+    }
+
+    TelepathyBridge *mBridge;
+
+private:
+    std::mutex mtx;
+    std::condition_variable cv;
+};
+
+
+CallMonitor::CallMonitor():
+    d(new CallMonitorPrivate)
+{
+}
+
+CallMonitor::~CallMonitor()
+{
+    delete d->mBridge;
+    delete d;
+}
+
+void CallMonitor::on_change(const std::function<void(CallMonitor::State)>& func)
+{
+    if (d->mBridge != nullptr) {
+        std::cout << "CallMonitor: Setting up callback for TelepathyBridge on_change" << std::endl;
+        d->mBridge->on_change(func);
+    } else
+        std::cerr << "TelepathyBridge: Failed to hook on_change signal, bridge not yet set" << std::endl;
+}
+
+#include "call_monitor.moc"
+

=== added file 'src/core/media/call-monitor/call_monitor.h'
--- src/core/media/call-monitor/call_monitor.h	1970-01-01 00:00:00 +0000
+++ src/core/media/call-monitor/call_monitor.h	2015-03-31 21:19:24 +0000
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *      Author: Justin McPherson <[e-mail]>
+ */
+
+
+#ifndef CALLMONITOR_H
+#define CALLMONITOR_H
+
+#include <functional>
+
+class CallMonitorPrivate;
+
+class CallMonitor
+{
+public:
+    enum State { OffHook, OnHook };
+
+    CallMonitor();
+    ~CallMonitor();
+
+    void on_change(const std::function<void(CallMonitor::State)>& func);
+
+private:
+    CallMonitorPrivate *d;
+};
+
+#endif // CALLMONITOR_H

=== added file 'src/core/media/call-monitor/qtbridge.cpp'
--- src/core/media/call-monitor/qtbridge.cpp	1970-01-01 00:00:00 +0000
+++ src/core/media/call-monitor/qtbridge.cpp	2015-03-31 21:19:24 +0000
@@ -0,0 +1,186 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ *              Thomas Voß <[e-mail]>
+ */
+
+#include "qtbridge.h"
+
+#include<QCoreApplication>
+#include<QNetworkAccessManager>
+#include<QNetworkRequest>
+#include<QNetworkReply>
+#include<QThread>
+#include<QDebug>
+
+#include <iostream>
+
+namespace
+{
+QCoreApplication* app = nullptr;
+}
+
+namespace qt
+{
+namespace core
+{
+namespace world
+{
+namespace detail
+{
+QEvent::Type qt_core_world_task_event_type()
+{
+    static QEvent::Type event_type = static_cast<QEvent::Type>(QEvent::registerEventType());
+    return event_type;
+}
+
+class TaskEvent : public QEvent
+{
+public:
+    TaskEvent(const std::function<void()>& task)
+        : QEvent(qt_core_world_task_event_type()),
+          task(task)
+    {
+    }
+
+    void run()
+    {
+        try
+        {
+            task();
+            promise.set_value();
+        } catch(...)
+        {
+            promise.set_exception(std::current_exception());
+        }
+    }
+
+    std::future<void> get_future()
+    {
+        return promise.get_future();
+    }
+
+private:
+    std::function<void()> task;
+    std::promise<void> promise;
+};
+
+class TaskHandler : public QObject
+{
+    Q_OBJECT
+
+public:
+    TaskHandler(QObject* parent) : QObject(parent)
+    {
+    }
+
+    bool event(QEvent* e);
+};
+
+
+
+void createCoreApplicationInstanceWithArgs(int argc, char** argv)
+{
+    app = new QCoreApplication(argc, argv);
+}
+
+void destroyCoreApplicationInstace()
+{
+    delete app;
+}
+
+QCoreApplication* coreApplicationInstance()
+{
+    return app;
+}
+
+TaskHandler* task_handler()
+{
+    static TaskHandler* instance = new TaskHandler(coreApplicationInstance());
+    return instance;
+}
+
+bool TaskHandler::event(QEvent *e)
+{
+    if (e->type() != qt_core_world_task_event_type())
+        return QObject::event(e);
+
+    auto te = dynamic_cast<TaskEvent*>(e);
+    if (te)
+    {
+        te->run();
+        return true;
+    }
+
+    return false;
+}
+}
+
+void build_and_run(int argc, char** argv, const std::function<void()>& ready)
+{
+    QThread::currentThread();
+    if (QCoreApplication::instance() != nullptr)
+        throw std::runtime_error(
+                "qt::core::world::build_and_run: "
+                "There is already a QCoreApplication running.");
+
+    detail::createCoreApplicationInstanceWithArgs(argc, argv);
+
+    detail::task_handler()->moveToThread(
+                detail::coreApplicationInstance()->thread());
+
+    // Signal to other worlds that we are good to go.
+    ready();
+
+    detail::coreApplicationInstance()->exec();
+
+    // Someone has called quit and we clean up on the correct thread here.
+    detail::destroyCoreApplicationInstace();
+}
+
+void destroy()
+{
+    enter_with_task([]()
+    {
+        // We make sure that all tasks have completed before quitting the app.
+        QEventLoopLocker locker;
+    }).wait_for(std::chrono::seconds{1});
+}
+
+std::future<void> enter_with_task(const std::function<void()>& task)
+{
+    QCoreApplication* instance = QCoreApplication::instance();
+
+    if (!instance)
+    {
+        throw std::runtime_error("Qt world has not been built before calling this function.");
+    }
+
+    detail::TaskEvent* te = new detail::TaskEvent(task);
+    auto future = te->get_future();
+
+    // We hand over ownership of te here. The event is deleted later after it has
+    // been processed by the event loop.
+    instance->postEvent(detail::task_handler(), te);
+
+    return future;
+}
+
+}
+}
+}
+
+#include "qtbridge.moc"

=== added file 'src/core/media/call-monitor/qtbridge.h'
--- src/core/media/call-monitor/qtbridge.h	1970-01-01 00:00:00 +0000
+++ src/core/media/call-monitor/qtbridge.h	2015-03-31 21:19:24 +0000
@@ -0,0 +1,87 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Jussi Pakkanen <[e-mail]>
+ *              Thomas Voß <[e-mail]>
+ */
+
+#ifndef QT_CORE_WORLD_BRIDGE_H_
+#define QT_CORE_WORLD_BRIDGE_H_
+
+#include <QObject>
+
+#include <functional>
+#include <future>
+#include <iostream>
+
+namespace qt
+{
+namespace core
+{
+namespace world
+{
+/**
+ * @brief Sets up the Qt core world and executes its event loop. Blocks until destroy() is called.
+ * @param argc Number of arguments in argv.
+ * @param argv Array of command-line arguments.
+ * @param ready Functor be called when the world has been setup and is about to be executed.
+ * @throw std::runtime_error in case of errors.
+ */
+void build_and_run(int argc, char** argv, const std::function<void()>& ready);
+
+/**
+ * @brief Destroys the Qt core world and quits its event loop.
+ */
+void destroy();
+
+/**
+ * @brief Enters the Qt core world and schedules the given task for execution.
+ * @param task The task to be executed in the Qt core world.
+ * @return A std::future that can be waited for to synchronize to the world's internal event loop.
+ */
+std::future<void> enter_with_task(const std::function<void()>& task);
+
+
+/**
+ * @brief Enters the Qt core world and schedules the given task for execution.
+ * @param task The task to be executed in the Qt core world.
+ * @return A std::future that can be waited for to get hold of the result of the task.
+ */
+template<typename T>
+inline std::future<T> enter_with_task_and_expect_result(const std::function<T()>& task)
+{
+    std::shared_ptr<std::promise<T>> promise = std::make_shared<std::promise<T>>();
+    std::future<T> future = promise->get_future();
+
+    auto t = [promise, task]()
+    {
+        try
+        {
+            promise->set_value(task());
+        } catch(...)
+        {
+            promise->set_exception(std::current_exception());
+        }
+    };
+
+    enter_with_task(t);
+
+    return future;
+}
+}
+}
+}
+
+#endif // QT_CORE_WORLD_BRIDGE_H_

=== modified file 'src/core/media/codec.h'
--- src/core/media/codec.h	2015-01-13 14:18:59 +0000
+++ src/core/media/codec.h	2015-03-31 21:19:24 +0000
@@ -230,6 +230,7 @@
     }
 };
 
+<<<<<<< TREE
 namespace helper
 {
 template<>
@@ -310,6 +311,48 @@
     }
 };
 
+=======
+namespace helper
+{
+template<>
+struct TypeMapper<core::ubuntu::media::Player::Error>
+{
+    constexpr static ArgumentType type_value()
+    {
+        return core::dbus::ArgumentType::int16;
+    }
+    constexpr static bool is_basic_type()
+    {
+        return false;
+    }
+    constexpr static bool requires_signature()
+    {
+        return false;
+    }
+
+    static std::string signature()
+    {
+        static const std::string s = TypeMapper<std::int16_t>::signature();
+        return s;
+    }
+};
+}
+
+template<>
+struct Codec<core::ubuntu::media::Player::Error>
+{
+    static void encode_argument(core::dbus::Message::Writer& out, const core::ubuntu::media::Player::Error& in)
+    {
+        out.push_int16(static_cast<std::int16_t>(in));
+    }
+
+    static void decode_argument(core::dbus::Message::Reader& out, core::ubuntu::media::Player::Error& in)
+    {
+        in = static_cast<core::ubuntu::media::Player::Error>(out.pop_int16());
+    }
+};
+
+>>>>>>> MERGE-SOURCE
 }
 }
 

=== modified file 'src/core/media/engine.h'
=== modified file 'src/core/media/gstreamer/engine.cpp'
=== modified file 'src/core/media/gstreamer/engine.h'
=== modified file 'src/core/media/gstreamer/playbin.h'
--- src/core/media/gstreamer/playbin.h	2014-11-11 23:59:07 +0000
+++ src/core/media/gstreamer/playbin.h	2015-03-31 21:19:24 +0000
@@ -109,6 +109,7 @@
                     G_CALLBACK(about_to_finish),
                     this
                     );
+<<<<<<< TREE
 
         g_signal_connect(
                     pipeline,
@@ -117,6 +118,8 @@
                     this
                     );
 
+=======
+>>>>>>> MERGE-SOURCE
     }
 
     ~Playbin()

=== modified file 'src/core/media/mpris/player.h'
=== modified file 'src/core/media/player_implementation.cpp'
=== modified file 'src/core/media/player_implementation.h'
=== modified file 'src/core/media/player_skeleton.cpp'
=== modified file 'src/core/media/player_skeleton.h'
=== modified file 'src/core/media/player_stub.cpp'
=== modified file 'src/core/media/player_stub.h'
=== modified file 'src/core/media/service_implementation.cpp'
--- src/core/media/service_implementation.cpp	2015-01-16 17:17:30 +0000
+++ src/core/media/service_implementation.cpp	2015-03-31 21:19:24 +0000
@@ -35,6 +35,9 @@
 #include <map>
 #include <memory>
 #include <thread>
+#include <utility>
+
+#include <pulse/pulseaudio.h>
 
 #include <pulse/pulseaudio.h>
 
@@ -460,6 +463,7 @@
     int disp_cookie;
     std::shared_ptr<dbus::Object> uscreen_session;
     MediaRecorderObserver *observer;
+<<<<<<< TREE
 
     // Pulse-specific
     pa_mainloop_api *pulse_mainloop_api;
@@ -479,6 +483,29 @@
     core::Signal<void> pause_playback;
     std::unique_ptr<CallMonitor> call_monitor;
     std::list<media::Player::PlayerKey> paused_sessions;
+=======
+
+    // Pulse-specific
+    pa_mainloop_api *pulse_mainloop_api;
+    pa_threaded_mainloop *pulse_mainloop;
+    pa_context *pulse_context;
+    std::thread pulse_worker;
+    std::mutex pulse_mutex;
+    std::condition_variable pcv;
+    bool headphones_connected;
+    bool a2dp_connected;
+    std::tuple<int, int, std::string> active_sink;
+    int primary_idx;
+
+    // Gets signaled when both the headphone jack is removed or an A2DP device is
+    // disconnected and playback needs pausing. Also gets signaled when recording
+    // begins.
+    core::Signal<void> pause_playback;
+    std::unique_ptr<CallMonitor> call_monitor;
+    // Holds a pair of a Player key denoting what player to resume playback, and a bool
+    // for if it should be resumed after a phone call is hung up
+    std::list<std::pair<media::Player::PlayerKey, bool>> paused_sessions;
+>>>>>>> MERGE-SOURCE
 };
 
 media::ServiceImplementation::ServiceImplementation() : d(new Private())
@@ -488,7 +515,9 @@
         // When the battery level hits 10% or 5%, pause all multimedia sessions.
         // Playback will resume when the user clears the presented notification.
         if (level == "low" || level == "very_low")
-            pause_all_multimedia_sessions();
+            // Whatever player session is currently playing, make sure it is NOT resumed after
+            // a phonecall is hung up
+            pause_all_multimedia_sessions(false);
     });
 
     d->is_warning->changed().connect([this](const core::IndicatorPower::IsWarning::ValueType &notifying)
@@ -498,6 +527,7 @@
         if (!notifying)
             resume_multimedia_session();
     });
+<<<<<<< TREE
 
     d->pause_playback.connect([this]()
     {
@@ -518,6 +548,32 @@
             break;
         }
     });
+=======
+
+    d->pause_playback.connect([this]()
+    {
+        std::cout << "Got pause_playback signal, pausing all multimedia sessions" << std::endl;
+        // Whatever player session is currently playing, make sure it is NOT resumed after
+        // a phonecall is hung up
+        pause_all_multimedia_sessions(false);
+    });
+
+    d->call_monitor->on_change([this](CallMonitor::State state) {
+        switch (state) {
+        case CallMonitor::OffHook:
+            std::cout << "Got call started signal, pausing all multimedia sessions" << std::endl;
+            // Whatever player session is currently playing, make sure it gets resumed after
+            // a phonecall is hung up
+            pause_all_multimedia_sessions(true);
+            break;
+        case CallMonitor::OnHook:
+            std::cout << "Got call ended signal, resuming paused multimedia sessions" << std::endl;
+            // Don't auto-resume any paused video playback sessions
+            resume_paused_multimedia_sessions(false);
+            break;
+        }
+    });
+>>>>>>> MERGE-SOURCE
 }
 
 media::ServiceImplementation::~ServiceImplementation()
@@ -595,20 +651,27 @@
     });
 }
 
-void media::ServiceImplementation::pause_all_multimedia_sessions()
+void media::ServiceImplementation::pause_all_multimedia_sessions(bool resume_play_after_phonecall)
 {
-    enumerate_players([this](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
+    enumerate_players([this, resume_play_after_phonecall](const media::Player::PlayerKey& key, const std::shared_ptr<media::Player>& player)
                       {
                           if (player->playback_status() == Player::playing
                               && player->audio_stream_role() == media::Player::multimedia)
                           {
+<<<<<<< TREE
                               d->paused_sessions.push_back(key);
                               std::cout << "Pausing Player with key: " << key << std::endl;
+=======
+                              auto paused_player_pair = std::make_pair(key, resume_play_after_phonecall);
+                              d->paused_sessions.push_back(paused_player_pair);
+                              std::cout << "Pausing Player with key: " << key << std::endl;
+>>>>>>> MERGE-SOURCE
                               player->pause();
                           }
                       });
 }
 
+<<<<<<< TREE
 void media::ServiceImplementation::resume_paused_multimedia_sessions(bool resume_video_sessions)
 {
     std::for_each(d->paused_sessions.begin(), d->paused_sessions.end(), [this, resume_video_sessions](const media::Player::PlayerKey& key) {
@@ -623,6 +686,25 @@
     d->paused_sessions.clear();
 }
 
+=======
+void media::ServiceImplementation::resume_paused_multimedia_sessions(bool resume_video_sessions)
+{
+    std::for_each(d->paused_sessions.begin(), d->paused_sessions.end(),
+        [this, resume_video_sessions](const std::pair<media::Player::PlayerKey, bool> &paused_player_pair) {
+            const media::Player::PlayerKey key = paused_player_pair.first;
+            const bool resume_play_after_phonecall = paused_player_pair.second;
+            auto player = player_for_key(key);
+            // Only resume video playback if explicitly desired
+            if ((resume_video_sessions || player->is_audio_source()) && resume_play_after_phonecall)
+                player->play();
+            else
+                std::cout << "Not auto-resuming video player session or other type of player session." << std::endl;
+        });
+
+    d->paused_sessions.clear();
+}
+
+>>>>>>> MERGE-SOURCE
 void media::ServiceImplementation::resume_multimedia_session()
 {
     if (not has_player_for_key(d->resume_key))

=== modified file 'src/core/media/service_implementation.h'
--- src/core/media/service_implementation.h	2015-01-16 17:17:30 +0000
+++ src/core/media/service_implementation.h	2015-03-31 21:19:24 +0000
@@ -42,8 +42,13 @@
     void pause_other_sessions(Player::PlayerKey key);
 
 private:
+<<<<<<< TREE
     void pause_all_multimedia_sessions();
     void resume_paused_multimedia_sessions(bool resume_video_sessions = true);
+=======
+    void pause_all_multimedia_sessions(bool resume_play_after_phonecall);
+    void resume_paused_multimedia_sessions(bool resume_video_sessions = true);
+>>>>>>> MERGE-SOURCE
     void resume_multimedia_session();
 
     struct Private;

=== modified file 'src/core/media/service_skeleton.cpp'
=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-11-18 20:29:26 +0000
+++ tests/unit-tests/CMakeLists.txt	2015-03-31 21:19:24 +0000
@@ -41,8 +41,12 @@
     ${PC_GSTREAMER_1_0_LIBRARIES}
     ${PROCESS_CPP_LDFLAGS}
     ${GIO_LIBRARIES}
+<<<<<<< TREE
     ${PROCESS_CPP_LIBRARIES}
     ${PC_PULSE_AUDIO_LIBRARIES}
+=======
+    ${PC_PULSE_AUDIO_LIBRARIES}
+>>>>>>> MERGE-SOURCE
 
     gmock
     gmock_main

=== modified file 'tests/unit-tests/test-gstreamer-engine.cpp'
--- tests/unit-tests/test-gstreamer-engine.cpp	2015-03-03 22:41:22 +0000
+++ tests/unit-tests/test-gstreamer-engine.cpp	2015-03-31 21:19:24 +0000
@@ -155,6 +155,7 @@
                     std::chrono::seconds{10}));
 }
 
+<<<<<<< TREE
 TEST(GStreamerEngine, setting_uri_and_audio_playback_with_http_headers_works)
 {
     const std::string test_file{"/tmp/test-audio-1.ogg"};
@@ -222,6 +223,14 @@
     const std::string test_file_uri{"file:///tmp/test-audio.ogg"};
     std::remove(test_file.c_str());
     ASSERT_TRUE(test::copy_test_media_file_to("test-audio.ogg", test_file));
+=======
+TEST(GStreamerEngine, DISABLED_stop_pause_play_seek_audio_only_works)
+{
+    const std::string test_file{"/tmp/test.ogg"};
+    const std::string test_file_uri{"file:///tmp/test.ogg"};
+    std::remove(test_file.c_str());
+    ASSERT_TRUE(test::copy_test_mp3_file_to(test_file));
+>>>>>>> MERGE-SOURCE
 
     core::testing::WaitableStateTransition<core::ubuntu::media::Engine::State> wst(
                 core::ubuntu::media::Engine::State::ready);