Merge lp:~boiko/telephony-service/sync_ota5_fixes into lp:telephony-service

[Gustavo Pichorim Boiko]

Sync the fixes that were released in OTA5:

  [ Andreas Pokorny ]
  * sbuild fix

  [ Gustavo Pichorim Boiko ]
  * Do not update the pot file automatically on builds, it causes
    conflicts when multiple changes are applied together.

  [ Iain Lane ]
  * We don't inherit from the 'gnome' icon theme any more, so our icons
    weren't being found in a default Unity session using ubuntu-mono-
    dark. We do, however, inherit from Humanity, so put the icons under
    this theme. (LP: #1412709)

  [ Sebastien Bacher ]
  * Don't play keypad sounds in silentmode (LP: #1384274)
  * don't unref a non owned variant, g_variant_new_strv() returns a
    floating reference which is consumed by calling
    messaging_menu_message_add_action() thanks Lars Uebernickel for
    pointing the issue (LP: #1427286)

  [ Tiago Salem Herrmann ]
  * Check if targetContact() returns a valid pointer before using it.
    (LP: #1433068)

  [ Gustavo Pichorim Boiko ]
  * Prevent telephony-service from auto-accepting calls in the case of
    an approver failure. added: tests/approver/
    tests/approver/ApproverTest.cpp tests/approver/CMakeLists.txt
    tests/approver/approvercontroller.cpp
    tests/approver/approvercontroller.h

  [ Tiago Salem Herrmann ]
  * Do not let USSD and incoming call snap decisions timeout. Initialize
    m_notificationId with -1, as 0 is a valid id. Do not call
    CloseNotification() when notificationClosed() is received to avoid
    loop. (LP: #1453004)

Sync the fixes that were released in OTA5:

  [ Andreas Pokorny ]
  * sbuild fix

  [ Gustavo Pichorim Boiko ]
  * Do not update the pot file automatically on builds, it causes
    conflicts when multiple changes are applied together.

  [ Iain Lane ]
  * We don't inherit from the 'gnome' icon theme any more, so our icons
    weren't being found in a default Unity session using ubuntu-mono-
    dark. We do, however, inherit from Humanity, so put the icons under
    this theme. (LP: #1412709)

  [ Sebastien Bacher ]
  * Don't play keypad sounds in silentmode (LP: #1384274)
  * don't unref a non owned variant, g_variant_new_strv() returns a
    floating reference which is consumed by calling
    messaging_menu_message_add_action() thanks Lars Uebernickel for
    pointing the issue (LP: #1427286)

  [ Tiago Salem Herrmann ]
  * Check if targetContact() returns a valid pointer before using it.
    (LP: #1433068)

  [ Gustavo Pichorim Boiko ]
  * Prevent telephony-service from auto-accepting calls in the case of
    an approver failure. added: tests/approver/
    tests/approver/ApproverTest.cpp tests/approver/CMakeLists.txt
    tests/approver/approvercontroller.cpp
    tests/approver/approvercontroller.h

  [ Tiago Salem Herrmann ]
  * Do not let USSD and incoming call snap decisions timeout. Initialize
    m_notificationId with -1, as 0 is a valid id. Do not call
    CloseNotification() when notificationClosed() is received to avoid
    loop. (LP: #1453004)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1099
http://jenkins.qa.ubuntu.com/job/telephony-service-ci/491/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-vivid-amd64-ci/163/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-vivid-armhf-ci/159/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/telephony-service-vivid-i386-ci/159/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/telephony-service-ci/491/rebuild

review: Needs Fixing (continuous-integration)

[Tiago Salem Herrmann (tiagosh)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2015-05-21 18:02:42 +0000
+++ .bzrignore	2015-07-08 21:44:54 +0000
@@ -47,6 +47,7 @@
 
 tests/*/*Test
 tests/common/dbus-test-wrapper.sh
+tests/common/NotificationsMock
 tests/common/MockConnectionInterface.*
 tests/common/mock/mockconnectionadaptor.*
 tests/common/mock/telepathy-mock

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-06-10 21:05:50 +0000
+++ CMakeLists.txt	2015-07-08 21:44:54 +0000
@@ -12,6 +12,9 @@
 # Instruct CMake to run moc automatically when needed.
 set(CMAKE_AUTOMOC ON)
 
+# just to make debug easier, print the system processor
+message(STATUS "System processor: ${CMAKE_SYSTEM_PROCESSOR}")
+
 # Check if should build using ubuntu platform api
 check_include_file_cxx("ubuntu/application/init.h" USE_UBUNTU_PLATFORM_API)
 
@@ -47,6 +50,11 @@
     OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 
+# sbuild/cross-compilation fallback:
+if (QT_INSTALL_QML STREQUAL "")
+    set(QT_INSTALL_QML ${CMAKE_INSTALL_LIBDIR}/qt5/qml)
+endif()
+
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(TP_QT5 REQUIRED TelepathyQt5)
 pkg_check_modules(NOTIFY REQUIRED libnotify)

=== modified file 'approver/approver.cpp'
--- approver/approver.cpp	2015-06-10 21:05:50 +0000
+++ approver/approver.cpp	2015-07-08 21:44:54 +0000
@@ -334,8 +334,8 @@
         request->setFilter(QContactPhoneNumber::match(contact->id()));
 
         // lambda function to update the notification
-        QObject::connect(request, &QContactAbstractRequest::stateChanged, [this, request, dispatchOp, channel]() {
-            if (!request || request->state() != QContactAbstractRequest::FinishedState) {
+        QObject::connect(request, &QContactAbstractRequest::stateChanged, [this, request, dispatchOp, channel](QContactAbstractRequest::State state) {
+            if (!request || state != QContactAbstractRequest::FinishedState) {
                 return;
             }
 
@@ -349,7 +349,6 @@
                 // Also notify greeter via AccountsService
                 GreeterContacts::emitContact(contact);
             }
-
             showSnapDecision(dispatchOp, channel, contact);
         });
 
@@ -368,6 +367,8 @@
 {
     closeSnapDecision();
 
+    acceptCallChannels(dispatchOp);
+
     // forward the channel to the handler
     dispatchOp->handleWith(TELEPHONY_SERVICE_HANDLER);
 
@@ -386,6 +387,8 @@
         CallManager::instance()->foregroundCall()->endCall();
     }
 
+    acceptCallChannels(dispatchOp);
+
     // forward the channel to the handler
     dispatchOp->handleWith(TELEPHONY_SERVICE_HANDLER);
 
@@ -477,6 +480,9 @@
     notify_notification_set_hint_string(notification,
                                         "x-canonical-secondary-icon",
                                         "incoming-call");
+    notify_notification_set_hint_int32(notification,
+                                        "x-canonical-snap-decisions-timeout",
+                                        -1);
 
     QString acceptTitle = hasCalls ? C::gettext("Hold + Answer") :
                                      C::gettext("Accept");
@@ -551,6 +557,17 @@
     return true;
 }
 
+void Approver::acceptCallChannels(const Tp::ChannelDispatchOperationPtr dispatchOp)
+{
+    // accept all channels
+    Q_FOREACH(Tp::ChannelPtr channel, dispatchOp->channels()) {
+        Tp::CallChannelPtr callChannel = Tp::CallChannelPtr::dynamicCast(channel);
+        if (callChannel) {
+            callChannel->accept();
+        }
+    }
+}
+
 Tp::ChannelDispatchOperationPtr Approver::dispatchOperationForIncomingCall()
 {
     Tp::ChannelDispatchOperationPtr callDispatchOp;

=== modified file 'approver/approver.h'
--- approver/approver.h	2015-01-20 12:46:29 +0000
+++ approver/approver.h	2015-07-08 21:44:54 +0000
@@ -56,6 +56,7 @@
     bool showSnapDecision(const Tp::ChannelDispatchOperationPtr dispatchOperation,
                           const Tp::ChannelPtr channel,
                           const QContact &contact = QContact());
+    void acceptCallChannels(const Tp::ChannelDispatchOperationPtr dispatchOp);
     bool handleMediaKey(bool doubleClick);
 
 protected:

=== modified file 'cmake/modules/GenerateTest.cmake'
--- cmake/modules/GenerateTest.cmake	2015-06-02 20:39:25 +0000
+++ cmake/modules/GenerateTest.cmake	2015-07-08 21:44:54 +0000
@@ -77,7 +77,8 @@
                                     HISTORY_SQLITE_DBPATH=:memory:
                                     MC_ACCOUNT_DIR=${TMPDIR}
                                     MC_MANAGER_DIR=${TMPDIR}
-                                    MC_CLIENTS_DIR=${TMPDIR})
+                                    MC_CLIENTS_DIR=${TMPDIR}
+                                    TELEPHONY_SERVICE_TEST=1)
             endif ()
 
             set(TEST_COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} ${PLATFORM} -p -o -p -,txt -p -o -p ${CMAKE_BINARY_DIR}/test_${TESTNAME}.xml,xunitxml)
@@ -105,11 +106,12 @@
 
 function(generate_telepathy_test TESTNAME)
     set(options "")
-    set(oneValueArgs "")
+    set(oneValueArgs WAIT_FOR)
     set(multiValueArgs TASKS LIBRARIES QT5_MODULES)
     cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
 
     set(TASKS --task gnome-keyring-daemon -p -r -p -d --task-name gnome-keyring --ignore-return
+              --task ${CMAKE_BINARY_DIR}/tests/common/NotificationsMock --task-name notifications --ignore-return
               --task /usr/lib/dconf/dconf-service --task-name dconf-service --ignore-return
               --task dconf -p write -p /org/gnome/empathy/use-conn -p false --task-name dconf-write --wait-for ca.desrt.dconf --ignore-return
               --task /usr/lib/telepathy/mission-control-5 --task-name mission-control --wait-for ca.desrt.dconf --ignore-return
@@ -125,10 +127,13 @@
     if (NOT DEFINED ARG_QT5_MODULES)
         set(ARG_QT5_MODULES Core DBus Test Qml)
     endif (NOT DEFINED ARG_QT5_MODULES)
+    if (NOT DEFINED ARG_WAIT_FOR)
+        set(ARG_WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceHandler)
+    endif (NOT DEFINED ARG_WAIT_FOR)
     generate_test(${TESTNAME} ${ARGN}
                   TASKS ${TASKS}
                   LIBRARIES ${ARG_LIBRARIES} 
                   QT5_MODULES ${ARG_QT5_MODULES} 
                   USE_DBUS USE_UI 
-                  WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceHandler)
+                  WAIT_FOR ${ARG_WAIT_FOR})
 endfunction(generate_telepathy_test)

=== modified file 'debian/telephony-service.install'
--- debian/telephony-service.install	2015-06-11 13:32:01 +0000
+++ debian/telephony-service.install	2015-07-08 21:44:54 +0000
@@ -8,9 +8,9 @@
 usr/share/icons/ubuntu-mono-dark/status/*/indicator-call.svg
 usr/share/icons/ubuntu-mono-light/status/*/indicator-call.svg
 usr/share/locale/*/LC_MESSAGES/telephony-service.mo
-usr/share/notify-osd/icons/gnome/scalable/status/notification-group-call.svg
-usr/share/notify-osd/icons/gnome/scalable/status/notification-unavailable-image-call.svg
-usr/share/notify-osd/icons/gnome/scalable/status/notification-unknown-call.svg
+usr/share/notify-osd/icons/Humanity/scalable/status/notification-group-call.svg
+usr/share/notify-osd/icons/Humanity/scalable/status/notification-unavailable-image-call.svg
+usr/share/notify-osd/icons/Humanity/scalable/status/notification-unknown-call.svg
 usr/share/polkit-1/actions/*TelephonyService*.policy
 usr/share/telepathy/clients/TelephonyService*.client
 usr/share/telephony-service/assets/*

=== modified file 'handler/callhandler.cpp'
--- handler/callhandler.cpp	2015-03-04 18:02:13 +0000
+++ handler/callhandler.cpp	2015-07-08 21:44:54 +0000
@@ -177,7 +177,8 @@
      * play locally (via tone generator) only if we are on a call, or if this is 
      * dialpad sounds
      */
-    if (GreeterContacts::instance()->dialpadSoundsEnabled() && objectPath.isEmpty()
+    if (GreeterContacts::instance()->dialpadSoundsEnabled() && 
+        !GreeterContacts::instance()->silentMode() && objectPath.isEmpty()
         || !objectPath.isEmpty()) {
         ToneGenerator::instance()->playDTMFTone((uint)event);
     }
@@ -264,8 +265,6 @@
 
 void CallHandler::onCallChannelAvailable(Tp::CallChannelPtr channel)
 {
-    channel->accept();
-
     QDBusInterface callChannelIface(channel->busName(), channel->objectPath(), DBUS_PROPERTIES_IFACE);
     QDBusMessage reply = callChannelIface.call("GetAll", CANONICAL_TELEPHONY_AUDIOOUTPUTS_IFACE);
     QVariantList args = reply.arguments();

=== modified file 'handler/handler.cpp'
--- handler/handler.cpp	2015-06-10 21:05:50 +0000
+++ handler/handler.cpp	2015-07-08 21:44:54 +0000
@@ -21,6 +21,7 @@
  */
 
 #include "handler.h"
+#include "accountentry.h"
 #include "protocolmanager.h"
 #include "telepathyhelper.h"
 
@@ -60,6 +61,7 @@
 
 
     Q_FOREACH(const Tp::ChannelPtr channel, channels) {
+        mContexts[channel.data()] = context;
         Tp::TextChannelPtr textChannel = Tp::TextChannelPtr::dynamicCast(channel);
         if (textChannel) {
             Tp::PendingReady *pr = textChannel->becomeReady(Tp::Features()
@@ -89,7 +91,6 @@
         }
 
     }
-    context->setFinished();
 }
 
 Tp::ChannelClassSpecList Handler::channelFilters()
@@ -121,6 +122,10 @@
     }
 
     mReadyRequests.remove(pr);
+    Tp::MethodInvocationContextPtr<> context = mContexts.take(textChannel.data());
+    if (context) {
+        context->setFinished();
+    }
 
     Q_EMIT textChannelAvailable(textChannel);
 }
@@ -134,15 +139,37 @@
         return;
     }
 
-    Tp::ChannelPtr channel = mReadyRequests[pr];
+    Tp::ChannelPtr channel = mReadyRequests.take(pr);
     Tp::CallChannelPtr callChannel = Tp::CallChannelPtr::dynamicCast(channel);
+    Tp::MethodInvocationContextPtr<> context = mContexts.take(channel.data());
 
     if(!callChannel) {
+        if (context) {
+            context->setFinishedWithError(TP_QT_ERROR_CONFUSED, "Channel was not a call channel");
+        }
         qCritical() << "The saved channel is not a Tp::CallChannel";
         return;
     }
 
-    mReadyRequests.remove(pr);
+    // if the call is neither Accepted nor Active, it means it got dispatched directly to the handler without passing
+    // through any approver. For phone calls, this would mean calls getting auto-accepted which is not desirable
+    // so we return an error here
+    bool incoming = false;
+    AccountEntry *accountEntry = TelepathyHelper::instance()->accountForConnection(callChannel->connection());
+    if (accountEntry) {
+        incoming = callChannel->initiatorContact() != accountEntry->account()->connection()->selfContact();
+    }
+    if (incoming && callChannel->callState() != Tp::CallStateAccepted && callChannel->callState() != Tp::CallStateActive) {
+        qWarning() << "Available channel was not approved by telephony-service-approver, ignoring it.";
+        if (context) {
+            context->setFinishedWithError(TP_QT_ERROR_NOT_CAPABLE, "Only channels approved and accepted by telephony-service-approver are supported");
+        }
+        return;
+    }
+
+    if (context) {
+        context->setFinished();
+    }
 
     Q_EMIT callChannelAvailable(callChannel);
 }

=== modified file 'handler/handler.h'
--- handler/handler.h	2013-07-18 17:02:10 +0000
+++ handler/handler.h	2015-07-08 21:44:54 +0000
@@ -56,6 +56,7 @@
 
 private:
     QMap<Tp::PendingReady*, Tp::ChannelPtr> mReadyRequests;
+    QMap<Tp::Channel*, Tp::MethodInvocationContextPtr<> > mContexts;
 };
 
 #endif // HANDLER_H

=== modified file 'indicator/icons/CMakeLists.txt'
--- indicator/icons/CMakeLists.txt	2012-07-20 14:14:47 +0000
+++ indicator/icons/CMakeLists.txt	2015-07-08 21:44:54 +0000
@@ -1,3 +1,4 @@
+set (icon-theme Humanity)
 
 set(icons
     notification-group-call.svg
@@ -5,4 +6,4 @@
     notification-unknown-call.svg
     )
 
-install(FILES ${icons} DESTINATION share/notify-osd/icons/gnome/scalable/status)
+install(FILES ${icons} DESTINATION share/notify-osd/icons/${icon-theme}/scalable/status)

=== modified file 'indicator/messagingmenu.cpp'
--- indicator/messagingmenu.cpp	2015-06-11 16:38:02 +0000
+++ indicator/messagingmenu.cpp	2015-07-08 21:44:54 +0000
@@ -251,7 +251,6 @@
     messaging_menu_app_append_message(mCallsApp, message, SOURCE_ID, true);
     mCalls.append(call);
 
-    g_variant_unref(messages);
     g_object_unref(file);
     g_object_unref(icon);
     g_object_unref(message);

=== modified file 'indicator/ussdindicator.cpp'
--- indicator/ussdindicator.cpp	2015-04-28 19:18:55 +0000
+++ indicator/ussdindicator.cpp	2015-07-08 21:44:54 +0000
@@ -32,6 +32,7 @@
 
 USSDIndicator::USSDIndicator(QObject *parent)
 : QObject(parent),
+  m_notificationId(-1),
   m_menuRequest(true),
   m_menuNotification(false),
   m_notifications("org.freedesktop.Notifications",
@@ -99,7 +100,13 @@
 
 void USSDIndicator::onStateChanged(const QString &state)
 {
-    // TODO: check if we should close notifications when the state is idle
+    if (m_notificationId == -1) {
+        return;
+    }
+
+    if (state == "idle") {
+        m_notifications.CloseNotification(m_notificationId);
+    }
 }
 
 void USSDIndicator::showUSSDNotification(const QString &message, bool replyRequired, USSDManager *ussdManager)
@@ -116,6 +123,7 @@
     QVariantMap notificationHints;
     notificationHints["x-canonical-snap-decisions"] = "true";
     notificationHints["x-canonical-private-button-tint"] = "true";
+    notificationHints["x-canonical-snap-decisions-timeout"] = -1;
 
     QVariantMap menuModelActions;
     menuModelActions["notifications"] = menu->actionPath();
@@ -148,7 +156,7 @@
         return;
     }
 
-    m_notificationId = 0;
+    m_notificationId = -1;
 
     if (actionKey == "reply_id") {
         ussdManager->respond(m_menuRequest.response());
@@ -162,19 +170,18 @@
     if (id != m_notificationId) {
         return;
     }
-    m_notifications.CloseNotification(m_notificationId);
-    m_notificationId = 0;
+    m_notificationId = -1;
 }
 
 void USSDIndicator::clear()
 {
-    if (m_notificationId != 0) {
+    if (m_notificationId != -1) {
         USSDManager *ussdManager = mUSSDRequests.take(m_notificationId);
         if (ussdManager) {
             ussdManager->cancel();
         }
 
         m_notifications.CloseNotification(m_notificationId);
-        m_notificationId = 0;
+        m_notificationId = -1;
     }
 }

=== modified file 'libtelephonyservice/applicationutils.cpp'
--- libtelephonyservice/applicationutils.cpp	2015-05-21 18:02:42 +0000
+++ libtelephonyservice/applicationutils.cpp	2015-07-08 21:44:54 +0000
@@ -60,13 +60,15 @@
 bool ApplicationUtils::openUrl(const QUrl &url)
 {
 #ifdef USE_UBUNTU_PLATFORM_API
-    UAUrlDispatcherSession* session = ua_url_dispatcher_session();
-    if (!session)
-        return false;
-
-    ua_url_dispatcher_session_open(session, url.toEncoded().constData(), NULL, NULL);
-
-    free(session);
+    if (qgetenv("TELEPHONY_SERVICE_TEST").isEmpty()) {
+        UAUrlDispatcherSession* session = ua_url_dispatcher_session();
+        if (!session)
+            return false;
+
+        ua_url_dispatcher_session_open(session, url.toEncoded().constData(), NULL, NULL);
+
+        free(session);
+    }
 #endif
     return true;
 }

=== modified file 'libtelephonyservice/callentry.cpp'
--- libtelephonyservice/callentry.cpp	2015-04-28 20:44:57 +0000
+++ libtelephonyservice/callentry.cpp	2015-07-08 21:44:54 +0000
@@ -295,7 +295,7 @@
 
 QString CallEntry::phoneNumber() const
 {
-    if (mChannel->isConference() || !mChannel->actualFeatures().contains(Tp::CallChannel::FeatureCore)) {
+    if (mChannel->isConference() || !mChannel->actualFeatures().contains(Tp::CallChannel::FeatureCore) || mChannel->targetContact().isNull()) {
         return "";
     }
     return mChannel->targetContact()->id();

=== modified file 'libtelephonyservice/telepathyhelper.cpp'
--- libtelephonyservice/telepathyhelper.cpp	2015-06-11 16:48:18 +0000
+++ libtelephonyservice/telepathyhelper.cpp	2015-07-08 21:44:54 +0000
@@ -466,6 +466,7 @@
     }
 
     if (mAccounts.count() == 0) {
+        mFirstTime = false;
         Q_EMIT setupReady();
         return;
     }

=== modified file 'po/CMakeLists.txt'
--- po/CMakeLists.txt	2014-08-20 09:35:55 +0000
+++ po/CMakeLists.txt	2015-07-08 21:44:54 +0000
@@ -28,7 +28,7 @@
 
 find_program(XGETTEXT_EXECUTABLE xgettext)
 if(XGETTEXT_EXECUTABLE)
-    add_custom_target(${POT_FILE} ALL
+    add_custom_target(${POT_FILE}
         COMMENT "Generating translation template"
         COMMAND ${XGETTEXT_EXECUTABLE} --c++ --qt --add-comments=TRANSLATORS --keyword=GettextMarkExtraction --keyword=tr --keyword=tr:1,2 -D ${CMAKE_SOURCE_DIR} -s -p ${CMAKE_CURRENT_SOURCE_DIR} -o ${POT_FILE} ${I18N_SRCS}
     )

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-05-21 18:02:42 +0000
+++ tests/CMakeLists.txt	2015-07-08 21:44:54 +0000
@@ -1,6 +1,7 @@
 include (GenerateTest)
 
 add_subdirectory(common)
+add_subdirectory(approver)
 add_subdirectory(handler)
 add_subdirectory(indicator)
 add_subdirectory(libtelephonyservice)

=== added directory 'tests/approver'
=== added file 'tests/approver/ApproverTest.cpp'
--- tests/approver/ApproverTest.cpp	1970-01-01 00:00:00 +0000
+++ tests/approver/ApproverTest.cpp	2015-07-08 21:44:54 +0000
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2013-2015 Canonical, Ltd.
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service 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.
+ *
+ * telephony-service 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/>.
+ */
+
+#include <QtCore/QObject>
+#include <QtTest/QtTest>
+#include "telepathytest.h"
+#include "approvercontroller.h"
+#include "mockcontroller.h"
+#include "accountentry.h"
+#include "accountentryfactory.h"
+#include "telepathyhelper.h"
+
+class ApproverTest : public TelepathyTest
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase();
+    void init();
+    void cleanup();
+    void testSnapDecisionTimeout();
+    void testAcceptCall();
+
+private:
+    void waitForCallActive(const QString &callerId);
+    MockController *mMockController;
+    Tp::AccountPtr mTpAccount;
+};
+
+void ApproverTest::initTestCase()
+{
+    initialize();
+
+    QSignalSpy setupReadySpy(TelepathyHelper::instance(), SIGNAL(setupReady()));
+    TRY_COMPARE(setupReadySpy.count(), 1);
+}
+
+void ApproverTest::init()
+{
+    mTpAccount = addAccount("mock", "mock", "the account");
+
+    // and create the mock controller
+    mMockController = new MockController("mock", this);
+}
+
+void ApproverTest::cleanup()
+{
+    doCleanup();
+    mMockController->deleteLater();
+}
+
+void ApproverTest::testSnapDecisionTimeout()
+{
+    QString callerId("12345");
+    QVariantMap properties;
+    properties["Caller"] = callerId;
+    properties["State"] = "incoming";
+
+    QDBusInterface notificationsMock("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications");
+    QSignalSpy notificationSpy(&notificationsMock, SIGNAL(MockNotificationReceived(QString, uint, QString, QString, QString, QStringList, QVariantMap, int)));
+    mMockController->placeCall(properties);
+    TRY_COMPARE(notificationSpy.count(), 1);
+    QVariantMap hints = notificationSpy.first()[6].toMap();
+    QVERIFY(hints.contains("x-canonical-snap-decisions-timeout"));
+    QCOMPARE(hints["x-canonical-snap-decisions-timeout"].toInt(), -1);
+    mMockController->HangupCall(callerId);
+}
+
+void ApproverTest::testAcceptCall()
+{
+    QString callerId("7654321");
+
+    QVariantMap properties;
+    properties["Caller"] = callerId;
+    properties["State"] = "incoming";
+
+    QDBusInterface notificationsMock("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications");
+    QSignalSpy notificationSpy(&notificationsMock, SIGNAL(MockNotificationReceived(QString, uint, QString, QString, QString, QStringList, QVariantMap, int)));
+    QString objectPath = mMockController->placeCall(properties);
+    TRY_COMPARE(notificationSpy.count(), 1);
+
+    // at this point we are already sure the approver has the call, as the notification was placed
+    QSignalSpy callStateSpy(mMockController, SIGNAL(CallStateChanged(QString,QString,QString)));
+    ApproverController::instance()->acceptCall();
+    TRY_COMPARE(callStateSpy.count(), 1);
+    QCOMPARE(callStateSpy.first()[0].toString(), callerId);
+    QCOMPARE(callStateSpy.first()[1].toString(), objectPath);
+    QCOMPARE(callStateSpy.first()[2].toString(), QString("accepted"));
+    mMockController->HangupCall(callerId);
+}
+
+QTEST_MAIN(ApproverTest)
+#include "ApproverTest.moc"

=== added file 'tests/approver/CMakeLists.txt'
--- tests/approver/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/approver/CMakeLists.txt	2015-07-08 21:44:54 +0000
@@ -0,0 +1,16 @@
+include_directories(
+    ${CMAKE_CURRENT_BINARY_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/../common
+    ${CMAKE_SOURCE_DIR}
+    ${CMAKE_SOURCE_DIR}/libtelephonyservice
+    ${CMAKE_BINARY_DIR}/tests/common
+    ${TP_QT5_INCLUDE_DIRS}
+    ${GSETTINGS_QT_INCLUDE_DIRS}
+    )
+
+if (NOT ("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "aarch64"))
+    generate_telepathy_test(ApproverTest
+                            SOURCES ApproverTest.cpp approvercontroller.cpp
+                            TASKS --task ${CMAKE_BINARY_DIR}/approver/telephony-service-approver --task-name telephony-service-approver --wait-for com.canonical.TelephonyServiceHandler --ignore-return
+                            WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceApprover)
+endif()

=== added file 'tests/approver/approvercontroller.cpp'
--- tests/approver/approvercontroller.cpp	1970-01-01 00:00:00 +0000
+++ tests/approver/approvercontroller.cpp	2015-07-08 21:44:54 +0000
@@ -0,0 +1,49 @@
+/**
+ * Copyright (C) 2013-2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ */
+
+#include <QStringList>
+#include "approvercontroller.h"
+#include <QDBusReply>
+#include <QDebug>
+
+#define APPROVER_SERVICE "com.canonical.Approver"
+#define APPROVER_OBJECT "/com/canonical/Approver"
+#define APPROVER_INTERFACE "com.canonical.TelephonyServiceApprover"
+
+ApproverController *ApproverController::instance()
+{
+    static ApproverController *self = new ApproverController();
+    return self;
+}
+
+ApproverController::ApproverController(QObject *parent) :
+    QObject(parent),
+    mApproverInterface(APPROVER_SERVICE, APPROVER_OBJECT, APPROVER_INTERFACE)
+{
+}
+
+void ApproverController::acceptCall()
+{
+    mApproverInterface.call("AcceptCall");
+}
+
+void ApproverController::hangUpAndAcceptCall()
+{
+    mApproverInterface.call("HangUpAndAcceptCall");
+}

=== added file 'tests/approver/approvercontroller.h'
--- tests/approver/approvercontroller.h	1970-01-01 00:00:00 +0000
+++ tests/approver/approvercontroller.h	2015-07-08 21:44:54 +0000
@@ -0,0 +1,41 @@
+/**
+ * Copyright (C) 2013-2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ * Authors:
+ *  Gustavo Pichorim Boiko <[e-mail]>
+ */
+
+#ifndef APPROVERCONTROLLER_H
+#define APPROVERCONTROLLER_H
+
+#include <QObject>
+#include <QDBusInterface>
+
+class ApproverController : public QObject
+{
+    Q_OBJECT
+public:
+    static ApproverController *instance();
+
+public Q_SLOTS:
+    void acceptCall();
+    void hangUpAndAcceptCall();
+
+private:
+    explicit ApproverController(QObject *parent = 0);
+    QDBusInterface mApproverInterface;
+};
+
+#endif // ApproverController_H

=== modified file 'tests/common/CMakeLists.txt'
--- tests/common/CMakeLists.txt	2015-06-05 18:42:14 +0000
+++ tests/common/CMakeLists.txt	2015-07-08 21:44:54 +0000
@@ -5,6 +5,9 @@
 
 configure_file(dbus-session.conf.in ${CMAKE_CURRENT_BINARY_DIR}/dbus-session.conf)
 
+add_executable(NotificationsMock NotificationsMock.cpp)
+qt5_use_modules(NotificationsMock Core DBus)
+
 qt5_add_dbus_interface(mockcontroller_SRCS mock/MockConnection.xml MockConnectionInterface)
 add_library(mockcontroller STATIC mockcontroller.cpp mockcontroller.h ${mockcontroller_SRCS})
 qt5_use_modules(mockcontroller Core DBus)

=== added file 'tests/common/NotificationsMock.cpp'
--- tests/common/NotificationsMock.cpp	1970-01-01 00:00:00 +0000
+++ tests/common/NotificationsMock.cpp	2015-07-08 21:44:54 +0000
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This file is part of telephony-service.
+ *
+ * telephony-service 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.
+ *
+ * telephony-service 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/>.
+ */
+
+#include <QObject>
+#include <QCoreApplication>
+#include <QDBusConnection>
+#include <QDBusMessage>
+#include <QDBusObjectPath>
+#include <QDebug>
+
+#define NOTIFICATIONS_DBUS_SERVICE_NAME "org.freedesktop.Notifications"
+#define NOTIFICATIONS_DBUS_OBJ_PATH "/org/freedesktop/Notifications"
+
+class NotificationsMock : public QObject
+{
+    Q_OBJECT
+    Q_CLASSINFO("D-Bus Interface", NOTIFICATIONS_DBUS_SERVICE_NAME)
+
+public:
+    Q_SCRIPTABLE uint Notify(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout);
+    Q_SCRIPTABLE void CloseNotification(uint id);
+    Q_SCRIPTABLE QString GetServerInformation(QString& vendor, QString& version, QString& spec_version);
+
+    // Mock specific method
+    Q_SCRIPTABLE void MockInvokeAction(uint id, QString action_key);
+
+Q_SIGNALS:
+    Q_SCRIPTABLE void NotificationClosed(uint id, uint reason);
+    Q_SCRIPTABLE void ActionInvoked(uint id, QString action_key);
+
+    // Mock specific signal
+    Q_SCRIPTABLE void MockNotificationReceived(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout);
+};
+
+uint NotificationsMock::Notify(QString app_name, uint replaces_id, QString app_icon, QString summary, QString body, QStringList actions, QVariantMap hints, int expire_timeout)
+{
+    Q_EMIT MockNotificationReceived(app_name, replaces_id, app_icon, summary, body, actions, hints, expire_timeout);
+    static uint id = 1;
+    return (replaces_id != 0 ? replaces_id : id++);
+}
+
+void NotificationsMock::MockInvokeAction(uint id, QString action_key)
+{
+    Q_EMIT ActionInvoked(id, action_key);
+    Q_EMIT NotificationClosed(id, 2); // 2 is dismissed by user
+}
+
+void NotificationsMock::CloseNotification(uint id)
+{
+    Q_EMIT NotificationClosed(id, 3); // 3 is closed by a CloseNotification() call
+}
+
+QString NotificationsMock::GetServerInformation(QString &vendor, QString &version, QString &spec_version)
+{
+    return QString();
+}
+
+int main(int argc, char **argv)
+{
+    QCoreApplication a(argc, argv);
+
+    QDBusConnection connection = QDBusConnection::sessionBus();
+
+    NotificationsMock notifications;
+    connection.registerObject(NOTIFICATIONS_DBUS_OBJ_PATH, &notifications, QDBusConnection::ExportScriptableContents);
+    connection.registerService(NOTIFICATIONS_DBUS_SERVICE_NAME);
+
+    return a.exec();
+}
+
+#include "NotificationsMock.moc"

=== modified file 'tests/common/mock/callchannel.cpp'
--- tests/common/mock/callchannel.cpp	2015-06-16 15:59:34 +0000
+++ tests/common/mock/callchannel.cpp	2015-07-08 21:44:54 +0000
@@ -68,7 +68,15 @@
 
 void MockCallChannel::onAccept(Tp::DBusError*)
 {
-    setCallState("active");
+    setCallState("accepted");
+    QTimer *timer = new QTimer(this);
+    timer->setSingleShot(true);
+    timer->setInterval(100);
+    connect(timer, &QTimer::timeout, [this, timer]() {
+        setCallState("active");
+        timer->deleteLater();
+    });
+    timer->start();
 }
 
 void MockCallChannel::init()
@@ -195,6 +203,8 @@
         }
         mCallChannel->setCallState(Tp::CallStateEnded, 0, reason, stateDetails);
         mBaseChannel->close();
+    } else if (state == "accepted") {
+        mCallChannel->setCallState(Tp::CallStateAccepted, 0, reason, stateDetails);
     } else if (state == "active") {
         qDebug() << "active";
         mHoldIface->setHoldState(Tp::LocalHoldStateUnheld, Tp::LocalHoldStateReasonNone);

=== modified file 'tests/handler/HandlerTest.cpp'
--- tests/handler/HandlerTest.cpp	2015-05-07 16:44:43 +0000
+++ tests/handler/HandlerTest.cpp	2015-07-08 21:44:54 +0000
@@ -41,8 +41,11 @@
     void testConferenceCall();
     void testSendMessage();
     void testActiveCallIndicator();
+    void testNotApprovedChannels();
 
 private:
+    void registerApprover();
+    void unregisterApprover();
     void waitForCallActive(const QString &callerId);
     Approver *mApprover;
     MockController *mMockController;
@@ -56,11 +59,7 @@
     QSignalSpy setupReadySpy(TelepathyHelper::instance(), SIGNAL(setupReady()));
     TRY_COMPARE(setupReadySpy.count(), 1);
 
-    // register the approver
-    mApprover = new Approver(this);
-    TelepathyHelper::instance()->registerClient(mApprover, "TelephonyTestApprover");
-    // Tp-qt does not set registered status to approvers
-    TRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
+    registerApprover();
 }
 
 void HandlerTest::init()
@@ -163,6 +162,8 @@
     TRY_COMPARE(approverCallSpy.count(), 1);
     mApprover->acceptCall();
 
+    waitForCallActive(callerId);
+
     // wait until the call properties are changed
     TRY_VERIFY(handlerCallPropertiesSpy.count() > 0);
     QString objectPath = handlerCallPropertiesSpy.last()[0].toString();
@@ -302,21 +303,63 @@
     QVERIFY(!HandlerController::instance()->callIndicatorVisible());
 }
 
+void HandlerTest::testNotApprovedChannels()
+{
+    QVariantMap properties;
+    properties["Caller"] = "123456";
+    properties["State"] = "incoming";
+
+    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
+
+    QSignalSpy callStateSpy(mMockController, SIGNAL(CallStateChanged(QString,QString,QString)));
+    QString objectPath = mMockController->placeCall(properties);
+    QVERIFY(!objectPath.isEmpty());
+
+    // wait for the channel to hit the approver
+    TRY_COMPARE(approverCallSpy.count(), 1);
+
+    // accept the call but do not call callChannel->accept() on the channel
+    mApprover->acceptCall(false);
+
+    // wait for a few seconds
+    QTest::qWait(3000);
+
+    // no state changes should happen, as the channel was not accepted
+    QVERIFY(callStateSpy.isEmpty());
+}
+
+void HandlerTest::registerApprover()
+{
+    // register the approver
+    mApprover = new Approver();
+    QVERIFY(TelepathyHelper::instance()->registerClient(mApprover, "TelephonyTestApprover"));
+    // Tp-qt does not set registered status to approvers
+    TRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
+}
+
+void HandlerTest::unregisterApprover()
+{
+    QVERIFY(TelepathyHelper::instance()->unregisterClient(mApprover));
+    mApprover->deleteLater();
+    mApprover = NULL;
+    TRY_VERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
+}
+
 void HandlerTest::waitForCallActive(const QString &callerId)
 {
-    // wait until the call state is "accepted"
     QSignalSpy callStateSpy(mMockController, SIGNAL(CallStateChanged(QString,QString,QString)));
     QString state;
     QString objectPath;
     QString caller;
     int tries = 0;
-    while (state != "active" && caller != callerId && tries < 5) {
+    while ((state != "active" || caller != callerId) && tries < 5) {
         TRY_COMPARE(callStateSpy.count(), 1);
         caller = callStateSpy.first()[0].toString();
         objectPath = callStateSpy.first()[1].toString();
         state = callStateSpy.first()[2].toString();
         callStateSpy.clear();
         tries++;
+        qDebug() << "Waiting for call active, try " << tries << " failed.";
     }
 
     QCOMPARE(caller, callerId);

=== modified file 'tests/handler/approver.cpp'
--- tests/handler/approver.cpp	2015-03-23 19:59:50 +0000
+++ tests/handler/approver.cpp	2015-07-08 21:44:54 +0000
@@ -107,11 +107,17 @@
     }
 }
 
-void Approver::acceptCall()
+void Approver::acceptCall(bool callAcceptOnChannel)
 {
     Q_FOREACH (Tp::ChannelDispatchOperationPtr dispatchOperation, mDispatchOps) {
         QList<Tp::ChannelPtr> channels = dispatchOperation->channels();
         Q_FOREACH (Tp::ChannelPtr channel, channels) {
+            if (callAcceptOnChannel) {
+                Tp::CallChannelPtr callChannel = Tp::CallChannelPtr::dynamicCast(channel);
+                if (callChannel) {
+                    callChannel->accept();
+                }
+            }
             if (dispatchOperation->possibleHandlers().contains(TELEPHONY_SERVICE_HANDLER)) {
                 dispatchOperation->handleWith(TELEPHONY_SERVICE_HANDLER);
                 mDispatchOps.removeAll(dispatchOperation);

=== modified file 'tests/handler/approver.h'
--- tests/handler/approver.h	2014-01-07 19:53:45 +0000
+++ tests/handler/approver.h	2015-07-08 21:44:54 +0000
@@ -44,7 +44,7 @@
     void newCall();
 
 public Q_SLOTS:
-    void acceptCall();
+    void acceptCall(bool callAcceptOnChannel = true);
     void rejectCall();
 
 private Q_SLOTS:

=== modified file 'tests/handler/handlercontroller.cpp'
--- tests/handler/handlercontroller.cpp	2014-06-17 17:46:07 +0000
+++ tests/handler/handlercontroller.cpp	2015-07-08 21:44:54 +0000
@@ -99,6 +99,12 @@
     mHandlerInterface.call("SendDTMF", objectPath, key);
 }
 
+bool HandlerController::hasCalls()
+{
+    QDBusReply<bool> reply = mHandlerInterface.call("HasCalls");
+    return reply.isValid() && reply.value();
+}
+
 void HandlerController::createConferenceCall(const QStringList &objectPaths)
 {
     mHandlerInterface.call("CreateConferenceCall", objectPaths);

=== modified file 'tests/handler/handlercontroller.h'
--- tests/handler/handlercontroller.h	2014-06-17 17:46:07 +0000
+++ tests/handler/handlercontroller.h	2015-07-08 21:44:54 +0000
@@ -40,6 +40,7 @@
     void setMuted(const QString &objectPath, bool muted);
     void setSpeakerMode(const QString &objectPath, bool enabled);
     void sendDTMF(const QString &objectPath, const QString &key);
+    bool hasCalls();
 
     // conference call methods
     void createConferenceCall(const QStringList &objectPaths);

=== modified file 'tests/libtelephonyservice/CallEntryTest.cpp'
--- tests/libtelephonyservice/CallEntryTest.cpp	2015-05-08 21:57:06 +0000
+++ tests/libtelephonyservice/CallEntryTest.cpp	2015-07-08 21:44:54 +0000
@@ -122,7 +122,12 @@
 
 void CallEntryTest::onCallChannelAvailable(const Tp::CallChannelPtr &channel)
 {
-    mCallChannel = channel;
+    channel->accept();
+    connect(channel->becomeReady(Tp::Features() << Tp::CallChannel::FeatureCore
+                                                << Tp::CallChannel::FeatureCallState),
+            &Tp::PendingOperation::finished, [this, channel] {
+        mCallChannel = channel;
+    });
 }
 
 QTEST_MAIN(CallEntryTest)