1
=== modified file '.bzrignore'
2
--- .bzrignore	2014-01-07 19:53:45 +0000
3
+++ .bzrignore	2015-03-30 20:55:55 +0000
4
@@ -32,19 +32,22 @@
5
32
handler/handleradaptor.*
32
handler/handleradaptor.*
6
33
indicator/*.desktop
33
indicator/*.desktop
7
34
indicator/*.service
34
indicator/*.service
8
35
indicator/NotificationsInterface.*
9
35
36
10
36
Testing
37
Testing
11
37
Ubuntu/Telephony/tests/*Test
12
38
Ubuntu/Telephony/qmldir
38
Ubuntu/Telephony/qmldir
13
39
libtelephonyservice/tests/*Test
14
40
CTestTestfile.cmake
39
CTestTestfile.cmake
15
41
test_*.xml
40
test_*.xml
16
41
cmake_uninstall.cmake
17
42
42
18
43
coverage*
43
coverage*
19
44
44
20
45
po/*.gmo
45
po/*.gmo
21
46
46
26
47
handler/tests/HandlerTest
47
tests/*/*Test
27
48
handler/tests/dbus-test-wrapper.sh
48
tests/common/dbus-test-wrapper.sh
28
49
handler/tests/mock/mockconnectionadaptor.*
49
tests/common/mock/mockconnectionadaptor.*
29
50
handler/tests/mock/telepathy-mock
50
tests/common/mock/telepathy-mock
30
51
tests/Ubuntu.Telephony/ContactWatcherTest
31
52
tests/libtelephonyservice/GreeterContactsTestExe
32
53
tests/libtelephonyservice/GreeterContactsTestServerExe
33
51
54
34
=== modified file 'CMakeLists.txt'
35
--- CMakeLists.txt	2014-08-05 20:04:00 +0000
36
+++ CMakeLists.txt	2015-03-30 20:55:55 +0000
37
@@ -9,23 +9,6 @@
38
9
include(CheckIncludeFileCXX)
9
include(CheckIncludeFileCXX)
39
10
include(CheckIncludeFile)
10
include(CheckIncludeFile)
40
11
11
41
12
include(EnableCoverageReport)
42
13
#####################################################################
43
14
# Enable code coverage calculation with gcov/gcovr/lcov
44
15
# Usage:
45
16
#  * Switch build type to coverage (use ccmake or cmake-gui)
46
17
#  * Invoke make, make test, make coverage
47
18
#  * Find html report in subdir coveragereport
48
19
#  * Find xml report feasible for jenkins in coverage.xml
49
20
#####################################################################
50
21
IF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
51
22
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
52
23
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
53
24
  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -coverage" )
54
25
  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -coverage" )
55
26
  ENABLE_COVERAGE_REPORT(TARGETS ${PHONE_APP})
56
27
ENDIF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
57
28
58
29
# Instruct CMake to run moc automatically when needed.
12
# Instruct CMake to run moc automatically when needed.
59
30
set(CMAKE_AUTOMOC ON)
13
set(CMAKE_AUTOMOC ON)
60
31
14
61
@@ -36,8 +19,6 @@
62
36
    add_definitions(-DUSE_UBUNTU_PLATFORM_API)
19
    add_definitions(-DUSE_UBUNTU_PLATFORM_API)
63
37
endif (USE_UBUNTU_PLATFORM_API)
20
endif (USE_UBUNTU_PLATFORM_API)
64
38
21
65
39
find_program(DBUS_RUNNER dbus-test-runner)
66
40
67
41
set(TELEPHONY_SERVICE_DIR ${CMAKE_INSTALL_DATADIR}/telephony-service)
22
set(TELEPHONY_SERVICE_DIR ${CMAKE_INSTALL_DATADIR}/telephony-service)
68
42
23
69
43
configure_file(config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h @ONLY)
24
configure_file(config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h @ONLY)
70
@@ -81,6 +62,14 @@
71
81
    ${CMAKE_CURRENT_SOURCE_DIR}
62
    ${CMAKE_CURRENT_SOURCE_DIR}
72
82
    )
63
    )
73
83
64
74
65
# generate a macro to make it easier to enable coverage support on targets
75
66
function(ENABLE_COVERAGE)
76
67
    get_directory_property(COVERAGE_TARGETS DIRECTORY ${CMAKE_SOURCE_DIR} COVERAGE_TARGETS)
77
68
    list(APPEND COVERAGE_TARGETS ${ARGN})
78
69
    MESSAGE(STATUS "Enabling coverage report for target(s): ${ARGN}")
79
70
    set_property(DIRECTORY ${CMAKE_SOURCE_DIR} PROPERTY COVERAGE_TARGETS ${COVERAGE_TARGETS})
80
71
endfunction()
81
72
82
84
enable_testing()
73
enable_testing()
83
85
74
84
86
add_definitions(-std=c++11)
75
add_definitions(-std=c++11)
85
@@ -98,3 +87,24 @@
86
98
add_subdirectory(tools)
87
add_subdirectory(tools)
87
99
add_subdirectory(icons)
88
add_subdirectory(icons)
88
100
add_subdirectory(po)
89
add_subdirectory(po)
89
90
add_subdirectory(tests)
90
91
91
92
include(EnableCoverageReport)
92
93
#####################################################################
93
94
# Enable code coverage calculation with gcov/gcovr/lcov
94
95
# Usage:
95
96
#  * Switch build type to coverage (use ccmake or cmake-gui)
96
97
#  * Invoke make, make test, make coverage
97
98
#  * Find html report in subdir coveragereport
98
99
#  * Find xml report feasible for jenkins in coverage.xml
99
100
#####################################################################
100
101
IF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
101
102
  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftest-coverage -fprofile-arcs" )
102
103
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ftest-coverage -fprofile-arcs" )
103
104
  SET(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -coverage" )
104
105
  SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -coverage" )
105
106
  GET_DIRECTORY_PROPERTY(COVERAGE_TARGETS DIRECTORY ${CMAKE_SOURCE_DIR} COVERAGE_TARGETS)
106
107
  ENABLE_COVERAGE_REPORT(TARGETS ${COVERAGE_TARGETS})
107
108
ENDIF(CMAKE_BUILD_TYPE MATCHES [cC][oO][vV][eE][rR][aA][gG][eE])
108
109
109
110
110
101
111
111
=== modified file 'Ubuntu/Telephony/CMakeLists.txt'
112
--- Ubuntu/Telephony/CMakeLists.txt	2014-04-23 20:55:13 +0000
113
+++ Ubuntu/Telephony/CMakeLists.txt	2015-03-30 20:55:55 +0000
114
@@ -19,10 +19,11 @@
115
19
    telephonyservice
19
    telephonyservice
116
20
    )
20
    )
117
21
21
118
22
enable_coverage(telephonyservice-qml)
119
23
120
22
configure_file(qmldir.in ${CMAKE_CURRENT_BINARY_DIR}/qmldir)
24
configure_file(qmldir.in ${CMAKE_CURRENT_BINARY_DIR}/qmldir)
121
23
set(PLUGIN_DIR ${QT_INSTALL_QML}/Ubuntu/Telephony)
25
set(PLUGIN_DIR ${QT_INSTALL_QML}/Ubuntu/Telephony)
122
24
install(TARGETS telephonyservice-qml DESTINATION ${PLUGIN_DIR})
26
install(TARGETS telephonyservice-qml DESTINATION ${PLUGIN_DIR})
123
25
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/qmldir DESTINATION ${PLUGIN_DIR})
27
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/qmldir DESTINATION ${PLUGIN_DIR})
124
26
28
125
27
add_subdirectory(PhoneNumber)
29
add_subdirectory(PhoneNumber)
126
28
add_subdirectory(tests)
127
29
30
128
=== modified file 'Ubuntu/Telephony/contactwatcher.cpp'
129
--- Ubuntu/Telephony/contactwatcher.cpp	2015-03-30 20:55:55 +0000
130
+++ Ubuntu/Telephony/contactwatcher.cpp	2015-03-30 20:55:55 +0000
131
@@ -219,6 +219,10 @@
132
219
void ContactWatcher::setAddressableFields(const QStringList &fields)
219
void ContactWatcher::setAddressableFields(const QStringList &fields)
133
220
{
220
{
134
221
    mAddressableFields = fields;
221
    mAddressableFields = fields;
135
222
    // if the addressable fields is empty, fall back to matching phone numbers
136
223
    if (mAddressableFields.isEmpty()) {
137
224
            mAddressableFields << "tel";
138
225
    }
139
222
    Q_EMIT addressableFieldsChanged();
226
    Q_EMIT addressableFieldsChanged();
140
223
227
141
224
    startSearching();
228
    startSearching();
142
225
229
143
=== modified file 'approver/CMakeLists.txt'
144
--- approver/CMakeLists.txt	2014-07-06 16:19:49 +0000
145
+++ approver/CMakeLists.txt	2015-03-30 20:55:55 +0000
146
@@ -25,6 +25,8 @@
147
25
    telephonyservice
25
    telephonyservice
148
26
    )
26
    )
149
27
27
150
28
enable_coverage(telephony-service-approver)
151
29
152
28
configure_file(org.freedesktop.Telepathy.Client.TelephonyServiceApprover.service.in org.freedesktop.Telepathy.Client.TelephonyServiceApprover.service)
30
configure_file(org.freedesktop.Telepathy.Client.TelephonyServiceApprover.service.in org.freedesktop.Telepathy.Client.TelephonyServiceApprover.service)
153
29
install(TARGETS telephony-service-approver RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
31
install(TARGETS telephony-service-approver RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
154
30
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.Client.TelephonyServiceApprover.service DESTINATION share/dbus-1/services)
32
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.Client.TelephonyServiceApprover.service DESTINATION share/dbus-1/services)
155
31
33
156
=== added file 'cmake/modules/GenerateTest.cmake'
157
--- cmake/modules/GenerateTest.cmake	1970-01-01 00:00:00 +0000
158
+++ cmake/modules/GenerateTest.cmake	2015-03-30 20:55:55 +0000
159
@@ -0,0 +1,133 @@
160
1
#
161
2
# Copyright (C) 2015 Canonical, Ltd.
162
3
#
163
4
# Authors:
164
5
#  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
165
6
#
166
7
# This file is part of telephony-service.
167
8
#
168
9
# telephony-service is free software; you can redistribute it and/or modify
169
10
# it under the terms of the GNU General Public License as published by
170
11
# the Free Software Foundation; version 3.
171
12
#
172
13
# telephony-service is distributed in the hope that it will be useful,
173
14
# but WITHOUT ANY WARRANTY; without even the implied warranty of
174
15
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
175
16
# GNU General Public License for more details.
176
17
#
177
18
# You should have received a copy of the GNU General Public License
178
19
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
179
20
#
180
21
181
22
include(CMakeParseArguments)
182
23
find_program(DBUS_RUNNER dbus-test-runner)
183
24
184
25
function(generate_test TESTNAME)
185
26
    set(options USE_DBUS USE_UI)
186
27
    set(oneValueArgs TIMEOUT WORKING_DIRECTORY QML_TEST WAIT_FOR)
187
28
    set(multiValueArgs TASKS LIBRARIES QT5_MODULES SOURCES ENVIRONMENT)
188
29
    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
189
30
190
31
    MESSAGE(STATUS "Adding test: ${TESTNAME}")
191
32
192
33
    # set reasonable defaults for the arguments
193
34
    if (NOT DEFINED ARG_WORKING_DIRECTORY)
194
35
        set(ARG_WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
195
36
    endif ()
196
37
197
38
    if (NOT DEFINED ARG_TIMEOUT)
198
39
        set(ARG_TIMEOUT 60)
199
40
    endif ()
200
41
201
42
    if (NOT DEFINED ARG_QT5_MODULES)
202
43
        set(ARG_QT5_MODULES Core Test)
203
44
    endif ()
204
45
205
46
    if (${ARG_USE_UI})
206
47
        if (${ARG_USE_DBUS})
207
48
            set(PLATFORM -p -platform -p offscreen)
208
49
        else ()
209
50
            set(PLATFORM -platform offscreen)
210
51
        endif ()
211
52
    endif()
212
53
213
54
    # Generate QML tests
214
55
    if (DEFINED ARG_QML_TEST)
215
56
        add_test(NAME ${TESTNAME}
216
57
            WORKING_DIRECTORY ${ARG_WORKING_DIRECTORY}
217
58
            COMMAND qmltestrunner -platform offscreen -import ${CMAKE_BINARY_DIR} -input ${CMAKE_CURRENT_SOURCE_DIR}/${ARG_QML_TEST})
218
59
        set_tests_properties(${TESTNAME} PROPERTIES ENVIRONMENT "QT_QPA_FONTDIR=${CMAKE_BINARY_DIR}")
219
60
    else ()
220
61
        # For sanity checking, make sure DBUS_RUNNER is available for DBUS tests
221
62
        if (${ARG_USE_DBUS} AND "${DBUS_RUNNER}" STREQUAL "")
222
63
            message(WARNING "Test ${TESTNAME} disabled because dbus-test-runner was not found.")
223
64
            return()
224
65
        endif ()
225
66
226
67
        # No QML test, regular binary compiled test.
227
68
        add_executable(${TESTNAME} ${ARG_SOURCES})
228
69
        qt5_use_modules(${TESTNAME} ${ARG_QT5_MODULES})
229
70
230
71
        if (${ARG_USE_DBUS})
231
72
            execute_process(COMMAND mktemp -d OUTPUT_VARIABLE TMPDIR)
232
73
            string(REPLACE "\n" "" TMPDIR ${TMPDIR})
233
74
234
75
            if (NOT DEFINED ARG_ENVIRONMENT)
235
76
                set(ARG_ENVIRONMENT HOME=${TMPDIR}
236
77
                                    HISTORY_SQLITE_DBPATH=:memory:
237
78
                                    MC_ACCOUNT_DIR=${TMPDIR}
238
79
                                    MC_MANAGER_DIR=${TMPDIR})
239
80
            endif ()
240
81
241
82
            set(TEST_COMMAND ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} ${PLATFORM} -p -o -p -,txt -p -o -p ${CMAKE_BINARY_DIR}/test_${TESTNAME}.xml,xunitxml)
242
83
            if (DEFINED ARG_WAIT_FOR)
243
84
                SET(TEST_COMMAND ${TEST_COMMAND} --wait-for ${ARG_WAIT_FOR})
244
85
            endif ()
245
86
246
87
            add_test(${TESTNAME} ${DBUS_RUNNER} --keep-env --dbus-config=${CMAKE_BINARY_DIR}/tests/common/dbus-session.conf --max-wait=${ARG_TIMEOUT}
247
88
                                                ${ARG_TASKS} --task ${TEST_COMMAND} --task-name ${TESTNAME})
248
89
        else ()
249
90
            add_test(${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} ${PLATFORM} -o -,txt -o ${CMAKE_BINARY_DIR}/test_${TESTNAME}.xml,xunitxml)
250
91
        endif()
251
92
252
93
        set_tests_properties(${TESTNAME} PROPERTIES
253
94
                             ENVIRONMENT "${ARG_ENVIRONMENT}"
254
95
                             TIMEOUT ${ARG_TIMEOUT})
255
96
        if (DEFINED ARG_LIBRARIES)
256
97
            target_link_libraries(${TESTNAME}
257
98
                                  ${ARG_LIBRARIES})
258
99
        endif ()
259
100
260
101
        enable_coverage(${TESTNAME})
261
102
    endif ()
262
103
endfunction(generate_test)
263
104
264
105
function(generate_telepathy_test TESTNAME)
265
106
    set(options "")
266
107
    set(oneValueArgs "")
267
108
    set(multiValueArgs TASKS LIBRARIES QT5_MODULES)
268
109
    cmake_parse_arguments(ARG "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
269
110
270
111
    set(TASKS --task gnome-keyring-daemon -p -r -p -d --task-name gnome-keyring --ignore-return
271
112
              --task /usr/lib/dconf/dconf-service --task-name dconf-service --ignore-return
272
113
              --task dconf -p write -p /org/gnome/empathy/use-conn -p false --task-name dconf-write --wait-for ca.desrt.dconf --ignore-return
273
114
              --task /usr/lib/telepathy/mission-control-5 --task-name mission-control --wait-for ca.desrt.dconf --ignore-return
274
115
              --task ${CMAKE_BINARY_DIR}/tests/common/mock/telepathy-mock --task-name telepathy-mock --wait-for org.freedesktop.Telepathy.MissionControl5 --ignore-return
275
116
              # FIXME: maybe it would be better to decide whether to run the handler in a per-test basis?
276
117
              --task ${CMAKE_BINARY_DIR}/handler/telephony-service-handler --task-name telephony-service-handler --wait-for org.freedesktop.Telepathy.ConnectionManager.mock --ignore-return
277
118
              ${ARG_TASKS})
278
119
279
120
    if (NOT DEFINED ARG_LIBRARIES)
280
121
        set(ARG_LIBRARIES ${TP_QT5_LIBRARIES} telephonyservice mockcontroller telepathytest)
281
122
    endif(NOT DEFINED ARG_LIBRARIES)
282
123
283
124
    if (NOT DEFINED ARG_QT5_MODULES)
284
125
        set(ARG_QT5_MODULES Core DBus Test Qml)
285
126
    endif (NOT DEFINED ARG_QT5_MODULES)
286
127
    generate_test(${TESTNAME} ${ARGN}
287
128
                  TASKS ${TASKS}
288
129
                  LIBRARIES ${ARG_LIBRARIES} 
289
130
                  QT5_MODULES ${ARG_QT5_MODULES} 
290
131
                  USE_DBUS USE_UI 
291
132
                  WAIT_FOR org.freedesktop.Telepathy.Client.TelephonyServiceHandler)
292
133
endfunction(generate_telepathy_test)
293
0
134
294
=== modified file 'handler/CMakeLists.txt'
295
--- handler/CMakeLists.txt	2014-08-05 20:04:00 +0000
296
+++ handler/CMakeLists.txt	2015-03-30 20:55:55 +0000
297
@@ -26,6 +26,8 @@
298
26
    telephonyservice
26
    telephonyservice
299
27
    )
27
    )
300
28
28
301
29
enable_coverage(telephony-service-handler)
302
30
303
29
configure_file(com.canonical.TelephonyServiceHandler.service.in com.canonical.TelephonyServiceHandler.service)
31
configure_file(com.canonical.TelephonyServiceHandler.service.in com.canonical.TelephonyServiceHandler.service)
304
30
configure_file(org.freedesktop.Telepathy.Client.TelephonyServiceHandler.service.in org.freedesktop.Telepathy.Client.TelephonyServiceHandler.service)
32
configure_file(org.freedesktop.Telepathy.Client.TelephonyServiceHandler.service.in org.freedesktop.Telepathy.Client.TelephonyServiceHandler.service)
305
31
33
306
@@ -33,9 +35,3 @@
307
33
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.Client.TelephonyServiceHandler.service DESTINATION share/dbus-1/services)
35
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.Client.TelephonyServiceHandler.service DESTINATION share/dbus-1/services)
308
34
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.TelephonyServiceHandler.service DESTINATION share/dbus-1/services)
36
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/com.canonical.TelephonyServiceHandler.service DESTINATION share/dbus-1/services)
309
35
install(FILES TelephonyServiceHandler.client DESTINATION share/telepathy/clients)
37
install(FILES TelephonyServiceHandler.client DESTINATION share/telepathy/clients)
310
36
311
37
if(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc*")
312
38
    message(STATUS "Tests disabled on ppc")
313
39
else()
314
40
    add_subdirectory(tests)
315
41
endif()
316
42
38
317
=== modified file 'handler/handler.cpp'
318
--- handler/handler.cpp	2015-02-09 20:32:32 +0000
319
+++ handler/handler.cpp	2015-03-30 20:55:55 +0000
320
@@ -97,6 +97,7 @@
321
97
    specList << TelepathyHelper::audioConferenceSpec();
97
    specList << TelepathyHelper::audioConferenceSpec();
322
98
    specList << Tp::ChannelClassSpec::audioCall();
98
    specList << Tp::ChannelClassSpec::audioCall();
323
99
    specList << Tp::ChannelClassSpec::textChat();
99
    specList << Tp::ChannelClassSpec::textChat();
324
100
    specList << Tp::ChannelClassSpec::unnamedTextChat();
325
100
101
326
101
    return specList;
102
    return specList;
327
102
}
103
}
328
103
104
329
=== removed file 'handler/tests/dbus-test-wrapper.sh.in'
330
--- handler/tests/dbus-test-wrapper.sh.in	2014-03-27 13:26:31 +0000
331
+++ handler/tests/dbus-test-wrapper.sh.in	1970-01-01 00:00:00 +0000
332
@@ -1,35 +0,0 @@
333
1
#!/bin/sh -x
334
2
335
3
# export the home folder to somewhere in /tmp
336
4
TMPDIR=/tmp/telephony_service_test_home
337
5
rm -rf $TMPDIR
338
6
mkdir -p $TMPDIR
339
7
export HOME=$TMPDIR
340
8
341
9
# now run gnome-keyring
342
10
gnome-keyring-daemon -r -d
343
11
344
12
# we need to set this otherwise mission-control doesn't work properly
345
13
dconf write /org/gnome/empathy/use-conn false
346
14
347
15
# start the mock connection manager
348
16
@CMAKE_CURRENT_BINARY_DIR@/mock/telepathy-mock &
349
17
MOCK_PID=$!
350
18
351
19
# wait 1 sec for the mock to start up
352
20
sleep 1
353
21
354
22
mc-tool add mock/mock account0
355
23
356
24
@CMAKE_CURRENT_BINARY_DIR@/../telephony-service-handler &
357
25
358
26
HANDLER_PID=$!
359
27
360
28
$@
361
29
RESULT=$?
362
30
363
31
# FIXME: check the variables and things that should not be started
364
32
kill -9 $HANDLER_PID
365
33
kill -9 $MOCK_PID
366
34
367
35
return $RESULT
368
36
0
369
=== removed file 'handler/tests/telepathyhelper.cpp'
370
--- handler/tests/telepathyhelper.cpp	2014-01-07 19:53:45 +0000
371
+++ handler/tests/telepathyhelper.cpp	1970-01-01 00:00:00 +0000
372
@@ -1,279 +0,0 @@
373
1
/**
374
2
 * Copyright (C) 2013 Canonical, Ltd.
375
3
 *
376
4
 * This program is free software: you can redistribute it and/or modify it under
377
5
 * the terms of the GNU General Public License version 3, as published by
378
6
 * the Free Software Foundation.
379
7
 *
380
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
381
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
382
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
383
11
 * General Public License for more details.
384
12
 *
385
13
 * You should have received a copy of the GNU General Public License
386
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
387
15
 *
388
16
 * Authors: 
389
17
 *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
390
18
 *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
391
19
 */
392
20
393
21
#include "telepathyhelper.h"
394
22
#include <TelepathyQt/AbstractClient>
395
23
#include <TelepathyQt/AccountSet>
396
24
#include <TelepathyQt/ClientRegistrar>
397
25
#include <TelepathyQt/PendingReady>
398
26
#include <TelepathyQt/PendingAccount>
399
27
400
28
TelepathyHelper::TelepathyHelper(QObject *parent)
401
29
    : QObject(parent),
402
30
      //mChannelObserver(0),
403
31
      mFirstTime(true),
404
32
      mConnected(false),
405
33
      mHandlerInterface(0)
406
34
{
407
35
    Tp::registerTypes();
408
36
409
37
    mAccountFeatures << Tp::Account::FeatureCore;
410
38
    mContactFeatures << Tp::Contact::FeatureAlias
411
39
                     << Tp::Contact::FeatureAvatarData
412
40
                     << Tp::Contact::FeatureAvatarToken
413
41
                     << Tp::Contact::FeatureCapabilities
414
42
                     << Tp::Contact::FeatureSimplePresence;
415
43
    mConnectionFeatures << Tp::Connection::FeatureCore
416
44
                        << Tp::Connection::FeatureSelfContact
417
45
                        << Tp::Connection::FeatureSimplePresence;
418
46
419
47
    Tp::ChannelFactoryPtr channelFactory = Tp::ChannelFactory::create(QDBusConnection::sessionBus());
420
48
    channelFactory->addCommonFeatures(Tp::Channel::FeatureCore);
421
49
422
50
    mAccountManager = Tp::AccountManager::create(
423
51
            Tp::AccountFactory::create(QDBusConnection::sessionBus(), mAccountFeatures),
424
52
            Tp::ConnectionFactory::create(QDBusConnection::sessionBus(), mConnectionFeatures),
425
53
            channelFactory,
426
54
            Tp::ContactFactory::create(mContactFeatures));
427
55
428
56
    connect(mAccountManager->becomeReady(Tp::AccountManager::FeatureCore),
429
57
            SIGNAL(finished(Tp::PendingOperation*)),
430
58
            SLOT(onAccountManagerReady(Tp::PendingOperation*)));
431
59
432
60
    mClientRegistrar = Tp::ClientRegistrar::create(mAccountManager);
433
61
}
434
62
435
63
TelepathyHelper::~TelepathyHelper()
436
64
{
437
65
}
438
66
439
67
TelepathyHelper *TelepathyHelper::instance()
440
68
{
441
69
    static TelepathyHelper* helper = new TelepathyHelper();
442
70
    return helper;
443
71
}
444
72
445
73
QString TelepathyHelper::accountId() const
446
74
{
447
75
    if (mAccount) {
448
76
        return mAccount->uniqueIdentifier();
449
77
    }
450
78
    return QString();
451
79
}
452
80
453
81
Tp::AccountPtr TelepathyHelper::account() const
454
82
{
455
83
    return mAccount;
456
84
}
457
85
458
86
/*
459
87
ChannelObserver *TelepathyHelper::channelObserver() const
460
88
{
461
89
    return mChannelObserver;
462
90
}
463
91
*/
464
92
465
93
bool TelepathyHelper::connected() const
466
94
{
467
95
    return mConnected;
468
96
}
469
97
470
98
/*
471
99
void TelepathyHelper::registerChannelObserver(const QString &observerName)
472
100
{
473
101
    QString name = observerName;
474
102
475
103
    if (name.isEmpty()) {
476
104
        name = "TelephonyPluginObserver";
477
105
    }
478
106
479
107
    if (mChannelObserver) {
480
108
        mChannelObserver->deleteLater();
481
109
    }
482
110
483
111
    mChannelObserver = new ChannelObserver(this);
484
112
    registerClient(mChannelObserver, name);
485
113
486
114
    // messages
487
115
    connect(mChannelObserver, SIGNAL(textChannelAvailable(Tp::TextChannelPtr)),
488
116
            ChatManager::instance(), SLOT(onTextChannelAvailable(Tp::TextChannelPtr)));
489
117
490
118
    // calls
491
119
    connect(mChannelObserver, SIGNAL(callChannelAvailable(Tp::CallChannelPtr)),
492
120
            CallManager::instance(), SLOT(onCallChannelAvailable(Tp::CallChannelPtr)));
493
121
494
122
    Q_EMIT channelObserverCreated(mChannelObserver);
495
123
}
496
124
497
125
void TelepathyHelper::unregisterChannelObserver()
498
126
{
499
127
    Tp::AbstractClientPtr clientPtr(mChannelObserver);
500
128
    if (clientPtr) {
501
129
        mClientRegistrar->unregisterClient(clientPtr);
502
130
    }
503
131
    mChannelObserver->deleteLater();
504
132
    mChannelObserver = NULL;
505
133
    Q_EMIT channelObserverUnregistered();
506
134
}
507
135
*/
508
136
509
137
QStringList TelepathyHelper::supportedProtocols() const
510
138
{
511
139
    QStringList protocols;
512
140
    protocols << "mock";
513
141
    return protocols;
514
142
}
515
143
516
144
void TelepathyHelper::initializeAccount()
517
145
{
518
146
    // watch for account state and connection changes
519
147
    connect(mAccount.data(),
520
148
            SIGNAL(stateChanged(bool)),
521
149
            SLOT(onAccountStateChanged(bool)));
522
150
    connect(mAccount.data(),
523
151
            SIGNAL(connectionChanged(const Tp::ConnectionPtr&)),
524
152
            SLOT(onAccountConnectionChanged(const Tp::ConnectionPtr&)));
525
153
526
154
    // and make sure it is enabled and connected
527
155
    if (!mAccount->isEnabled()) {
528
156
        ensureAccountEnabled();
529
157
    } else {
530
158
        ensureAccountConnected();
531
159
    }
532
160
}
533
161
534
162
void TelepathyHelper::ensureAccountEnabled()
535
163
{
536
164
    mAccount->setConnectsAutomatically(true);
537
165
    connect(mAccount->setEnabled(true),
538
166
            SIGNAL(finished(Tp::PendingOperation*)),
539
167
            SLOT(onAccountEnabled(Tp::PendingOperation*)));
540
168
}
541
169
542
170
void TelepathyHelper::ensureAccountConnected()
543
171
{
544
172
    // if the account is not connected, request it to connect
545
173
    if (!mAccount->connection() || mAccount->connectionStatus() != Tp::ConnectionStatusConnected) {
546
174
        Tp::Presence presence(Tp::ConnectionPresenceTypeAvailable, "available", "online");
547
175
        mAccount->setRequestedPresence(presence);
548
176
    } else {
549
177
        watchSelfContactPresence();
550
178
    }
551
179
552
180
    if (mFirstTime) {
553
181
        Q_EMIT accountReady();
554
182
        mFirstTime = false;
555
183
    }
556
184
}
557
185
558
186
void TelepathyHelper::watchSelfContactPresence()
559
187
{
560
188
    if (mAccount.isNull() || mAccount->connection().isNull()) {
561
189
        return;
562
190
    }
563
191
564
192
    connect(mAccount->connection()->selfContact().data(),
565
193
            SIGNAL(presenceChanged(Tp::Presence)),
566
194
            SLOT(onPresenceChanged(Tp::Presence)));
567
195
    onPresenceChanged(mAccount->connection()->selfContact()->presence());
568
196
}
569
197
570
198
void TelepathyHelper::registerClient(Tp::AbstractClient *client, QString name)
571
199
{
572
200
    Tp::AbstractClientPtr clientPtr(client);
573
201
    bool succeeded = mClientRegistrar->registerClient(clientPtr, name);
574
202
    if (!succeeded) {
575
203
        name.append("%1");
576
204
        int count = 0;
577
205
        // limit the number of registered clients to 20, that should be a safe margin
578
206
        while (!succeeded && count < 20) {
579
207
            succeeded = mClientRegistrar->registerClient(clientPtr, name.arg(++count));
580
208
            if (succeeded) {
581
209
                name = name.arg(count);
582
210
            }
583
211
        }
584
212
    }
585
213
586
214
    if (succeeded) {
587
215
        QObject *object = dynamic_cast<QObject*>(client);
588
216
        if (object) {
589
217
            object->setProperty("clientName", TP_QT_IFACE_CLIENT + "." + name );
590
218
        }
591
219
    }
592
220
}
593
221
594
222
void TelepathyHelper::onAccountManagerReady(Tp::PendingOperation *op)
595
223
{
596
224
    Q_UNUSED(op)
597
225
598
226
    Tp::AccountSetPtr accountSet;
599
227
    // try to find an account of the one of supported protocols
600
228
    Q_FOREACH(const QString &protocol, supportedProtocols()) {
601
229
        accountSet = mAccountManager->accountsByProtocol(protocol);
602
230
        if (accountSet->accounts().count() > 0) {
603
231
            break;
604
232
        }
605
233
    }
606
234
607
235
    if (accountSet->accounts().count() == 0) {
608
236
        qCritical() << "No compatible telepathy account found!";
609
237
        return;
610
238
    }
611
239
612
240
    mAccount = accountSet->accounts()[0];
613
241
614
242
    // in case we have more than one account, the first one to show on the list is going to be used
615
243
    if (accountSet->accounts().count() > 1) {
616
244
        qWarning() << "There are more than just one account of type" << mAccount->protocolName();
617
245
    }
618
246
619
247
    Q_EMIT accountIdChanged();
620
248
621
249
    initializeAccount();
622
250
}
623
251
624
252
void TelepathyHelper::onAccountEnabled(Tp::PendingOperation *op)
625
253
{
626
254
    // we might need to do more stuff once the account is enabled, but making sure it is connected is a good start
627
255
    ensureAccountConnected();
628
256
}
629
257
630
258
void TelepathyHelper::onAccountStateChanged(bool enabled)
631
259
{
632
260
    if (!enabled) {
633
261
        ensureAccountEnabled();
634
262
    }
635
263
}
636
264
637
265
void TelepathyHelper::onAccountConnectionChanged(const Tp::ConnectionPtr &connection)
638
266
{
639
267
    if (connection.isNull()) {
640
268
        ensureAccountConnected();
641
269
    } else {
642
270
        watchSelfContactPresence();
643
271
    }
644
272
    Q_EMIT connectionChanged();
645
273
}
646
274
647
275
void TelepathyHelper::onPresenceChanged(const Tp::Presence &presence)
648
276
{
649
277
    mConnected = (presence.type() == Tp::ConnectionPresenceTypeAvailable);
650
278
    Q_EMIT connectedChanged();
651
279
}
652
280
0
653
=== removed file 'handler/tests/telepathyhelper.h'
654
--- handler/tests/telepathyhelper.h	2014-06-27 17:45:58 +0000
655
+++ handler/tests/telepathyhelper.h	1970-01-01 00:00:00 +0000
656
@@ -1,95 +0,0 @@
657
1
/**
658
2
 * Copyright (C) 2013 Canonical, Ltd.
659
3
 *
660
4
 * This program is free software: you can redistribute it and/or modify it under
661
5
 * the terms of the GNU General Public License version 3, as published by
662
6
 * the Free Software Foundation.
663
7
 *
664
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
665
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
666
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
667
11
 * General Public License for more details.
668
12
 *
669
13
 * You should have received a copy of the GNU General Public License
670
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
671
15
 *
672
16
 * Authors: 
673
17
 *  Tiago Salem Herrmann <tiago.herrmann@canonical.com>
674
18
 *  Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
675
19
 */
676
20
677
21
#ifndef TELEPATHYHELPER_H
678
22
#define TELEPATHYHELPER_H
679
23
680
24
#include <QObject>
681
25
#include <TelepathyQt/AccountManager>
682
26
#include <TelepathyQt/Contact>
683
27
#include <TelepathyQt/Connection>
684
28
#include <TelepathyQt/ConnectionManager>
685
29
#include <TelepathyQt/Types>
686
30
//#include "channelobserver.h"
687
31
688
32
#define CANONICAL_TELEPHONY_VOICEMAIL_IFACE "com.canonical.Telephony.Voicemail"
689
33
#define CANONICAL_TELEPHONY_SPEAKER_IFACE "com.canonical.Telephony.Speaker"
690
34
#define CANONICAL_TELEPHONY_EMERGENCYMODE_IFACE "com.canonical.Telephony.EmergencyMode"
691
35
692
36
class TelepathyHelper : public QObject
693
37
{
694
38
    Q_OBJECT
695
39
    Q_PROPERTY(bool connected READ connected NOTIFY connectedChanged)
696
40
    Q_PROPERTY(QString accountId READ accountId NOTIFY accountIdChanged)
697
41
698
42
public:
699
43
    ~TelepathyHelper();
700
44
701
45
    static TelepathyHelper *instance();
702
46
    Tp::AccountPtr account() const;
703
47
    //ChannelObserver *channelObserver() const;
704
48
705
49
    bool connected() const;
706
50
    QString accountId() const;
707
51
708
52
    void registerClient(Tp::AbstractClient *client, QString name);
709
53
710
54
Q_SIGNALS:
711
55
    //void channelObserverCreated(ChannelObserver *observer);
712
56
    //void channelObserverUnregistered();
713
57
    void accountReady();
714
58
    void connectionChanged();
715
59
    void connectedChanged();
716
60
    void accountIdChanged();
717
61
718
62
public Q_SLOTS:
719
63
    //Q_INVOKABLE void registerChannelObserver(const QString &observerName = QString::null);
720
64
    //Q_INVOKABLE void unregisterChannelObserver();
721
65
722
66
protected:
723
67
    QStringList supportedProtocols() const;
724
68
    void initializeAccount();
725
69
    void ensureAccountEnabled();
726
70
    void ensureAccountConnected();
727
71
    void watchSelfContactPresence();
728
72
729
73
private Q_SLOTS:
730
74
    void onAccountManagerReady(Tp::PendingOperation *op);
731
75
    void onAccountEnabled(Tp::PendingOperation *op);
732
76
    void onAccountStateChanged(bool enabled);
733
77
    void onAccountConnectionChanged(const Tp::ConnectionPtr &connection);
734
78
    void onPresenceChanged(const Tp::Presence &presence);
735
79
736
80
private:
737
81
    explicit TelepathyHelper(QObject *parent = 0);
738
82
    Tp::AccountManagerPtr mAccountManager;
739
83
    Tp::Features mAccountManagerFeatures;
740
84
    Tp::Features mAccountFeatures;
741
85
    Tp::Features mContactFeatures;
742
86
    Tp::Features mConnectionFeatures;
743
87
    Tp::ClientRegistrarPtr mClientRegistrar;
744
88
    Tp::AccountPtr mAccount;
745
89
    //ChannelObserver *mChannelObserver;
746
90
    bool mFirstTime;
747
91
    bool mConnected;
748
92
    QDBusInterface *mHandlerInterface;
749
93
};
750
94
751
95
#endif // TELEPATHYHELPER_H
752
96
0
753
=== modified file 'indicator/CMakeLists.txt'
754
--- indicator/CMakeLists.txt	2014-04-07 19:21:14 +0000
755
+++ indicator/CMakeLists.txt	2015-03-30 20:55:55 +0000
756
@@ -47,6 +47,8 @@
757
47
    telephonyservice
47
    telephonyservice
758
48
    )
48
    )
759
49
49
760
50
enable_coverage(telephony-service-indicator)
761
51
762
50
configure_file(org.freedesktop.Telepathy.Client.TelephonyServiceIndicator.service.in org.freedesktop.Telepathy.Client.TelephonyServiceIndicator.service)
52
configure_file(org.freedesktop.Telepathy.Client.TelephonyServiceIndicator.service.in org.freedesktop.Telepathy.Client.TelephonyServiceIndicator.service)
763
51
install(TARGETS telephony-service-indicator RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
53
install(TARGETS telephony-service-indicator RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
764
52
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.Client.TelephonyServiceIndicator.service DESTINATION share/dbus-1/services)
54
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.freedesktop.Telepathy.Client.TelephonyServiceIndicator.service DESTINATION share/dbus-1/services)
765
53
55
766
=== modified file 'libtelephonyservice/CMakeLists.txt'
767
--- libtelephonyservice/CMakeLists.txt	2015-03-30 20:55:55 +0000
768
+++ libtelephonyservice/CMakeLists.txt	2015-03-30 20:55:55 +0000
769
@@ -38,4 +38,4 @@
770
38
38
771
39
qt5_use_modules(telephonyservice Contacts Core DBus Feedback Multimedia Qml Quick)
39
qt5_use_modules(telephonyservice Contacts Core DBus Feedback Multimedia Qml Quick)
772
40
40
774
41
add_subdirectory(tests)
41
enable_coverage(telephonyservice)
775
42
42
776
=== modified file 'libtelephonyservice/accountentry.cpp'
777
--- libtelephonyservice/accountentry.cpp	2015-03-30 20:55:55 +0000
778
+++ libtelephonyservice/accountentry.cpp	2015-03-30 20:55:55 +0000
779
@@ -41,7 +41,8 @@
780
41
41
781
42
bool AccountEntry::active() const
42
bool AccountEntry::active() const
782
43
{
43
{
784
44
    return (!mAccount->connection().isNull() &&
44
    return (!mAccount.isNull() &&
785
45
            !mAccount->connection().isNull() &&
786
45
            !mAccount->connection()->selfContact().isNull() &&
46
            !mAccount->connection()->selfContact().isNull() &&
787
46
             mAccount->connection()->selfContact()->presence().type() != Tp::ConnectionPresenceTypeOffline);
47
             mAccount->connection()->selfContact()->presence().type() != Tp::ConnectionPresenceTypeOffline);
788
47
}
48
}
789
@@ -70,10 +71,7 @@
790
70
        return QString::null;
71
        return QString::null;
791
71
    }
72
    }
792
72
    Tp::Presence presence = mAccount->connection()->selfContact()->presence();
73
    Tp::Presence presence = mAccount->connection()->selfContact()->presence();
797
73
    if (presence.type() == Tp::ConnectionPresenceTypeAvailable) {
74
    return presence.statusMessage();
794
74
        return presence.statusMessage();
795
75
    }
796
76
    return QString::null;
798
77
}
75
}
799
78
76
800
79
QString AccountEntry::selfContactId() const
77
QString AccountEntry::selfContactId() const
801
@@ -147,6 +145,10 @@
802
147
            SIGNAL(connectionChanged(Tp::ConnectionPtr)),
145
            SIGNAL(connectionChanged(Tp::ConnectionPtr)),
803
148
            SLOT(onConnectionChanged()));
146
            SLOT(onConnectionChanged()));
804
149
147
805
148
    connect(this,
806
149
            SIGNAL(connectedChanged()),
807
150
            SIGNAL(activeChanged()));
808
151
809
150
    // and make sure it is enabled and connected
152
    // and make sure it is enabled and connected
810
151
    if (!mAccount->isEnabled()) {
153
    if (!mAccount->isEnabled()) {
811
152
        QTimer::singleShot(0, this, SLOT(ensureEnabled()));
154
        QTimer::singleShot(0, this, SLOT(ensureEnabled()));
812
@@ -203,15 +205,12 @@
813
203
    Q_EMIT statusMessageChanged();
205
    Q_EMIT statusMessageChanged();
814
204
    Q_EMIT connectedChanged();
206
    Q_EMIT connectedChanged();
815
205
    Q_EMIT selfContactIdChanged();
207
    Q_EMIT selfContactIdChanged();
816
206
    Q_EMIT activeChanged();
817
207
}
208
}
818
208
209
819
209
void AccountEntry::onConnectionChanged()
210
void AccountEntry::onConnectionChanged()
820
210
{
211
{
821
211
    if (!mAccount->connection()) {
212
    if (!mAccount->connection()) {
825
212
213
        // ensure the account gets connected
823
213
824
214
        // and ensure the account gets connected
826
215
        ensureConnected();
214
        ensureConnected();
827
216
    } else {
215
    } else {
828
217
        mConnectionInfo.busName = mAccount->connection()->busName();
216
        mConnectionInfo.busName = mAccount->connection()->busName();
829
@@ -226,5 +225,4 @@
830
226
225
831
227
    Q_EMIT connectedChanged();
226
    Q_EMIT connectedChanged();
832
228
    Q_EMIT selfContactIdChanged();
227
    Q_EMIT selfContactIdChanged();
833
229
    Q_EMIT activeChanged();
834
230
}
228
}
835
231
229
836
=== modified file 'libtelephonyservice/accountentryfactory.cpp'
837
--- libtelephonyservice/accountentryfactory.cpp	2015-03-30 20:55:55 +0000
838
+++ libtelephonyservice/accountentryfactory.cpp	2015-03-30 20:55:55 +0000
839
@@ -25,7 +25,7 @@
840
25
25
841
26
AccountEntry *AccountEntryFactory::createEntry(const Tp::AccountPtr &account, QObject *parent)
26
AccountEntry *AccountEntryFactory::createEntry(const Tp::AccountPtr &account, QObject *parent)
842
27
{
27
{
844
28
    QString protocol = account->protocolName();
28
    QString protocol = account.isNull() ? "" : account->protocolName();
845
29
29
846
30
    // FIXME: check what other accounts need extra properties/methods
30
    // FIXME: check what other accounts need extra properties/methods
847
31
    if (protocol == "ofono") {
31
    if (protocol == "ofono") {
848
@@ -34,7 +34,3 @@
849
34
34
850
35
    return new AccountEntry(account, parent);
35
    return new AccountEntry(account, parent);
851
36
}
36
}
852
37
853
38
AccountEntryFactory::AccountEntryFactory()
854
39
{
855
40
}
856
41
37
857
=== modified file 'libtelephonyservice/accountentryfactory.h'
858
--- libtelephonyservice/accountentryfactory.h	2015-03-30 20:55:55 +0000
859
+++ libtelephonyservice/accountentryfactory.h	2015-03-30 20:55:55 +0000
860
@@ -31,8 +31,6 @@
861
31
public:
31
public:
862
32
    static AccountEntry *createEntry(const Tp::AccountPtr &account, QObject *parent = 0);
32
    static AccountEntry *createEntry(const Tp::AccountPtr &account, QObject *parent = 0);
863
33
33
864
34
private:
865
35
    explicit AccountEntryFactory();
866
36
};
34
};
867
37
35
868
38
#endif // ACCOUNTENTRYFACTORY_H
36
#endif // ACCOUNTENTRYFACTORY_H
869
39
37
870
=== modified file 'libtelephonyservice/channelobserver.cpp'
871
--- libtelephonyservice/channelobserver.cpp	2015-02-09 20:32:32 +0000
872
+++ libtelephonyservice/channelobserver.cpp	2015-03-30 20:55:55 +0000
873
@@ -38,6 +38,7 @@
874
38
    specList << TelepathyHelper::audioConferenceSpec();
38
    specList << TelepathyHelper::audioConferenceSpec();
875
39
    specList << Tp::ChannelClassSpec::audioCall();
39
    specList << Tp::ChannelClassSpec::audioCall();
876
40
    specList << Tp::ChannelClassSpec::textChat();
40
    specList << Tp::ChannelClassSpec::textChat();
877
41
    specList << Tp::ChannelClassSpec::unnamedTextChat();
878
41
42
879
42
    return specList;
43
    return specList;
880
43
}
44
}
881
44
45
882
=== modified file 'libtelephonyservice/chatmanager.cpp'
883
--- libtelephonyservice/chatmanager.cpp	2015-03-30 20:55:55 +0000
884
+++ libtelephonyservice/chatmanager.cpp	2015-03-30 20:55:55 +0000
885
@@ -26,6 +26,7 @@
886
26
#include "dbustypes.h"
26
#include "dbustypes.h"
887
27
#include "accountentry.h"
27
#include "accountentry.h"
888
28
28
889
29
#include <TelepathyQt/Contact>
890
29
#include <TelepathyQt/ContactManager>
30
#include <TelepathyQt/ContactManager>
891
30
#include <TelepathyQt/PendingContacts>
31
#include <TelepathyQt/PendingContacts>
892
31
#include <QDBusArgument>
32
#include <QDBusArgument>
893
@@ -114,6 +115,7 @@
894
114
115
895
115
void ChatManager::sendMessage(const QStringList &recipients, const QString &message, const QString &accountId)
116
void ChatManager::sendMessage(const QStringList &recipients, const QString &message, const QString &accountId)
896
116
{
117
{
897
118
    // FIXME: this probably should be handle internally by telepathy-ofono
898
117
    if (recipients.size() > 1 && TelepathyHelper::instance()->mmsGroupChat()) {
119
    if (recipients.size() > 1 && TelepathyHelper::instance()->mmsGroupChat()) {
899
118
        sendMMS(recipients, message, QVariant(), accountId);
120
        sendMMS(recipients, message, QVariant(), accountId);
900
119
        return;
121
        return;
901
@@ -173,9 +175,12 @@
902
173
        return;
175
        return;
903
174
    }
176
    }
904
175
177
907
176
    if (!channel->targetContact().isNull()) {
178
    QStringList recipients;
908
177
        Q_EMIT messageSent(channel->targetContact()->id(), sentMessage.text());
179
    Q_FOREACH(const Tp::ContactPtr &contact, channel->groupContacts(false)) {
909
180
        recipients << contact->id();
910
178
    }
181
    }
911
182
912
183
    Q_EMIT messageSent(recipients, sentMessage.text());
913
179
}
184
}
914
180
185
915
181
void ChatManager::acknowledgeMessage(const QStringList &recipients, const QString &messageId, const QString &accountId)
186
void ChatManager::acknowledgeMessage(const QStringList &recipients, const QString &messageId, const QString &accountId)
916
182
187
917
=== modified file 'libtelephonyservice/chatmanager.h'
918
--- libtelephonyservice/chatmanager.h	2015-03-30 20:55:55 +0000
919
+++ libtelephonyservice/chatmanager.h	2015-03-30 20:55:55 +0000
920
@@ -38,8 +38,8 @@
921
38
    Q_INVOKABLE void sendMMS(const QStringList &recipients, const QString &message, const QVariant &attachments, const QString &accountId = QString:: null);
38
    Q_INVOKABLE void sendMMS(const QStringList &recipients, const QString &message, const QVariant &attachments, const QString &accountId = QString:: null);
922
39
39
923
40
Q_SIGNALS:
40
Q_SIGNALS:
926
41
    void messageReceived(const QString &recipient, const QString &message, const QDateTime &timestamp, const QString &messageId, bool unread);
41
    void messageReceived(const QString &sender, const QString &message, const QDateTime &timestamp, const QString &messageId, bool unread);
927
42
    void messageSent(const QString &recipient, const QString &message);
42
    void messageSent(const QStringList &recipients, const QString &message);
928
43
43
929
44
public Q_SLOTS:
44
public Q_SLOTS:
930
45
    void onTextChannelAvailable(Tp::TextChannelPtr channel);
45
    void onTextChannelAvailable(Tp::TextChannelPtr channel);
931
46
46
932
=== modified file 'libtelephonyservice/ofonoaccountentry.cpp'
933
--- libtelephonyservice/ofonoaccountentry.cpp	2015-03-30 20:55:55 +0000
934
+++ libtelephonyservice/ofonoaccountentry.cpp	2015-03-30 20:55:55 +0000
935
@@ -203,6 +203,5 @@
936
203
        mSerial = ussdIface.property("Serial").toString();
203
        mSerial = ussdIface.property("Serial").toString();
937
204
    }
204
    }
938
205
205
939
206
    Q_EMIT simLockedChanged();
940
207
    Q_EMIT serialChanged();
206
    Q_EMIT serialChanged();
941
208
}
207
}
942
209
208
943
=== modified file 'libtelephonyservice/telepathyhelper.cpp'
944
--- libtelephonyservice/telepathyhelper.cpp	2015-03-30 20:55:55 +0000
945
+++ libtelephonyservice/telepathyhelper.cpp	2015-03-30 20:55:55 +0000
946
@@ -247,10 +247,7 @@
947
247
247
948
248
void TelepathyHelper::unregisterChannelObserver()
248
void TelepathyHelper::unregisterChannelObserver()
949
249
{
249
{
954
250
    Tp::AbstractClientPtr clientPtr(mChannelObserver);
250
    unregisterClient(mChannelObserver);
951
251
    if (clientPtr) {
952
252
        mClientRegistrar->unregisterClient(clientPtr);
953
253
    }
955
254
    mChannelObserver->deleteLater();
251
    mChannelObserver->deleteLater();
956
255
    mChannelObserver = NULL;
252
    mChannelObserver = NULL;
957
256
    Q_EMIT channelObserverUnregistered();
253
    Q_EMIT channelObserverUnregistered();
958
@@ -315,6 +312,15 @@
959
315
    return succeeded;
312
    return succeeded;
960
316
}
313
}
961
317
314
962
315
bool TelepathyHelper::unregisterClient(Tp::AbstractClient *client)
963
316
{
964
317
    Tp::AbstractClientPtr clientPtr(client);
965
318
    if (clientPtr) {
966
319
        return mClientRegistrar->unregisterClient(clientPtr);
967
320
    }
968
321
    return false;
969
322
}
970
323
971
318
AccountEntry *TelepathyHelper::accountForConnection(const Tp::ConnectionPtr &connection) const
324
AccountEntry *TelepathyHelper::accountForConnection(const Tp::ConnectionPtr &connection) const
972
319
{
325
{
973
320
    if (connection.isNull()) {
326
    if (connection.isNull()) {
974
@@ -401,7 +407,7 @@
975
401
    Q_FOREACH(AccountEntry *account, mAccounts) {
407
    Q_FOREACH(AccountEntry *account, mAccounts) {
976
402
        QString modemObjName = account->account()->parameters().value("modem-objpath").toString();
408
        QString modemObjName = account->account()->parameters().value("modem-objpath").toString();
977
403
        if (modemObjName.isEmpty()) {
409
        if (modemObjName.isEmpty()) {
979
404
            sortedOtherAccounts[account->displayName()] = account;
410
            sortedOtherAccounts[account->accountId()] = account;
980
405
        } else {
411
        } else {
981
406
            sortedOfonoAccounts[modemObjName] = account;
412
            sortedOfonoAccounts[modemObjName] = account;
982
407
        }
413
        }
983
408
414
984
=== modified file 'libtelephonyservice/telepathyhelper.h'
985
--- libtelephonyservice/telepathyhelper.h	2015-02-09 20:32:32 +0000
986
+++ libtelephonyservice/telepathyhelper.h	2015-03-30 20:55:55 +0000
987
@@ -87,6 +87,7 @@
988
87
    Q_INVOKABLE void unlockSimCards() const;
87
    Q_INVOKABLE void unlockSimCards() const;
989
88
88
990
89
    bool registerClient(Tp::AbstractClient *client, QString name);
89
    bool registerClient(Tp::AbstractClient *client, QString name);
991
90
    bool unregisterClient(Tp::AbstractClient *client);
992
90
91
993
91
    // pre-populated channel class specs for conferences
92
    // pre-populated channel class specs for conferences
994
92
    static Tp::ChannelClassSpec audioConferenceSpec();
93
    static Tp::ChannelClassSpec audioConferenceSpec();
995
93
94
996
=== added directory 'tests'
997
=== added file 'tests/CMakeLists.txt'
998
--- tests/CMakeLists.txt	1970-01-01 00:00:00 +0000
999
+++ tests/CMakeLists.txt	2015-03-30 20:55:55 +0000
1000
@@ -0,0 +1,6 @@
1001
1
include (GenerateTest)
1002
2
1003
3
add_subdirectory(common)
1004
4
add_subdirectory(handler)
1005
5
add_subdirectory(libtelephonyservice)
1006
6
add_subdirectory(Ubuntu.Telephony)
1007
0
7
1008
=== renamed directory 'Ubuntu/Telephony/tests' => 'tests/Ubuntu.Telephony'
1009
=== modified file 'tests/Ubuntu.Telephony/CMakeLists.txt'
1010
--- Ubuntu/Telephony/tests/CMakeLists.txt	2014-07-11 21:30:21 +0000
1011
+++ tests/Ubuntu.Telephony/CMakeLists.txt	2015-03-30 20:55:55 +0000
1012
@@ -1,35 +1,19 @@
1013
1
include_directories(
1
include_directories(
1014
2
    ${CMAKE_CURRENT_BINARY_DIR}
2
    ${CMAKE_CURRENT_BINARY_DIR}
1015
3
    ${CMAKE_SOURCE_DIR}/Ubuntu/Telephony
3
    ${CMAKE_SOURCE_DIR}/Ubuntu/Telephony
1045
4
    )
4
    ${CMAKE_SOURCE_DIR}/libtelephonyservice
1046
5
5
    )
1047
6
macro(generate_tests)
6
1048
7
    foreach(test ${ARGN})
7
set(SOURCE_DIR ${CMAKE_SOURCE_DIR}/Ubuntu/Telephony)
1049
8
        add_executable(${test} ${test}.cpp)
8
generate_test(ContactWatcherTest USE_UI
1050
9
        qt5_use_modules(${test} Contacts Core DBus Qml Test)
9
              SOURCES ContactWatcherTest.cpp
1051
10
        target_link_libraries(${test}
10
              LIBRARIES telephonyservice-qml
1052
11
            telephonyservice-qml
11
              QT5_MODULES Contacts Core DBus Qml Test)
1053
12
            )
12
1054
13
        add_test(${test} ${CMAKE_CURRENT_BINARY_DIR}/${test} -platform offscreen -xunitxml -o ${CMAKE_BINARY_DIR}/test_${test}.xml)
13
generate_test(context_properties QML_TEST tst_contextProperties.qml)
1055
14
    endforeach(test)
14
generate_test(phonenumber_field QML_TEST tst_PhoneNumberField.qml)
1056
15
endmacro(generate_tests)
15
generate_test(phonenumber_input QML_TEST tst_PhoneNumberInput.qml)
1057
16
16
generate_test(phonenumber_utils QML_TEST tst_PhoneNumberPhoneUtils.qml)
1029
17
macro(DECLARE_QML_TEST TST_NAME TST_QML_FILE)
1030
18
    add_test(NAME ${TST_NAME}
1031
19
        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
1032
20
        COMMAND xvfb-run -a -s "-screen 0 1024x768x24" qmltestrunner -import ${CMAKE_BINARY_DIR} -input ${CMAKE_CURRENT_SOURCE_DIR}/${TST_QML_FILE}
1033
21
    )
1034
22
endmacro()
1035
23
1036
24
1037
25
generate_tests(
1038
26
    ContactWatcherTest
1039
27
    )
1040
28
1041
29
declare_qml_test("context_properties" tst_contextProperties.qml)
1042
30
declare_qml_test("phonenumber_field" tst_PhoneNumberField.qml)
1043
31
declare_qml_test("phonenumber_input" tst_PhoneNumberInput.qml)
1044
32
declare_qml_test("phonenumber_utils" tst_PhoneNumberPhoneUtils.qml)
1058
33
17
1059
34
# make the files visible on qtcreator
18
# make the files visible on qtcreator
1060
35
file(GLOB QML_TESTS *.qml *.js)
19
file(GLOB QML_TESTS *.qml *.js)
1061
36
20
1062
=== modified file 'tests/Ubuntu.Telephony/ContactWatcherTest.cpp'
1063
--- Ubuntu/Telephony/tests/ContactWatcherTest.cpp	2015-03-30 20:55:55 +0000
1064
+++ tests/Ubuntu.Telephony/ContactWatcherTest.cpp	2015-03-30 20:55:55 +0000
1065
@@ -438,6 +438,11 @@
1066
438
    watcher.setAddressableFields(addressableFields);
438
    watcher.setAddressableFields(addressableFields);
1067
439
    QCOMPARE(addressableFieldsSpy.count(), 1);
439
    QCOMPARE(addressableFieldsSpy.count(), 1);
1068
440
    QCOMPARE(watcher.addressableFields(), addressableFields);
440
    QCOMPARE(watcher.addressableFields(), addressableFields);
1069
441
1070
442
    // set the addressable fields to an empty value and make sure it falls back to "tel"
1071
443
    watcher.setAddressableFields(QStringList());
1072
444
    QCOMPARE(watcher.addressableFields().count(), 1);
1073
445
    QCOMPARE(watcher.addressableFields()[0], QString("tel"));
1074
441
}
446
}
1075
442
447
1076
443
void ContactWatcherTest::testExtendedFieldMatch()
448
void ContactWatcherTest::testExtendedFieldMatch()
1077
444
449
1078
=== added directory 'tests/common'
1079
=== added file 'tests/common/CMakeLists.txt'
1080
--- tests/common/CMakeLists.txt	1970-01-01 00:00:00 +0000
1081
+++ tests/common/CMakeLists.txt	2015-03-30 20:55:55 +0000
1082
@@ -0,0 +1,14 @@
1083
1
include_directories(${TP_QT5_INCLUDE_DIRS}
1084
2
                    ${CMAKE_SOURCE_DIR}/libtelephonyservice)
1085
3
1086
4
configure_file(dbus-session.conf.in ${CMAKE_CURRENT_BINARY_DIR}/dbus-session.conf)
1087
5
1088
6
add_library(mockcontroller STATIC mockcontroller.cpp mockcontroller.h)
1089
7
qt5_use_modules(mockcontroller Core DBus)
1090
8
1091
9
add_library(telepathytest STATIC telepathytest.cpp telepathytest.h)
1092
10
qt5_use_modules(telepathytest Core DBus)
1093
11
target_link_libraries(telepathytest telephonyservice ${TP_QT5_LIBRARIES})
1094
12
1095
13
add_subdirectory(mock)
1096
14
add_subdirectory(dbus-services)
1097
0
15
1098
=== added directory 'tests/common/dbus-services'
1099
=== added file 'tests/common/dbus-services/CMakeLists.txt'
1100
--- tests/common/dbus-services/CMakeLists.txt	1970-01-01 00:00:00 +0000
1101
+++ tests/common/dbus-services/CMakeLists.txt	2015-03-30 20:55:55 +0000
1102
@@ -0,0 +1,9 @@
1103
1
# copy the services we want to use
1104
2
set(DBUS_SERVICES_DIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/dbus-1/services)
1105
3
1106
4
file(COPY ${DBUS_SERVICES_DIR}/org.freedesktop.Telepathy.MissionControl5.service
1107
5
     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
1108
6
file(COPY ${DBUS_SERVICES_DIR}/org.freedesktop.Telepathy.AccountManager.service
1109
7
     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
1110
8
file(COPY ${DBUS_SERVICES_DIR}/ca.desrt.dconf.service
1111
9
     DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
1112
0
10
1113
=== added file 'tests/common/dbus-session.conf.in'
1114
--- tests/common/dbus-session.conf.in	1970-01-01 00:00:00 +0000
1115
+++ tests/common/dbus-session.conf.in	2015-03-30 20:55:55 +0000
1116
@@ -0,0 +1,42 @@
1117
1
<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
1118
2
 "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
1119
3
<busconfig>
1120
4
  <type>session</type>
1121
5
1122
6
  <!-- If we fork, keep the user's original umask to avoid affecting
1123
7
       the behavior of child processes. -->
1124
8
  <keep_umask/>
1125
9
1126
10
  <listen>unix:tmpdir=/tmp</listen>
1127
11
1128
12
  <servicedir>@CMAKE_CURRENT_BINARY_DIR@/dbus-services</servicedir>
1129
13
1130
14
  <policy context="default">
1131
15
    <!-- Allow everything to be sent -->
1132
16
    <allow send_destination="*" eavesdrop="true"/>
1133
17
    <!-- Allow everything to be received -->
1134
18
    <allow eavesdrop="true"/>
1135
19
    <!-- Allow anyone to own anything -->
1136
20
    <allow own="*"/>
1137
21
  </policy>
1138
22
1139
23
  <!-- raise the service start timeout to 40 seconds as it can timeout
1140
24
       on the live cd on slow machines -->
1141
25
  <limit name="service_start_timeout">60000</limit>
1142
26
1143
27
  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
1144
28
  <limit name="max_incoming_bytes">1000000000</limit>
1145
29
  <limit name="max_outgoing_bytes">1000000000</limit>
1146
30
  <limit name="max_message_size">1000000000</limit>
1147
31
  <limit name="service_start_timeout">120000</limit>  
1148
32
  <limit name="auth_timeout">240000</limit>
1149
33
  <limit name="max_completed_connections">100000</limit>  
1150
34
  <limit name="max_incomplete_connections">10000</limit>
1151
35
  <limit name="max_connections_per_user">100000</limit>
1152
36
  <limit name="max_pending_service_starts">10000</limit>
1153
37
  <limit name="max_names_per_connection">50000</limit>
1154
38
  <limit name="max_match_rules_per_connection">50000</limit>
1155
39
  <limit name="max_replies_per_connection">50000</limit>
1156
40
  <limit name="reply_timeout">300000</limit>
1157
41
1158
42
</busconfig>
1159
0
43
1160
=== renamed directory 'handler/tests/mock' => 'tests/common/mock'
1161
=== modified file 'tests/common/mock/CMakeLists.txt'
1162
--- handler/tests/mock/CMakeLists.txt	2014-03-13 17:11:09 +0000
1163
+++ tests/common/mock/CMakeLists.txt	2015-03-30 20:55:55 +0000
1164
@@ -4,11 +4,14 @@
1165
4
    ${Qt5DBus_INCLUDE_DIRS}
4
    ${Qt5DBus_INCLUDE_DIRS}
1166
5
    ${CMAKE_CURRENT_BINARY_DIR}
5
    ${CMAKE_CURRENT_BINARY_DIR}
1167
6
    ${CMAKE_CURRENT_SOURCE_DIR}
6
    ${CMAKE_CURRENT_SOURCE_DIR}
1168
7
    ${CMAKE_SOURCE_DIR}/libtelephonyservice
1169
7
    )
8
    )
1170
8
9
1171
9
find_library(TELEPATHY_QT5_SERVICE_LIBRARIES telepathy-qt5-service)
10
find_library(TELEPATHY_QT5_SERVICE_LIBRARIES telepathy-qt5-service)
1172
10
11
1174
11
set(mock_SRCS main.cpp protocol.cpp connection.cpp textchannel.cpp callchannel.cpp conferencecallchannel.cpp mockconnectiondbus.cpp speakeriface.cpp)
12
set(mock_SRCS main.cpp protocol.cpp connection.cpp textchannel.cpp callchannel.cpp
1175
13
              conferencecallchannel.cpp mockconnectiondbus.cpp speakeriface.cpp
1176
14
              emergencymodeiface.cpp ussdiface.cpp voicemailiface.cpp)
1177
12
qt5_add_dbus_adaptor(mock_SRCS MockConnection.xml mockconnectiondbus.h MockConnectionDBus)
15
qt5_add_dbus_adaptor(mock_SRCS MockConnection.xml mockconnectiondbus.h MockConnectionDBus)
1178
13
16
1179
14
add_executable(telepathy-mock ${mock_SRCS})
17
add_executable(telepathy-mock ${mock_SRCS})
1180
15
18
1181
=== modified file 'tests/common/mock/MockConnection.xml'
1182
--- handler/tests/mock/MockConnection.xml	2014-03-20 21:03:26 +0000
1183
+++ tests/common/mock/MockConnection.xml	2015-03-30 20:55:55 +0000
1184
@@ -38,6 +38,55 @@
1185
38
            <arg name="phoneNumber" type="s" direction="in"/>
38
            <arg name="phoneNumber" type="s" direction="in"/>
1186
39
            <arg name="status" type="s" direction="in"/>
39
            <arg name="status" type="s" direction="in"/>
1187
40
        </method>
40
        </method>
1188
41
        <method name="SetOnline">
1189
42
            <dox:d><![CDATA[
1190
43
                Set the account online/offline
1191
44
            ]]></dox:d>
1192
45
            <arg name="online" type="b" direction="in"/>
1193
46
        </method>
1194
47
        <method name="SetPresence">
1195
48
            <dox:d><![CDATA[
1196
49
                Set the requested presence
1197
50
            ]]></dox:d>
1198
51
            <arg name="status" type="s" direction="in"/>
1199
52
            <arg name="statusMessage" type="s" direction="in"/>
1200
53
        </method>
1201
54
        <method name="SetVoicemailIndicator">
1202
55
            <dox:d><![CDATA[
1203
56
                Set the voicemail indicator on/off
1204
57
            ]]></dox:d>
1205
58
            <arg name="active" type="b" direction="in"/>
1206
59
        </method>
1207
60
        <method name="SetVoicemailNumber">
1208
61
            <dox:d><![CDATA[
1209
62
                Set the voicemail number
1210
63
            ]]></dox:d>
1211
64
            <arg name="number" type="s" direction="in"/>
1212
65
        </method>
1213
66
        <method name="SetVoicemailCount">
1214
67
            <dox:d><![CDATA[
1215
68
                Set the voicemail count
1216
69
            ]]></dox:d>
1217
70
            <arg name="count" type="i" direction="in"/>
1218
71
        </method>
1219
72
        <method name="SetEmergencyNumbers">
1220
73
            <dox:d><![CDATA[
1221
74
                Set the emergency numbers
1222
75
            ]]></dox:d>
1223
76
            <arg name="numbers" type="as" direction="in"/>
1224
77
        </method>
1225
78
        <method name="Serial">
1226
79
            <dox:d><![CDATA[
1227
80
                Get the USSD serial
1228
81
            ]]></dox:d>
1229
82
            <arg name="value" type="s" direction="out"/>
1230
83
        </method>
1231
84
        <signal name="MessageRead">
1232
85
            <dox:d><![CDATA[
1233
86
                A message was acknowledged
1234
87
            ]]></dox:d>
1235
88
            <arg name="messageId" type="s"/>
1236
89
        </signal>
1237
41
        <signal name="MessageSent">
90
        <signal name="MessageSent">
1238
42
            <dox:d><![CDATA[
91
            <dox:d><![CDATA[
1239
43
                A message was sent from the client.
92
                A message was sent from the client.
1240
@@ -45,6 +94,7 @@
1241
45
            <arg name="message" type="s"/>
94
            <arg name="message" type="s"/>
1242
46
            <arg name="properties" type="a{sv}"/>
95
            <arg name="properties" type="a{sv}"/>
1243
47
            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
96
            <annotation name="org.qtproject.QtDBus.QtTypeName.In1" value="QVariantMap"/>
1244
97
            <annotation name="org.qtproject.QtDBus.QtTypeName.Out1" value="QVariantMap"/>
1245
48
        </signal>
98
        </signal>
1246
49
        <signal name="CallReceived">
99
        <signal name="CallReceived">
1247
50
            <dox:d><![CDATA[
100
            <dox:d><![CDATA[
1248
@@ -84,5 +134,15 @@
1249
84
            ]]></dox:d>
134
            ]]></dox:d>
1250
85
            <arg name="objectPath" type="s"/>
135
            <arg name="objectPath" type="s"/>
1251
86
        </signal>
136
        </signal>
1252
137
        <signal name="Disconnected">
1253
138
            <dox:d><![CDATA[
1254
139
                The account was disconnected
1255
140
            ]]></dox:d>
1256
141
        </signal>
1257
142
        <signal name="Destroyed">
1258
143
            <dox:d><![CDATA[
1259
144
                The connection object was destroyed
1260
145
            ]]></dox:d>
1261
146
        </signal>
1262
87
    </interface>
147
    </interface>
1263
88
</node>
148
</node>
1264
89
149
1265
=== modified file 'tests/common/mock/callchannel.cpp'
1266
--- handler/tests/mock/callchannel.cpp	2014-03-20 21:03:26 +0000
1267
+++ tests/common/mock/callchannel.cpp	2015-03-30 20:55:55 +0000
1268
@@ -172,7 +172,7 @@
1269
172
{
172
{
1270
173
    qDebug() << "call channel closed";
173
    qDebug() << "call channel closed";
1271
174
    // TODO - for some reason the object is not being removed
174
    // TODO - for some reason the object is not being removed
1273
175
    mConnection->dbusConnection().unregisterObject(mObjPath, QDBusConnection::UnregisterTree);
175
    mConnection->dbusConnection().unregisterObject(mBaseChannel->objectPath(), QDBusConnection::UnregisterTree);
1274
176
}
176
}
1275
177
177
1276
178
Tp::BaseChannelPtr MockCallChannel::baseChannel()
178
Tp::BaseChannelPtr MockCallChannel::baseChannel()
1277
179
179
1278
=== modified file 'tests/common/mock/connection.cpp'
1279
--- handler/tests/mock/connection.cpp	2014-04-03 16:38:01 +0000
1280
+++ tests/common/mock/connection.cpp	2015-03-30 20:55:55 +0000
1281
@@ -36,7 +36,7 @@
1282
36
                            const QString &protocolName,
36
                            const QString &protocolName,
1283
37
                            const QVariantMap &parameters) :
37
                            const QVariantMap &parameters) :
1284
38
    Tp::BaseConnection(dbusConnection, cmName, protocolName, parameters),
38
    Tp::BaseConnection(dbusConnection, cmName, protocolName, parameters),
1286
39
    mHandleCount(0), mConferenceCall(0)
39
    mConferenceCall(0), mVoicemailIndicator(false), mVoicemailCount(0)
1287
40
{
40
{
1288
41
    setSelfHandle(newHandle("<SelfHandle>"));
41
    setSelfHandle(newHandle("<SelfHandle>"));
1289
42
42
1290
@@ -54,6 +54,7 @@
1291
54
    text.fixedProperties[TP_QT_IFACE_CHANNEL+".TargetHandleType"]  = Tp::HandleTypeContact;
54
    text.fixedProperties[TP_QT_IFACE_CHANNEL+".TargetHandleType"]  = Tp::HandleTypeContact;
1292
55
    text.allowedProperties.append(TP_QT_IFACE_CHANNEL+".TargetHandle");
55
    text.allowedProperties.append(TP_QT_IFACE_CHANNEL+".TargetHandle");
1293
56
    text.allowedProperties.append(TP_QT_IFACE_CHANNEL+".TargetID");
56
    text.allowedProperties.append(TP_QT_IFACE_CHANNEL+".TargetID");
1294
57
    text.allowedProperties.append(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles"));
1295
57
58
1296
58
    // set requestable call channel properties
59
    // set requestable call channel properties
1297
59
    Tp::RequestableChannelClass call;
60
    Tp::RequestableChannelClass call;
1298
@@ -77,26 +78,41 @@
1299
77
    // init presence interface
78
    // init presence interface
1300
78
    simplePresenceIface = Tp::BaseConnectionSimplePresenceInterface::create();
79
    simplePresenceIface = Tp::BaseConnectionSimplePresenceInterface::create();
1301
79
    simplePresenceIface->setSetPresenceCallback(Tp::memFun(this,&MockConnection::setPresence));
80
    simplePresenceIface->setSetPresenceCallback(Tp::memFun(this,&MockConnection::setPresence));
1302
81
    simplePresenceIface->setMaxmimumStatusMessageLength(255);
1303
80
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(simplePresenceIface));
82
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(simplePresenceIface));
1304
81
83
1305
82
    // Set Presence
84
    // Set Presence
1306
83
    Tp::SimpleStatusSpec presenceOnline;
85
    Tp::SimpleStatusSpec presenceOnline;
1307
84
    presenceOnline.type = Tp::ConnectionPresenceTypeAvailable;
86
    presenceOnline.type = Tp::ConnectionPresenceTypeAvailable;
1308
85
    presenceOnline.maySetOnSelf = true;
87
    presenceOnline.maySetOnSelf = true;
1310
86
    presenceOnline.canHaveMessage = false;
88
    presenceOnline.canHaveMessage = true;
1311
87
89
1312
88
    Tp::SimpleStatusSpec presenceOffline;
90
    Tp::SimpleStatusSpec presenceOffline;
1313
89
    presenceOffline.type = Tp::ConnectionPresenceTypeOffline;
91
    presenceOffline.type = Tp::ConnectionPresenceTypeOffline;
1322
90
    presenceOffline.maySetOnSelf = false;
92
    presenceOffline.maySetOnSelf = true;
1323
91
    presenceOffline.canHaveMessage = false;
93
    presenceOffline.canHaveMessage = true;
1324
92
94
1325
93
    Tp::SimpleStatusSpecMap statuses;
95
    Tp::SimpleStatusSpec presenceAway;
1326
94
    statuses.insert(QLatin1String("available"), presenceOnline);
96
    presenceAway.type = Tp::ConnectionPresenceTypeAway;
1327
95
    statuses.insert(QLatin1String("offline"), presenceOffline);
97
    presenceAway.maySetOnSelf = true;
1328
96
98
    presenceAway.canHaveMessage = true;
1329
97
    simplePresenceIface->setStatuses(statuses);
99
1330
100
    mStatuses.insert(QLatin1String("available"), presenceOnline);
1331
101
    mStatuses.insert(QLatin1String("offline"), presenceOffline);
1332
102
    mStatuses.insert(QLatin1String("away"), presenceAway);
1333
103
    mStatuses.insert(QLatin1String("simlocked"), presenceAway);
1334
104
    mStatuses.insert(QLatin1String("flightmode"), presenceOffline);
1335
105
    mStatuses.insert(QLatin1String("nosim"), presenceOffline);
1336
106
    mStatuses.insert(QLatin1String("nomodem"), presenceOffline);
1337
107
    mStatuses.insert(QLatin1String("registered"), presenceOnline);
1338
108
    mStatuses.insert(QLatin1String("roaming"), presenceOnline);
1339
109
    mStatuses.insert(QLatin1String("unregistered"), presenceAway);
1340
110
    mStatuses.insert(QLatin1String("denied"), presenceAway);
1341
111
    mStatuses.insert(QLatin1String("unknown"), presenceAway);
1342
112
    mStatuses.insert(QLatin1String("searching"), presenceAway);
1343
113
1344
114
    simplePresenceIface->setStatuses(mStatuses);
1345
98
    mSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
115
    mSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
1346
99
    mRequestedSelfPresence.type = Tp::ConnectionPresenceTypeOffline;
1347
100
116
1348
101
    contactsIface = Tp::BaseConnectionContactsInterface::create();
117
    contactsIface = Tp::BaseConnectionContactsInterface::create();
1349
102
    contactsIface->setGetContactAttributesCallback(Tp::memFun(this,&MockConnection::getContactAttributes));
118
    contactsIface->setGetContactAttributesCallback(Tp::memFun(this,&MockConnection::getContactAttributes));
1350
@@ -105,9 +121,40 @@
1351
105
                                                 << TP_QT_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE);
121
                                                 << TP_QT_IFACE_CONNECTION_INTERFACE_SIMPLE_PRESENCE);
1352
106
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(contactsIface));
122
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(contactsIface));
1353
107
123
1354
124
    // init custom emergency mode interface (not provided by telepathy
1355
125
    emergencyModeIface = BaseConnectionEmergencyModeInterface::create();
1356
126
    emergencyModeIface->setEmergencyNumbersCallback(Tp::memFun(this,&MockConnection::emergencyNumbers));
1357
127
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(emergencyModeIface));
1358
128
    mEmergencyNumbers << "123" << "456" << "789";
1359
129
    emergencyModeIface->setEmergencyNumbers(mEmergencyNumbers);
1360
130
1361
131
    // init custom voicemail interface (not provided by telepathy)
1362
132
    voicemailIface = BaseConnectionVoicemailInterface::create();
1363
133
    voicemailIface->setVoicemailCountCallback(Tp::memFun(this,&MockConnection::voicemailCount));
1364
134
    voicemailIface->setVoicemailIndicatorCallback(Tp::memFun(this,&MockConnection::voicemailIndicator));
1365
135
    voicemailIface->setVoicemailNumberCallback(Tp::memFun(this,&MockConnection::voicemailNumber));
1366
136
    voicemailIface->setVoicemailNumber(mVoicemailNumber);
1367
137
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(voicemailIface));
1368
138
    voicemailIface->setVoicemailCount(mVoicemailCount);
1369
139
    voicemailIface->setVoicemailIndicator(mVoicemailIndicator);
1370
140
    mVoicemailNumber = "555";
1371
141
1372
142
    supplementaryServicesIface = BaseConnectionUSSDInterface::create();
1373
143
    supplementaryServicesIface->setInitiateCallback(Tp::memFun(this,&MockConnection::USSDInitiate));
1374
144
    supplementaryServicesIface->setRespondCallback(Tp::memFun(this,&MockConnection::USSDRespond));
1375
145
    supplementaryServicesIface->setCancelCallback(Tp::memFun(this,&MockConnection::USSDCancel));
1376
146
1377
147
    static int serial = 0;
1378
148
    serial++;
1379
149
    supplementaryServicesIface->setSerial(QString("accountserial%1").arg(QString::number(serial)));
1380
150
1381
151
    plugInterface(Tp::AbstractConnectionInterfacePtr::dynamicCast(supplementaryServicesIface));
1382
152
1383
108
    mDBus = new MockConnectionDBus(this);
153
    mDBus = new MockConnectionDBus(this);
1384
154
}
1385
109
155
1387
110
    setOnline(true);
156
MockConnection::~MockConnection()
1388
157
{
1389
111
}
158
}
1390
112
159
1391
113
void MockConnection::addMMSToService(const QString &path, const QVariantMap &properties, const QString &servicePath)
160
void MockConnection::addMMSToService(const QString &path, const QVariantMap &properties, const QString &servicePath)
1392
@@ -143,16 +190,45 @@
1393
143
#endif
190
#endif
1394
144
}
191
}
1395
145
192
1397
146
MockConnection::~MockConnection()
193
MockTextChannel *MockConnection::textChannelForRecipients(const QStringList &recipients)
1398
147
{
194
{
1399
195
    Q_FOREACH(MockTextChannel *channel, mTextChannels) {
1400
196
        QStringList channelRecipients = channel->recipients();
1401
197
        if (channelRecipients.length() != recipients.length()) {
1402
198
            continue;
1403
199
        }
1404
200
1405
201
        bool ok = true;
1406
202
        Q_FOREACH(const QString &recipient, recipients) {
1407
203
            if (!channelRecipients.contains(recipient)) {
1408
204
                ok = false;
1409
205
                break;
1410
206
            }
1411
207
        }
1412
208
1413
209
        if (ok) {
1414
210
            return channel;
1415
211
        }
1416
212
    }
1417
213
    return 0;
1418
148
}
214
}
1419
149
215
1420
150
uint MockConnection::setPresence(const QString& status, const QString& statusMessage, Tp::DBusError *error)
216
uint MockConnection::setPresence(const QString& status, const QString& statusMessage, Tp::DBusError *error)
1421
151
{
217
{
1425
152
    qDebug() << "setPresence" << status;
218
    qDebug() << "setPresence" << status << statusMessage;
1426
153
    if (status == "available") {
219
    Tp::SimpleContactPresences presences;
1427
154
        mRequestedSelfPresence.type = Tp::ConnectionPresenceTypeAvailable;
220
    if (!mStatuses.contains(status) || !mStatuses[status].maySetOnSelf) {
1428
221
        error->set(TP_QT_ERROR_INVALID_ARGUMENT, "Status not supported or cannot be set");
1429
222
        return selfHandle();
1430
155
    }
223
    }
1431
224
1432
225
    Tp::SimpleStatusSpec spec = mStatuses[status];
1433
226
    mSelfPresence.status = status;
1434
227
    mSelfPresence.type = spec.type;
1435
228
    mSelfPresence.statusMessage = spec.canHaveMessage ? statusMessage : "";
1436
229
1437
230
    presences[selfHandle()] = mSelfPresence;
1438
231
    simplePresenceIface->setPresences(presences);
1439
156
    return selfHandle();
232
    return selfHandle();
1440
157
}
233
}
1441
158
234
1442
@@ -190,8 +266,9 @@
1443
190
266
1444
191
uint MockConnection::newHandle(const QString &identifier)
267
uint MockConnection::newHandle(const QString &identifier)
1445
192
{
268
{
1448
193
    mHandles[++mHandleCount] = identifier;
269
    static int handleCount = 0;
1449
194
    return mHandleCount;
270
    mHandles[++handleCount] = identifier;
1450
271
    return handleCount;
1451
195
}
272
}
1452
196
273
1453
197
QMap<QString, MockCallChannel *> MockConnection::callChannels()
274
QMap<QString, MockCallChannel *> MockConnection::callChannels()
1454
@@ -248,29 +325,44 @@
1455
248
}
325
}
1456
249
326
1457
250
Tp::BaseChannelPtr MockConnection::createTextChannel(uint targetHandleType,
327
Tp::BaseChannelPtr MockConnection::createTextChannel(uint targetHandleType,
1459
251
                                               uint targetHandle, Tp::DBusError *error)
328
                                                     uint targetHandle,
1460
329
                                                     const QVariantMap &hints,
1461
330
                                                     Tp::DBusError *error)
1462
252
{
331
{
1463
253
    Q_UNUSED(targetHandleType);
332
    Q_UNUSED(targetHandleType);
1464
254
    Q_UNUSED(error);
333
    Q_UNUSED(error);
1465
255
334
1473
256
    QString requestedId = mHandles.value(targetHandle);
335
    if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles")) &&
1474
257
336
            targetHandleType == Tp::HandleTypeNone && targetHandle == 0) {
1475
258
    if (mTextChannels.contains(requestedId)) {
337
1476
259
        return mTextChannels[requestedId]->baseChannel();
338
    }
1477
260
    }
339
1478
261
340
    QStringList recipients;
1479
262
    MockTextChannel *channel = new MockTextChannel(this, requestedId, targetHandle);
341
    bool flash;
1480
342
    if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles"))) {
1481
343
        recipients << inspectHandles(Tp::HandleTypeContact, qdbus_cast<Tp::UIntList>(hints[TP_QT_IFACE_CHANNEL_INTERFACE_CONFERENCE + QLatin1String(".InitialInviteeHandles")]), error);
1482
344
    } else {
1483
345
        recipients << mHandles.value(targetHandle);
1484
346
    }
1485
347
1486
348
    if (hints.contains(TP_QT_IFACE_CHANNEL_INTERFACE_SMS + QLatin1String(".Flash"))) {
1487
349
        flash = hints[TP_QT_IFACE_CHANNEL_INTERFACE_SMS + QLatin1String(".Flash")].toBool();
1488
350
    }
1489
351
1490
352
    // FIXME: test flash messages
1491
353
    MockTextChannel *channel = new MockTextChannel(this, recipients, targetHandle);
1492
263
    QObject::connect(channel, SIGNAL(messageRead(QString)), SLOT(onMessageRead(QString)));
354
    QObject::connect(channel, SIGNAL(messageRead(QString)), SLOT(onMessageRead(QString)));
1493
264
    QObject::connect(channel, SIGNAL(destroyed()), SLOT(onTextChannelClosed()));
355
    QObject::connect(channel, SIGNAL(destroyed()), SLOT(onTextChannelClosed()));
1494
265
    QObject::connect(channel, SIGNAL(messageSent(QString,QVariantMap)), SIGNAL(messageSent(QString,QVariantMap)));
356
    QObject::connect(channel, SIGNAL(messageSent(QString,QVariantMap)), SIGNAL(messageSent(QString,QVariantMap)));
1495
266
    qDebug() << channel;
357
    qDebug() << channel;
1497
267
    mTextChannels[requestedId] = channel;
358
    mTextChannels << channel;
1498
268
    return channel->baseChannel();
359
    return channel->baseChannel();
1499
269
}
360
}
1500
270
361
1501
271
void MockConnection::onMessageRead(const QString &id)
362
void MockConnection::onMessageRead(const QString &id)
1502
272
{
363
{
1504
273
    // FIXME: implement
364
    // FIXME: check what else to do
1505
365
    Q_EMIT messageRead(id);
1506
274
}
366
}
1507
275
367
1508
276
void MockConnection::onConferenceCallChannelClosed()
368
void MockConnection::onConferenceCallChannelClosed()
1509
@@ -355,7 +447,7 @@
1510
355
    }
447
    }
1511
356
448
1512
357
    if (channelType == TP_QT_IFACE_CHANNEL_TYPE_TEXT) {
449
    if (channelType == TP_QT_IFACE_CHANNEL_TYPE_TEXT) {
1514
358
        return createTextChannel(targetHandleType, targetHandle, error);
450
        return createTextChannel(targetHandleType, targetHandle, hints, error);
1515
359
    } else if (channelType == TP_QT_IFACE_CHANNEL_TYPE_CALL) {
451
    } else if (channelType == TP_QT_IFACE_CHANNEL_TYPE_CALL) {
1516
360
        return createCallChannel(targetHandleType, targetHandle, hints, error);
452
        return createCallChannel(targetHandleType, targetHandle, hints, error);
1517
361
    } else {
453
    } else {
1518
@@ -367,33 +459,36 @@
1519
367
459
1520
368
void MockConnection::placeIncomingMessage(const QString &message, const QVariantMap &info)
460
void MockConnection::placeIncomingMessage(const QString &message, const QVariantMap &info)
1521
369
{
461
{
1540
370
    const QString sender = info["Sender"].toString();
462
    QString sender = info["Sender"].toString();
1541
371
    // check if there is an open channel for this sender and use it
463
    QStringList recipients = info["Recipients"].toStringList();
1542
372
    Q_FOREACH(const QString &id, mTextChannels.keys()) {
464
1543
373
        if (id == sender) {
465
    MockTextChannel *channel = textChannelForRecipients(recipients);
1544
374
            mTextChannels[id]->messageReceived(message, info);
466
    if (!channel) {
1545
375
            return;
467
        // request the channel
1546
376
        }
468
        Tp::DBusError error;
1547
377
    }
469
        bool yours;
1548
378
470
        uint handle = newHandle(sender);
1549
379
    Tp::DBusError error;
471
        ensureChannel(TP_QT_IFACE_CHANNEL_TYPE_TEXT,Tp::HandleTypeContact, handle, yours, handle, false, QVariantMap(), &error);
1550
380
    bool yours;
472
        if(error.isValid()) {
1551
381
    uint handle = newHandle(sender);
473
            qWarning() << "Error creating channel for incoming message" << error.name() << error.message();
1552
382
    ensureChannel(TP_QT_IFACE_CHANNEL_TYPE_TEXT,Tp::HandleTypeContact, handle, yours, handle, false, QVariantMap(), &error);
474
            return;
1553
383
    if(error.isValid()) {
475
        }
1554
384
        qWarning() << "Error creating channel for incoming message" << error.name() << error.message();
476
1555
385
        return;
477
        channel = textChannelForRecipients(recipients);
1556
386
    }
478
        if (!channel) {
1557
387
    mTextChannels[sender]->messageReceived(message, info);
479
            return;
1558
480
        }
1559
481
    }
1560
482
1561
483
    channel->messageReceived(message, info);
1562
388
}
484
}
1563
389
485
1564
390
void MockConnection::onTextChannelClosed()
486
void MockConnection::onTextChannelClosed()
1565
391
{
487
{
1566
392
    MockTextChannel *channel = static_cast<MockTextChannel*>(sender());
488
    MockTextChannel *channel = static_cast<MockTextChannel*>(sender());
1567
393
    if (channel) {
489
    if (channel) {
1571
394
        QString key = mTextChannels.key(channel);
490
        qDebug() << "text channel closed for recipients " << channel->recipients();
1572
395
        qDebug() << "text channel closed for number " << key;
491
        mTextChannels.removeAll(channel);
1570
396
        mTextChannels.remove(key);
1573
397
    }
492
    }
1574
398
}
493
}
1575
399
494
1576
@@ -469,6 +564,76 @@
1577
469
    return channel->objectPath();
564
    return channel->objectPath();
1578
470
}
565
}
1579
471
566
1580
567
QStringList MockConnection::emergencyNumbers(Tp::DBusError *error)
1581
568
{
1582
569
    return mEmergencyNumbers;
1583
570
}
1584
571
1585
572
void MockConnection::setEmergencyNumbers(const QStringList &emergencyNumbers)
1586
573
{
1587
574
    mEmergencyNumbers = emergencyNumbers;
1588
575
    emergencyModeIface->setEmergencyNumbers(emergencyNumbers);
1589
576
}
1590
577
1591
578
bool MockConnection::voicemailIndicator(Tp::DBusError *error)
1592
579
{
1593
580
    return mVoicemailIndicator;
1594
581
}
1595
582
1596
583
void MockConnection::setVoicemailIndicator(bool visible)
1597
584
{
1598
585
    mVoicemailIndicator = visible;
1599
586
    voicemailIface->setVoicemailIndicator(visible);
1600
587
}
1601
588
1602
589
QString MockConnection::voicemailNumber(Tp::DBusError *error)
1603
590
{
1604
591
    return mVoicemailNumber;
1605
592
}
1606
593
1607
594
void MockConnection::setVoicemailNumber(const QString &number)
1608
595
{
1609
596
    mVoicemailNumber = number;
1610
597
    voicemailIface->setVoicemailNumber(mVoicemailNumber);
1611
598
}
1612
599
1613
600
uint MockConnection::voicemailCount(Tp::DBusError *error)
1614
601
{
1615
602
    return mVoicemailCount;
1616
603
}
1617
604
1618
605
void MockConnection::setVoicemailCount(int count)
1619
606
{
1620
607
    mVoicemailCount = count;
1621
608
    voicemailIface->setVoicemailCount(mVoicemailCount);
1622
609
}
1623
610
1624
611
void MockConnection::USSDInitiate(const QString &command, Tp::DBusError *error)
1625
612
{
1626
613
    // FIXME: implement
1627
614
}
1628
615
1629
616
void MockConnection::USSDRespond(const QString &reply, Tp::DBusError *error)
1630
617
{
1631
618
    // FIXME: implement
1632
619
}
1633
620
1634
621
void MockConnection::USSDCancel(Tp::DBusError *error)
1635
622
{
1636
623
    // FIXME: implement
1637
624
}
1638
625
1639
626
QString MockConnection::serial()
1640
627
{
1641
628
    return supplementaryServicesIface->serial();
1642
629
}
1643
630
1644
631
QString MockConnection::uniqueName() const
1645
632
{
1646
633
    static int count = 0;
1647
634
    return QString("connection%1%2").arg((quintptr) this, 0, 16).arg(count++, 0, 16);
1648
635
}
1649
636
1650
472
void MockConnection::hangupCall(const QString &callerId)
637
void MockConnection::hangupCall(const QString &callerId)
1651
473
{
638
{
1652
474
    if (!mCallChannels.contains(callerId)) {
639
    if (!mCallChannels.contains(callerId)) {
1653
475
640
1654
=== modified file 'tests/common/mock/connection.h'
1655
--- handler/tests/mock/connection.h	2014-03-20 21:03:26 +0000
1656
+++ tests/common/mock/connection.h	2015-03-30 20:55:55 +0000
1657
@@ -34,6 +34,9 @@
1658
34
#include "textchannel.h"
34
#include "textchannel.h"
1659
35
#include "callchannel.h"
35
#include "callchannel.h"
1660
36
#include "dbustypes.h"
36
#include "dbustypes.h"
1661
37
#include "emergencymodeiface.h"
1662
38
#include "ussdiface.h"
1663
39
#include "voicemailiface.h"
1664
37
40
1665
38
class MockTextChannel;
41
class MockTextChannel;
1666
39
class MockCallChannel;
42
class MockCallChannel;
1667
@@ -65,9 +68,16 @@
1668
65
    uint newHandle(const QString &identifier);
68
    uint newHandle(const QString &identifier);
1669
66
    QMap<QString, MockCallChannel*> callChannels();
69
    QMap<QString, MockCallChannel*> callChannels();
1670
67
70
1671
71
    // phone custom interfaces
1672
72
    BaseConnectionEmergencyModeInterfacePtr emergencyModeIface;
1673
73
    BaseConnectionVoicemailInterfacePtr voicemailIface;
1674
74
    BaseConnectionUSSDInterfacePtr supplementaryServicesIface;
1675
75
1676
68
    uint ensureHandle(const QString &id);
76
    uint ensureHandle(const QString &id);
1677
69
    Tp::BaseChannelPtr createTextChannel(uint targetHandleType,
77
    Tp::BaseChannelPtr createTextChannel(uint targetHandleType,
1679
70
                                         uint targetHandle, Tp::DBusError *error);
78
                                         uint targetHandle,
1680
79
                                         const QVariantMap &hints,
1681
80
                                         Tp::DBusError *error);
1682
71
    Tp::BaseChannelPtr createCallChannel(uint targetHandleType,
81
    Tp::BaseChannelPtr createCallChannel(uint targetHandleType,
1683
72
                                         uint targetHandle,
82
                                         uint targetHandle,
1684
73
                                         const QVariantMap &hints,
83
                                         const QVariantMap &hints,
1685
@@ -76,7 +86,27 @@
1686
76
    ~MockConnection();
86
    ~MockConnection();
1687
77
87
1688
78
    QString placeCall(const QVariantMap &properties);
88
    QString placeCall(const QVariantMap &properties);
1689
89
1690
90
    QStringList emergencyNumbers(Tp::DBusError *error);
1691
91
    void setEmergencyNumbers(const QStringList &emergencyNumbers);
1692
92
1693
93
    bool voicemailIndicator(Tp::DBusError *error);
1694
94
    void setVoicemailIndicator(bool visible);
1695
95
    QString voicemailNumber(Tp::DBusError *error);
1696
96
    void setVoicemailNumber(const QString &number);
1697
97
    uint voicemailCount(Tp::DBusError *error);
1698
98
    void setVoicemailCount(int count);
1699
99
    void USSDInitiate(const QString &command, Tp::DBusError *error);
1700
100
    void USSDRespond(const QString &reply, Tp::DBusError *error);
1701
101
    void USSDCancel(Tp::DBusError *error);
1702
102
    QString serial();
1703
103
1704
104
    // FIXME: there is a problem in telepathy-qt that connection object paths and services are not properly unregistered
1705
105
    // and thus if we gain the same memory address (and thus the same pointer) every time we reconnect, there might be some problems
1706
106
    QString uniqueName() const;
1707
107
1708
79
Q_SIGNALS:
108
Q_SIGNALS:
1709
109
    void messageRead(const QString &messageId);
1710
80
    void messageSent(const QString &message, const QVariantMap &info);
110
    void messageSent(const QString &message, const QVariantMap &info);
1711
81
    void callReceived(const QString &callerId);
111
    void callReceived(const QString &callerId);
1712
82
    void callEnded(const QString &callerId);
112
    void callEnded(const QString &callerId);
1713
@@ -102,20 +132,27 @@
1714
102
132
1715
103
private:
133
private:
1716
104
    void addMMSToService(const QString &path, const QVariantMap &properties, const QString &servicePath);
134
    void addMMSToService(const QString &path, const QVariantMap &properties, const QString &servicePath);
1717
135
1718
136
    MockTextChannel *textChannelForRecipients(const QStringList &recipients);
1719
137
1720
105
    QMap<uint, QString> mHandles;
138
    QMap<uint, QString> mHandles;
1721
139
    Tp::SimpleStatusSpecMap mStatuses;
1722
106
140
1724
107
    QMap<QString, MockTextChannel*> mTextChannels;
141
    QList<MockTextChannel*> mTextChannels;
1725
108
    QMap<QString, MockCallChannel*> mCallChannels;
142
    QMap<QString, MockCallChannel*> mCallChannels;
1726
109
    QMap<QString, QString> mInitialCallStatus;
143
    QMap<QString, QString> mInitialCallStatus;
1727
110
144
1728
111
    QStringList mModems;
145
    QStringList mModems;
1729
112
    uint mHandleCount;
1730
113
    Tp::SimplePresence mSelfPresence;
146
    Tp::SimplePresence mSelfPresence;
1731
114
    Tp::SimplePresence mRequestedSelfPresence;
1732
115
147
1733
116
    MockConnectionDBus *mDBus;
148
    MockConnectionDBus *mDBus;
1734
117
    QStringList mIncomingCalls;
149
    QStringList mIncomingCalls;
1735
118
    MockConferenceCallChannel *mConferenceCall;
150
    MockConferenceCallChannel *mConferenceCall;
1736
151
1737
152
    QStringList mEmergencyNumbers;
1738
153
    int mVoicemailCount;
1739
154
    bool mVoicemailIndicator;
1740
155
    QString mVoicemailNumber;
1741
119
};
156
};
1742
120
157
1743
121
#endif
158
#endif
1744
122
159
1745
=== added file 'tests/common/mock/emergencymodeiface.cpp'
1746
--- tests/common/mock/emergencymodeiface.cpp	1970-01-01 00:00:00 +0000
1747
+++ tests/common/mock/emergencymodeiface.cpp	2015-03-30 20:55:55 +0000
1748
@@ -0,0 +1,133 @@
1749
1
/**
1750
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
1751
3
 *
1752
4
 * This program is free software: you can redistribute it and/or modify it under
1753
5
 * the terms of the GNU General Public License version 3, as published by
1754
6
 * the Free Software Foundation.
1755
7
 *
1756
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
1757
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
1758
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1759
11
 * General Public License for more details.
1760
12
 *
1761
13
 * You should have received a copy of the GNU General Public License
1762
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1763
15
 *
1764
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
1765
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
1766
18
 */
1767
19
1768
20
#include <QDebug>
1769
21
1770
22
#include <TelepathyQt/Constants>
1771
23
#include <TelepathyQt/DBusObject>
1772
24
1773
25
#include "emergencymodeiface.h"
1774
26
1775
27
BaseConnectionEmergencyModeInterface::Adaptee::Adaptee(BaseConnectionEmergencyModeInterface *interface)
1776
28
    : QObject(interface),
1777
29
      mInterface(interface)
1778
30
{
1779
31
}
1780
32
1781
33
1782
34
struct TP_QT_NO_EXPORT BaseConnectionEmergencyModeInterface::Private {
1783
35
    Private(BaseConnectionEmergencyModeInterface *parent)
1784
36
        : adaptee(new BaseConnectionEmergencyModeInterface::Adaptee(parent)) {
1785
37
    }
1786
38
    EmergencyNumbersCallback emergencyNumbersCB;
1787
39
    BaseConnectionEmergencyModeInterface::Adaptee *adaptee;
1788
40
    QString fakeEmergencyNumber;
1789
41
};
1790
42
1791
43
BaseConnectionEmergencyModeInterface::Adaptee::~Adaptee()
1792
44
{
1793
45
}
1794
46
1795
47
void BaseConnectionEmergencyModeInterface::Adaptee::emergencyNumbers(const ConnectionInterfaceEmergencyModeAdaptor::EmergencyNumbersContextPtr &context)
1796
48
{
1797
49
    if (!mInterface->mPriv->emergencyNumbersCB.isValid()) {
1798
50
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
1799
51
        return;
1800
52
    }
1801
53
    Tp::DBusError error;
1802
54
    QStringList numbers = mInterface->mPriv->emergencyNumbersCB(&error);
1803
55
    if (error.isValid()) {
1804
56
        context->setFinishedWithError(error.name(), error.message());
1805
57
        return;
1806
58
    }
1807
59
    if (mInterface->mPriv->fakeEmergencyNumber.isEmpty()) {
1808
60
        context->setFinished(numbers);
1809
61
    } else {
1810
62
        context->setFinished(QStringList() << numbers << mInterface->mPriv->fakeEmergencyNumber);
1811
63
    }
1812
64
}
1813
65
1814
66
BaseConnectionEmergencyModeInterface::BaseConnectionEmergencyModeInterface()
1815
67
    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_EMERGENCYMODE),
1816
68
      mPriv(new Private(this))
1817
69
{
1818
70
}
1819
71
1820
72
BaseConnectionEmergencyModeInterface::~BaseConnectionEmergencyModeInterface()
1821
73
{
1822
74
    delete mPriv;
1823
75
}
1824
76
1825
77
void BaseConnectionEmergencyModeInterface::setEmergencyNumbersCallback(const EmergencyNumbersCallback &cb)
1826
78
{
1827
79
    mPriv->emergencyNumbersCB = cb;
1828
80
}
1829
81
1830
82
void BaseConnectionEmergencyModeInterface::setEmergencyNumbers(const QStringList &numbers)
1831
83
{
1832
84
    QStringList finalEmergencyList(numbers);
1833
85
1834
86
    if (!mPriv->fakeEmergencyNumber.isEmpty()) {
1835
87
        finalEmergencyList << mPriv->fakeEmergencyNumber;
1836
88
    }
1837
89
1838
90
    Q_EMIT mPriv->adaptee->emergencyNumbersChanged(finalEmergencyList);
1839
91
}
1840
92
1841
93
void BaseConnectionEmergencyModeInterface::setFakeEmergencyNumber(const QString &fakeEmergencyNumber)
1842
94
{
1843
95
    mPriv->fakeEmergencyNumber = fakeEmergencyNumber;
1844
96
}
1845
97
1846
98
QVariantMap BaseConnectionEmergencyModeInterface::immutableProperties() const
1847
99
{
1848
100
    QVariantMap map;
1849
101
    return map;
1850
102
}
1851
103
1852
104
void BaseConnectionEmergencyModeInterface::createAdaptor()
1853
105
{
1854
106
    (void) new ConnectionInterfaceEmergencyModeAdaptor(dbusObject()->dbusConnection(),
1855
107
            mPriv->adaptee, dbusObject());
1856
108
}
1857
109
1858
110
1859
111
ConnectionInterfaceEmergencyModeAdaptor::ConnectionInterfaceEmergencyModeAdaptor(const QDBusConnection& bus, QObject* adaptee, QObject* parent)
1860
112
    : Tp::AbstractAdaptor(bus, adaptee, parent)
1861
113
{
1862
114
    connect(adaptee, SIGNAL(emergencyNumbersChanged(QStringList)), SIGNAL(EmergencyNumbersChanged(QStringList)));
1863
115
}
1864
116
1865
117
ConnectionInterfaceEmergencyModeAdaptor::~ConnectionInterfaceEmergencyModeAdaptor()
1866
118
{
1867
119
}
1868
120
1869
121
QStringList ConnectionInterfaceEmergencyModeAdaptor::EmergencyNumbers(const QDBusMessage& dbusMessage)
1870
122
{
1871
123
    if (!adaptee()->metaObject()->indexOfMethod("emergencyNumbers(ConnectionInterfaceEmergencyModeAdaptor::EmergencyNumbersContextPtr)") == -1) {
1872
124
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
1873
125
        return QStringList();
1874
126
    }
1875
127
1876
128
    EmergencyNumbersContextPtr ctx = EmergencyNumbersContextPtr(
1877
129
            new Tp::MethodInvocationContext< QStringList >(dbusConnection(), dbusMessage));
1878
130
    QMetaObject::invokeMethod(adaptee(), "emergencyNumbers",
1879
131
        Q_ARG(ConnectionInterfaceEmergencyModeAdaptor::EmergencyNumbersContextPtr, ctx));
1880
132
    return QStringList();
1881
133
}
1882
0
134
1883
=== added file 'tests/common/mock/emergencymodeiface.h'
1884
--- tests/common/mock/emergencymodeiface.h	1970-01-01 00:00:00 +0000
1885
+++ tests/common/mock/emergencymodeiface.h	2015-03-30 20:55:55 +0000
1886
@@ -0,0 +1,121 @@
1887
1
/**
1888
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
1889
3
 *
1890
4
 * This program is free software: you can redistribute it and/or modify it under
1891
5
 * the terms of the GNU General Public License version 3, as published by
1892
6
 * the Free Software Foundation.
1893
7
 *
1894
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
1895
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
1896
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1897
11
 * General Public License for more details.
1898
12
 *
1899
13
 * You should have received a copy of the GNU General Public License
1900
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1901
15
 *
1902
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
1903
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
1904
18
 */
1905
19
1906
20
#ifndef OFONOEMERGENCYMODEIFACE_H
1907
21
#define OFONOEMERGENCYMODEIFACE_H
1908
22
1909
23
// telepathy-qt
1910
24
#include <TelepathyQt/Constants>
1911
25
#include <TelepathyQt/BaseConnection>
1912
26
#include <TelepathyQt/AbstractAdaptor>
1913
27
#include <TelepathyQt/DBusError>
1914
28
#include <TelepathyQt/Callbacks>
1915
29
1916
30
class BaseConnectionEmergencyModeInterface;
1917
31
1918
32
typedef Tp::SharedPtr<BaseConnectionEmergencyModeInterface> BaseConnectionEmergencyModeInterfacePtr;
1919
33
1920
34
#define TP_QT_IFACE_CONNECTION_EMERGENCYMODE "com.canonical.Telephony.EmergencyMode"
1921
35
1922
36
class TP_QT_EXPORT BaseConnectionEmergencyModeInterface : public Tp::AbstractConnectionInterface
1923
37
{
1924
38
    Q_OBJECT
1925
39
    Q_DISABLE_COPY(BaseConnectionEmergencyModeInterface)
1926
40
1927
41
public:
1928
42
    static BaseConnectionEmergencyModeInterfacePtr create() {
1929
43
        return BaseConnectionEmergencyModeInterfacePtr(new BaseConnectionEmergencyModeInterface());
1930
44
    }
1931
45
    template<typename BaseConnectionEmergencyModeInterfaceSubclass>
1932
46
    static Tp::SharedPtr<BaseConnectionEmergencyModeInterfaceSubclass> create() {
1933
47
        return Tp::SharedPtr<BaseConnectionEmergencyModeInterfaceSubclass>(
1934
48
                   new BaseConnectionEmergencyModeInterfaceSubclass());
1935
49
    }
1936
50
    QVariantMap immutableProperties() const;
1937
51
    virtual ~BaseConnectionEmergencyModeInterface();
1938
52
1939
53
    typedef Tp::Callback1<QStringList, Tp::DBusError*> EmergencyNumbersCallback;
1940
54
    void setEmergencyNumbersCallback(const EmergencyNumbersCallback &cb);
1941
55
    void setFakeEmergencyNumber(const QString &fakeEmergencyNumber);
1942
56
1943
57
public Q_SLOTS:
1944
58
    void setEmergencyNumbers(const QStringList &numbers);
1945
59
1946
60
protected:
1947
61
    BaseConnectionEmergencyModeInterface();
1948
62
1949
63
private:
1950
64
    void createAdaptor();
1951
65
1952
66
    class Adaptee;
1953
67
    friend class Adaptee;
1954
68
    struct Private;
1955
69
    friend struct Private;
1956
70
    Private *mPriv;
1957
71
};
1958
72
1959
73
1960
74
class TP_QT_EXPORT ConnectionInterfaceEmergencyModeAdaptor : public Tp::AbstractAdaptor
1961
75
{
1962
76
    Q_OBJECT
1963
77
    Q_CLASSINFO("D-Bus Interface", TP_QT_IFACE_CONNECTION_EMERGENCYMODE)
1964
78
    Q_CLASSINFO("D-Bus Introspection", ""
1965
79
"  <interface name=\"com.canonical.Telephony.EmergencyMode\">\n"
1966
80
"    <method name=\"EmergencyNumbers\">\n"
1967
81
"      <arg direction=\"out\" type=\"as\" name=\"emergencyNumbers\"/>\n"
1968
82
"    </method>\n"
1969
83
"    <signal name=\"EmergencyNumbersChanged\">\n"
1970
84
"      <arg type=\"as\" name=\"numbers\"/>\n"
1971
85
"    </signal>\n"
1972
86
"  </interface>\n"
1973
87
"")
1974
88
1975
89
public:
1976
90
    ConnectionInterfaceEmergencyModeAdaptor(const QDBusConnection& dbusConnection, QObject* adaptee, QObject* parent);
1977
91
    virtual ~ConnectionInterfaceEmergencyModeAdaptor();
1978
92
1979
93
    typedef Tp::MethodInvocationContextPtr< QStringList > EmergencyNumbersContextPtr;
1980
94
1981
95
public Q_SLOTS: // METHODS
1982
96
    QStringList EmergencyNumbers(const QDBusMessage& dbusMessage);
1983
97
1984
98
Q_SIGNALS: // SIGNALS
1985
99
    void EmergencyNumbersChanged(const QStringList &numbers);
1986
100
};
1987
101
1988
102
1989
103
class TP_QT_NO_EXPORT BaseConnectionEmergencyModeInterface::Adaptee : public QObject
1990
104
{
1991
105
    Q_OBJECT
1992
106
1993
107
public:
1994
108
    Adaptee(BaseConnectionEmergencyModeInterface *interface);
1995
109
    ~Adaptee();
1996
110
1997
111
private Q_SLOTS:
1998
112
    void emergencyNumbers(const ConnectionInterfaceEmergencyModeAdaptor::EmergencyNumbersContextPtr &context);
1999
113
2000
114
Q_SIGNALS:
2001
115
    void emergencyNumbersChanged(const QStringList &numbers);
2002
116
2003
117
public:
2004
118
    BaseConnectionEmergencyModeInterface *mInterface;
2005
119
};
2006
120
2007
121
#endif
2008
0
122
2009
=== modified file 'tests/common/mock/main.cpp'
2010
--- handler/tests/mock/main.cpp	2014-01-07 19:53:45 +0000
2011
+++ tests/common/mock/main.cpp	2015-03-30 20:55:55 +0000
2012
@@ -31,10 +31,17 @@
2013
31
    Tp::enableDebug(true);
31
    Tp::enableDebug(true);
2014
32
    Tp::enableWarnings(true);
32
    Tp::enableWarnings(true);
2015
33
33
2016
34
    // create a standard protocol
2017
34
    Tp::BaseProtocolPtr proto = Tp::BaseProtocol::create<Protocol>(
35
    Tp::BaseProtocolPtr proto = Tp::BaseProtocol::create<Protocol>(
2018
35
            QDBusConnection::sessionBus(), QLatin1String("mock"));
36
            QDBusConnection::sessionBus(), QLatin1String("mock"));
2019
37
2020
38
    // create a phone protocol
2021
39
    Tp::BaseProtocolPtr phoneProto = Tp::BaseProtocol::create<Protocol>(
2022
40
            QDBusConnection::sessionBus(), QLatin1String("ofono"));
2023
41
2024
36
    Tp::BaseConnectionManagerPtr cm = Tp::BaseConnectionManager::create(
42
    Tp::BaseConnectionManagerPtr cm = Tp::BaseConnectionManager::create(
2025
37
            QDBusConnection::sessionBus(), QLatin1String("mock"));
43
            QDBusConnection::sessionBus(), QLatin1String("mock"));
2026
44
    cm->addProtocol(phoneProto);
2027
38
    cm->addProtocol(proto);
45
    cm->addProtocol(proto);
2028
39
    cm->registerObject();
46
    cm->registerObject();
2029
40
47
2030
41
48
2031
=== modified file 'tests/common/mock/mockconnectiondbus.cpp'
2032
--- handler/tests/mock/mockconnectiondbus.cpp	2014-03-20 21:03:26 +0000
2033
+++ tests/common/mock/mockconnectiondbus.cpp	2015-03-30 20:55:55 +0000
2034
@@ -28,7 +28,9 @@
2035
28
MockConnectionDBus::MockConnectionDBus(MockConnection *parent) :
28
MockConnectionDBus::MockConnectionDBus(MockConnection *parent) :
2036
29
    QObject(parent), mAdaptor(0), mConnection(parent)
29
    QObject(parent), mAdaptor(0), mConnection(parent)
2037
30
{
30
{
2039
31
31
    connect(mConnection,
2040
32
            SIGNAL(messageRead(QString)),
2041
33
            SIGNAL(MessageRead(QString)));
2042
32
    connect(mConnection,
34
    connect(mConnection,
2043
33
            SIGNAL(messageSent(QString,QVariantMap)),
35
            SIGNAL(messageSent(QString,QVariantMap)),
2044
34
            SIGNAL(MessageSent(QString,QVariantMap)));
36
            SIGNAL(MessageSent(QString,QVariantMap)));
2045
@@ -50,10 +52,22 @@
2046
50
    connect(mConnection,
52
    connect(mConnection,
2047
51
            SIGNAL(channelSplitted(QString)),
53
            SIGNAL(channelSplitted(QString)),
2048
52
            SIGNAL(ChannelSplitted(QString)));
54
            SIGNAL(ChannelSplitted(QString)));
2049
55
    connect(mConnection,
2050
56
            SIGNAL(disconnected()),
2051
57
            SIGNAL(Disconnected()));
2052
58
    connect(mConnection,
2053
59
            SIGNAL(destroyed()),
2054
60
            SIGNAL(Destroyed()));
2055
53
    qDBusRegisterMetaType<QList<QVariantMap> >();
61
    qDBusRegisterMetaType<QList<QVariantMap> >();
2056
62
    mObjectPath = "/com/canonical/MockConnection/" + mConnection->protocolName();
2057
54
    connectToBus();
63
    connectToBus();
2058
55
}
64
}
2059
56
65
2060
66
MockConnectionDBus::~MockConnectionDBus()
2061
67
{
2062
68
    QDBusConnection::sessionBus().unregisterObject(mObjectPath, QDBusConnection::UnregisterTree);
2063
69
}
2064
70
2065
57
bool MockConnectionDBus::connectToBus()
71
bool MockConnectionDBus::connectToBus()
2066
58
{
72
{
2067
59
    bool ok = QDBusConnection::sessionBus().registerService("com.canonical.MockConnection");
73
    bool ok = QDBusConnection::sessionBus().registerService("com.canonical.MockConnection");
2068
@@ -65,7 +79,7 @@
2069
65
        mAdaptor = new MockConnectionAdaptor(this);
79
        mAdaptor = new MockConnectionAdaptor(this);
2070
66
    }
80
    }
2071
67
81
2073
68
    return QDBusConnection::sessionBus().registerObject("/com/canonical/MockConnection", this);
82
    return QDBusConnection::sessionBus().registerObject(mObjectPath, this);
2074
69
}
83
}
2075
70
84
2076
71
void MockConnectionDBus::PlaceIncomingMessage(const QString &message, const QVariantMap &properties)
85
void MockConnectionDBus::PlaceIncomingMessage(const QString &message, const QVariantMap &properties)
2077
@@ -87,3 +101,39 @@
2078
87
{
101
{
2079
88
    mConnection->setCallState(phoneNumber, state);
102
    mConnection->setCallState(phoneNumber, state);
2080
89
}
103
}
2081
104
2082
105
void MockConnectionDBus::SetOnline(bool online)
2083
106
{
2084
107
    mConnection->setOnline(online);
2085
108
}
2086
109
2087
110
void MockConnectionDBus::SetPresence(const QString &status, const QString &statusMessage)
2088
111
{
2089
112
    Tp::DBusError error;
2090
113
    mConnection->setPresence(status, statusMessage, &error);
2091
114
}
2092
115
2093
116
void MockConnectionDBus::SetVoicemailIndicator(bool active)
2094
117
{
2095
118
    mConnection->setVoicemailIndicator(active);
2096
119
}
2097
120
2098
121
void MockConnectionDBus::SetVoicemailNumber(const QString &number)
2099
122
{
2100
123
    mConnection->setVoicemailNumber(number);
2101
124
}
2102
125
2103
126
void MockConnectionDBus::SetVoicemailCount(int count)
2104
127
{
2105
128
    mConnection->setVoicemailCount(count);
2106
129
}
2107
130
2108
131
void MockConnectionDBus::SetEmergencyNumbers(const QStringList &numbers)
2109
132
{
2110
133
    mConnection->setEmergencyNumbers(numbers);
2111
134
}
2112
135
2113
136
QString MockConnectionDBus::Serial()
2114
137
{
2115
138
    return mConnection->serial();
2116
139
}
2117
90
140
2118
=== modified file 'tests/common/mock/mockconnectiondbus.h'
2119
--- handler/tests/mock/mockconnectiondbus.h	2014-03-20 21:03:26 +0000
2120
+++ tests/common/mock/mockconnectiondbus.h	2015-03-30 20:55:55 +0000
2121
@@ -30,15 +30,30 @@
2122
30
    Q_OBJECT
30
    Q_OBJECT
2123
31
public:
31
public:
2124
32
    explicit MockConnectionDBus(MockConnection *parent);
32
    explicit MockConnectionDBus(MockConnection *parent);
2125
33
    ~MockConnectionDBus();
2126
33
34
2127
34
    bool connectToBus();
35
    bool connectToBus();
2128
35
    void PlaceIncomingMessage(const QString &message, const QVariantMap &properties);
36
    void PlaceIncomingMessage(const QString &message, const QVariantMap &properties);
2129
36
    QString PlaceCall(const QVariantMap &properties);
37
    QString PlaceCall(const QVariantMap &properties);
2130
37
    void HangupCall(const QString &callerId);
38
    void HangupCall(const QString &callerId);
2131
38
    void SetCallState(const QString &phoneNumber, const QString &state);
39
    void SetCallState(const QString &phoneNumber, const QString &state);
2132
40
    void SetOnline(bool online);
2133
41
    void SetPresence(const QString &status, const QString &statusMessage);
2134
42
2135
43
    // voicemail stuff
2136
44
    void SetVoicemailIndicator(bool active);
2137
45
    void SetVoicemailNumber(const QString &number);
2138
46
    void SetVoicemailCount(int count);
2139
47
2140
48
    // emergency numbers stuff
2141
49
    void SetEmergencyNumbers(const QStringList &numbers);
2142
50
2143
51
    // USSD stuff
2144
52
    QString Serial();
2145
39
53
2146
40
Q_SIGNALS:
54
Q_SIGNALS:
2147
41
    // signals that will be relayed into the bus
55
    // signals that will be relayed into the bus
2148
56
    void MessageRead(const QString &messageId);
2149
42
    void MessageSent(const QString &mesasge, const QVariantMap &properties);
57
    void MessageSent(const QString &mesasge, const QVariantMap &properties);
2150
43
    void CallReceived(const QString &callerId);
58
    void CallReceived(const QString &callerId);
2151
44
    void CallEnded(const QString &callerId);
59
    void CallEnded(const QString &callerId);
2152
@@ -47,9 +62,13 @@
2153
47
    void ChannelMerged(const QString &objectPath);
62
    void ChannelMerged(const QString &objectPath);
2154
48
    void ChannelSplitted(const QString &objectPath);
63
    void ChannelSplitted(const QString &objectPath);
2155
49
64
2156
65
    void Disconnected();
2157
66
    void Destroyed();
2158
67
2159
50
private:
68
private:
2160
51
    MockConnectionAdaptor *mAdaptor;
69
    MockConnectionAdaptor *mAdaptor;
2161
52
    MockConnection *mConnection;
70
    MockConnection *mConnection;
2162
71
    QString mObjectPath;
2163
53
};
72
};
2164
54
73
2165
55
#endif // MOCKCONNECTIONDBUS_H
74
#endif // MOCKCONNECTIONDBUS_H
2166
56
75
2167
=== modified file 'tests/common/mock/protocol.cpp'
2168
--- handler/tests/mock/protocol.cpp	2014-01-07 19:53:45 +0000
2169
+++ tests/common/mock/protocol.cpp	2015-03-30 20:55:55 +0000
2170
@@ -30,6 +30,19 @@
2171
30
                                 Tp::RequestableChannelClassSpec::audioCall());
30
                                 Tp::RequestableChannelClassSpec::audioCall());
2172
31
31
2173
32
    setCreateConnectionCallback(memFun(this, &Protocol::createConnection));
32
    setCreateConnectionCallback(memFun(this, &Protocol::createConnection));
2174
33
2175
34
    Tp::ProtocolParameterList parameters;
2176
35
    Tp::ProtocolParameter parameter("modem-objpath", "s", 0);
2177
36
    parameters << parameter;
2178
37
    setParameters(parameters);
2179
38
2180
39
    addressingIface = Tp::BaseProtocolAddressingInterface::create();
2181
40
    if (name == "ofono") {
2182
41
        addressingIface->setAddressableVCardFields(QStringList() << "tel");
2183
42
    } else {
2184
43
        addressingIface->setAddressableVCardFields(QStringList() << "x-mock-im" << "x-sip");
2185
44
    }
2186
45
    plugInterface(addressingIface);
2187
33
}
46
}
2188
34
47
2189
35
Tp::BaseConnectionPtr Protocol::createConnection(const QVariantMap &parameters, Tp::DBusError *error) {
48
Tp::BaseConnectionPtr Protocol::createConnection(const QVariantMap &parameters, Tp::DBusError *error) {
2190
36
49
2191
=== modified file 'tests/common/mock/protocol.h'
2192
--- handler/tests/mock/protocol.h	2014-01-07 19:53:45 +0000
2193
+++ tests/common/mock/protocol.h	2015-03-30 20:55:55 +0000
2194
@@ -31,6 +31,7 @@
2195
31
31
2196
32
public:
32
public:
2197
33
    Protocol(const QDBusConnection &dbusConnection, const QString &name);
33
    Protocol(const QDBusConnection &dbusConnection, const QString &name);
2198
34
    Tp::BaseProtocolAddressingInterfacePtr addressingIface;
2199
34
35
2200
35
private:
36
private:
2201
36
    Tp::BaseConnectionPtr createConnection(const QVariantMap &parameters, Tp::DBusError *error);
37
    Tp::BaseConnectionPtr createConnection(const QVariantMap &parameters, Tp::DBusError *error);
2202
37
38
2203
=== modified file 'tests/common/mock/speakeriface.h'
2204
--- handler/tests/mock/speakeriface.h	2014-03-13 17:11:09 +0000
2205
+++ tests/common/mock/speakeriface.h	2015-03-30 20:55:55 +0000
2206
@@ -1,19 +1,20 @@
2207
1
/**
1
/**
2209
2
 * Copyright (C) 2013 Canonical, Ltd.
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
2210
3
 *
3
 *
2211
4
 * This program is free software: you can redistribute it and/or modify it under
4
 * This program is free software: you can redistribute it and/or modify it under
2213
5
 * the terms of the GNU Lesser General Public License version 3, as published by
5
 * the terms of the GNU General Public License version 3, as published by
2214
6
 * the Free Software Foundation.
6
 * the Free Software Foundation.
2215
7
 *
7
 *
2216
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
2217
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
2218
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2220
11
 * Lesser General Public License for more details.
11
 * General Public License for more details.
2221
12
 *
12
 *
2223
13
 * You should have received a copy of the GNU Lesser General Public License
13
 * You should have received a copy of the GNU General Public License
2224
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2225
15
 *
15
 *
2226
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
2227
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
2228
17
 */
18
 */
2229
18
19
2230
19
#ifndef OFONOSPEAKERIFACE_H
20
#ifndef OFONOSPEAKERIFACE_H
2231
20
21
2232
=== modified file 'tests/common/mock/textchannel.cpp'
2233
--- handler/tests/mock/textchannel.cpp	2014-01-07 19:53:45 +0000
2234
+++ tests/common/mock/textchannel.cpp	2015-03-30 20:55:55 +0000
2235
@@ -36,20 +36,24 @@
2236
36
    return argument;
36
    return argument;
2237
37
}
37
}
2238
38
38
2240
39
MockTextChannel::MockTextChannel(MockConnection *conn, QString phoneNumber, uint targetHandle, QObject *parent):
39
MockTextChannel::MockTextChannel(MockConnection *conn, QStringList recipients, uint targetHandle, QObject *parent):
2241
40
    QObject(parent),
40
    QObject(parent),
2242
41
    mConnection(conn),
41
    mConnection(conn),
2244
42
    mPhoneNumber(phoneNumber),
42
    mRecipients(recipients),
2245
43
    mTargetHandle(targetHandle),
43
    mTargetHandle(targetHandle),
2246
44
    mMessageCounter(1)
44
    mMessageCounter(1)
2247
45
{
45
{
2248
46
    qDBusRegisterMetaType<AttachmentStruct>();
46
    qDBusRegisterMetaType<AttachmentStruct>();
2249
47
    qDBusRegisterMetaType<AttachmentList>();
47
    qDBusRegisterMetaType<AttachmentList>();
2250
48
48
2251
49
    Tp::HandleType type = recipients.count() > 1 ? Tp::HandleTypeNone : Tp::HandleTypeContact;
2252
50
2253
51
2254
49
    Tp::BaseChannelPtr baseChannel = Tp::BaseChannel::create(mConnection,
52
    Tp::BaseChannelPtr baseChannel = Tp::BaseChannel::create(mConnection,
2255
50
                                                             TP_QT_IFACE_CHANNEL_TYPE_TEXT,
53
                                                             TP_QT_IFACE_CHANNEL_TYPE_TEXT,
2256
51
                                                             targetHandle,
54
                                                             targetHandle,
2258
52
                                                             Tp::HandleTypeContact);
55
                                                             type);
2259
56
    mBaseChannel = baseChannel;
2260
53
    Tp::BaseChannelTextTypePtr textType = Tp::BaseChannelTextType::create(baseChannel.data());
57
    Tp::BaseChannelTextTypePtr textType = Tp::BaseChannelTextType::create(baseChannel.data());
2261
54
    baseChannel->plugInterface(Tp::AbstractChannelInterfacePtr::dynamicCast(textType));
58
    baseChannel->plugInterface(Tp::AbstractChannelInterfacePtr::dynamicCast(textType));
2262
55
59
2263
@@ -67,9 +71,15 @@
2264
67
                                                          deliveryReportingSupport);
71
                                                          deliveryReportingSupport);
2265
68
72
2266
69
    mMessagesIface->setSendMessageCallback(Tp::memFun(this,&MockTextChannel::sendMessage));
73
    mMessagesIface->setSendMessageCallback(Tp::memFun(this,&MockTextChannel::sendMessage));
2267
70
2268
71
    baseChannel->plugInterface(Tp::AbstractChannelInterfacePtr::dynamicCast(mMessagesIface));
74
    baseChannel->plugInterface(Tp::AbstractChannelInterfacePtr::dynamicCast(mMessagesIface));
2270
72
    mBaseChannel = baseChannel;
75
2271
76
    // group stuff
2272
77
    mGroupIface = Tp::BaseChannelGroupInterface::create(Tp::ChannelGroupFlagCanAdd, conn->selfHandle());
2273
78
    mGroupIface->setAddMembersCallback(Tp::memFun(this,&MockTextChannel::onAddMembers));
2274
79
    mGroupIface->setRemoveMembersCallback(Tp::memFun(this,&MockTextChannel::onRemoveMembers));
2275
80
    baseChannel->plugInterface(Tp::AbstractChannelInterfacePtr::dynamicCast(mGroupIface));
2276
81
    addMembers(recipients);
2277
82
2278
73
    mTextChannel = Tp::BaseChannelTextTypePtr::dynamicCast(mBaseChannel->interface(TP_QT_IFACE_CHANNEL_TYPE_TEXT));
83
    mTextChannel = Tp::BaseChannelTextTypePtr::dynamicCast(mBaseChannel->interface(TP_QT_IFACE_CHANNEL_TYPE_TEXT));
2279
74
    mTextChannel->setMessageAcknowledgedCallback(Tp::memFun(this,&MockTextChannel::messageAcknowledged));
84
    mTextChannel->setMessageAcknowledgedCallback(Tp::memFun(this,&MockTextChannel::messageAcknowledged));
2280
75
    QObject::connect(mBaseChannel.data(), SIGNAL(closed()), this, SLOT(deleteLater()));
85
    QObject::connect(mBaseChannel.data(), SIGNAL(closed()), this, SLOT(deleteLater()));
2281
@@ -101,11 +111,20 @@
2282
101
    QString messageText = body["content"].variant().toString();
111
    QString messageText = body["content"].variant().toString();
2283
102
    QVariantMap properties;
112
    QVariantMap properties;
2284
103
    properties["SentTime"] = QDateTime::currentDateTime().toString(Qt::ISODate);
113
    properties["SentTime"] = QDateTime::currentDateTime().toString(Qt::ISODate);
2286
104
    properties["Recipients"] = QStringList() << mPhoneNumber;
114
    properties["Recipients"] = mRecipients;
2287
105
    properties["Id"] = id;
115
    properties["Id"] = id;
2288
106
116
2289
107
    Q_EMIT messageSent(messageText, properties);
117
    Q_EMIT messageSent(messageText, properties);
2290
108
118
2291
119
    QTimer *deliveryReportTimer = new QTimer(this);
2292
120
    deliveryReportTimer->setSingleShot(true);
2293
121
    deliveryReportTimer->setInterval(100);
2294
122
    connect(deliveryReportTimer, &QTimer::timeout, [id, deliveryReportTimer, this] {
2295
123
        this->placeDeliveryReport(id, "sent");
2296
124
        deliveryReportTimer->deleteLater();
2297
125
    });
2298
126
    deliveryReportTimer->start();
2299
127
2300
109
    return id;
128
    return id;
2301
110
}
129
}
2302
111
130
2303
@@ -125,7 +144,8 @@
2304
125
    Tp::MessagePartList partList;
144
    Tp::MessagePartList partList;
2305
126
    Tp::MessagePart header;
145
    Tp::MessagePart header;
2306
127
    header["message-sender"] = QDBusVariant(mTargetHandle);
146
    header["message-sender"] = QDBusVariant(mTargetHandle);
2308
128
    header["message-sender-id"] = QDBusVariant(mPhoneNumber);
147
    // FIXME: fix it
2309
148
    header["message-sender-id"] = QDBusVariant(mRecipients.first());
2310
129
    header["message-type"] = QDBusVariant(Tp::ChannelTextMessageTypeDeliveryReport);
149
    header["message-type"] = QDBusVariant(Tp::ChannelTextMessageTypeDeliveryReport);
2311
130
    header["delivery-status"] = QDBusVariant(delivery_status);
150
    header["delivery-status"] = QDBusVariant(delivery_status);
2312
131
    header["delivery-token"] = QDBusVariant(messageId);
151
    header["delivery-token"] = QDBusVariant(messageId);
2313
@@ -145,7 +165,7 @@
2314
145
    header["message-token"] = QDBusVariant(info["SentTime"].toString() +"-" + QString::number(mMessageCounter++));
165
    header["message-token"] = QDBusVariant(info["SentTime"].toString() +"-" + QString::number(mMessageCounter++));
2315
146
    header["message-received"] = QDBusVariant(QDateTime::fromString(info["SentTime"].toString(), Qt::ISODate).toTime_t());
166
    header["message-received"] = QDBusVariant(QDateTime::fromString(info["SentTime"].toString(), Qt::ISODate).toTime_t());
2316
147
    header["message-sender"] = QDBusVariant(mTargetHandle);
167
    header["message-sender"] = QDBusVariant(mTargetHandle);
2318
148
    header["message-sender-id"] = QDBusVariant(mPhoneNumber);
168
    header["message-sender-id"] = QDBusVariant(mRecipients.first());
2319
149
    header["message-type"] = QDBusVariant(Tp::ChannelTextMessageTypeNormal);
169
    header["message-type"] = QDBusVariant(Tp::ChannelTextMessageTypeNormal);
2320
150
    partList << header << body;
170
    partList << header << body;
2321
151
171
2322
@@ -198,3 +218,45 @@
2323
198
218
2324
199
    mTextChannel->addReceivedMessage(message);
219
    mTextChannel->addReceivedMessage(message);
2325
200
}
220
}
2326
221
2327
222
void MockTextChannel::addMembers(QStringList recipients)
2328
223
{
2329
224
    Tp::UIntList handles;
2330
225
    Q_FOREACH(const QString &recipient, recipients) {
2331
226
        uint handle = mConnection->ensureHandle(recipient);
2332
227
        handles << handle;
2333
228
        if (!mRecipients.contains(recipient)) {
2334
229
            mRecipients << recipient;
2335
230
        }
2336
231
        if (!mMembers.contains(handle)) {
2337
232
            mMembers << handle;
2338
233
        }
2339
234
    }
2340
235
    mGroupIface->addMembers(handles, recipients);
2341
236
}
2342
237
2343
238
QStringList MockTextChannel::recipients() const
2344
239
{
2345
240
    return mRecipients;
2346
241
}
2347
242
2348
243
Tp::UIntList MockTextChannel::members()
2349
244
{
2350
245
    return mMembers;
2351
246
}
2352
247
2353
248
void MockTextChannel::onAddMembers(const Tp::UIntList &handles, const QString &message, Tp::DBusError *error)
2354
249
{
2355
250
    addMembers(mConnection->inspectHandles(Tp::HandleTypeContact, handles, error));
2356
251
}
2357
252
2358
253
void MockTextChannel::onRemoveMembers(const Tp::UIntList &handles, const QString &message, Tp::DBusError *error)
2359
254
{
2360
255
    Q_FOREACH(uint handle, handles) {
2361
256
        Q_FOREACH(const QString &recipient, mConnection->inspectHandles(Tp::HandleTypeContact, Tp::UIntList() << handle, error)) {
2362
257
            mRecipients.removeAll(recipient);
2363
258
        }
2364
259
        mMembers.removeAll(handle);
2365
260
    }
2366
261
    mGroupIface->removeMembers(handles);
2367
262
}
2368
201
263
2369
=== modified file 'tests/common/mock/textchannel.h'
2370
--- handler/tests/mock/textchannel.h	2014-01-07 19:53:45 +0000
2371
+++ tests/common/mock/textchannel.h	2015-03-30 20:55:55 +0000
2372
@@ -35,13 +35,19 @@
2373
35
{
35
{
2374
36
    Q_OBJECT
36
    Q_OBJECT
2375
37
public:
37
public:
2377
38
    MockTextChannel(MockConnection *conn, QString phoneNumber, uint targetHandle, QObject *parent = 0);
38
    MockTextChannel(MockConnection *conn, QStringList recipients, uint targetHandle, QObject *parent = 0);
2378
39
    QString sendMessage(const Tp::MessagePartList& message, uint flags, Tp::DBusError* error);
39
    QString sendMessage(const Tp::MessagePartList& message, uint flags, Tp::DBusError* error);
2379
40
    void messageReceived(const QString & message, const QVariantMap &info);
40
    void messageReceived(const QString & message, const QVariantMap &info);
2380
41
    Tp::BaseChannelPtr baseChannel();
41
    Tp::BaseChannelPtr baseChannel();
2381
42
    void messageAcknowledged(const QString &id);
42
    void messageAcknowledged(const QString &id);
2382
43
    void mmsReceived(const QString &id, const QVariantMap &properties);
43
    void mmsReceived(const QString &id, const QVariantMap &properties);
2383
44
44
2384
45
    void addMembers(QStringList recipients);
2385
46
    QStringList recipients() const;
2386
47
    Tp::UIntList members();
2387
48
    void onAddMembers(const Tp::UIntList& handles, const QString& message, Tp::DBusError* error);
2388
49
    void onRemoveMembers(const Tp::UIntList& handles, const QString& message, Tp::DBusError* error);
2389
50
2390
45
public Q_SLOTS:
51
public Q_SLOTS:
2391
46
    void placeDeliveryReport(const QString &messageId, const QString &status);
52
    void placeDeliveryReport(const QString &messageId, const QString &status);
2392
47
53
2393
@@ -52,12 +58,14 @@
2394
52
private:
58
private:
2395
53
    ~MockTextChannel();
59
    ~MockTextChannel();
2396
54
    Tp::BaseChannelPtr mBaseChannel;
60
    Tp::BaseChannelPtr mBaseChannel;
2398
55
    QString mPhoneNumber;
61
    QStringList mRecipients;
2399
56
    MockConnection *mConnection;
62
    MockConnection *mConnection;
2400
57
    uint mTargetHandle;
63
    uint mTargetHandle;
2401
58
    Tp::BaseChannelMessagesInterfacePtr mMessagesIface;
64
    Tp::BaseChannelMessagesInterfacePtr mMessagesIface;
2402
65
    Tp::BaseChannelGroupInterfacePtr mGroupIface;
2403
59
    Tp::BaseChannelTextTypePtr mTextChannel;
66
    Tp::BaseChannelTextTypePtr mTextChannel;
2404
60
    uint mMessageCounter;
67
    uint mMessageCounter;
2405
68
    Tp::UIntList mMembers;
2406
61
};
69
};
2407
62
70
2408
63
#endif // MOCKTEXTCHANNEL_H
71
#endif // MOCKTEXTCHANNEL_H
2409
64
72
2410
=== added file 'tests/common/mock/ussdiface.cpp'
2411
--- tests/common/mock/ussdiface.cpp	1970-01-01 00:00:00 +0000
2412
+++ tests/common/mock/ussdiface.cpp	2015-03-30 20:55:55 +0000
2413
@@ -0,0 +1,312 @@
2414
1
/**
2415
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
2416
3
 *
2417
4
 * This program is free software: you can redistribute it and/or modify it under
2418
5
 * the terms of the GNU General Public License version 3, as published by
2419
6
 * the Free Software Foundation.
2420
7
 *
2421
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
2422
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
2423
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2424
11
 * General Public License for more details.
2425
12
 *
2426
13
 * You should have received a copy of the GNU General Public License
2427
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2428
15
 *
2429
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
2430
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
2431
18
 */
2432
19
2433
20
#include <QDebug>
2434
21
2435
22
#include <TelepathyQt/Constants>
2436
23
#include <TelepathyQt/DBusObject>
2437
24
2438
25
#include "ussdiface.h"
2439
26
2440
27
// Conn.I.USSD
2441
28
BaseConnectionUSSDInterface::Adaptee::Adaptee(BaseConnectionUSSDInterface *interface)
2442
29
    : QObject(interface),
2443
30
      mInterface(interface)
2444
31
{
2445
32
}
2446
33
2447
34
2448
35
struct TP_QT_NO_EXPORT BaseConnectionUSSDInterface::Private {
2449
36
    Private(BaseConnectionUSSDInterface *parent)
2450
37
        : adaptee(new BaseConnectionUSSDInterface::Adaptee(parent)) {
2451
38
    }
2452
39
    QString state;
2453
40
    QString serial;
2454
41
    InitiateCallback initiateCB;
2455
42
    RespondCallback respondCB;
2456
43
    CancelCallback cancelCB;
2457
44
    BaseConnectionUSSDInterface::Adaptee *adaptee;
2458
45
};
2459
46
2460
47
BaseConnectionUSSDInterface::Adaptee::~Adaptee()
2461
48
{
2462
49
}
2463
50
2464
51
void BaseConnectionUSSDInterface::Adaptee::initiate(const QString &command, const ConnectionInterfaceUSSDAdaptor::InitiateContextPtr &context)
2465
52
{
2466
53
    if (!mInterface->mPriv->initiateCB.isValid()) {
2467
54
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
2468
55
        return;
2469
56
    }
2470
57
    Tp::DBusError error;
2471
58
    mInterface->mPriv->initiateCB(command, &error);
2472
59
    if (error.isValid()) {
2473
60
        context->setFinishedWithError(error.name(), error.message());
2474
61
        return;
2475
62
    }
2476
63
    context->setFinished();
2477
64
}
2478
65
2479
66
void BaseConnectionUSSDInterface::Adaptee::respond(const QString &reply, const ConnectionInterfaceUSSDAdaptor::RespondContextPtr &context)
2480
67
{
2481
68
    if (!mInterface->mPriv->respondCB.isValid()) {
2482
69
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
2483
70
        return;
2484
71
    }
2485
72
    Tp::DBusError error;
2486
73
    mInterface->mPriv->respondCB(reply, &error);
2487
74
    if (error.isValid()) {
2488
75
        context->setFinishedWithError(error.name(), error.message());
2489
76
        return;
2490
77
    }
2491
78
    context->setFinished();
2492
79
}
2493
80
2494
81
void BaseConnectionUSSDInterface::Adaptee::cancel(const ConnectionInterfaceUSSDAdaptor::CancelContextPtr &context)
2495
82
{
2496
83
    if (!mInterface->mPriv->cancelCB.isValid()) {
2497
84
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
2498
85
        return;
2499
86
    }
2500
87
    Tp::DBusError error;
2501
88
    mInterface->mPriv->cancelCB(&error);
2502
89
    if (error.isValid()) {
2503
90
        context->setFinishedWithError(error.name(), error.message());
2504
91
        return;
2505
92
    }
2506
93
    context->setFinished();
2507
94
}
2508
95
2509
96
BaseConnectionUSSDInterface::BaseConnectionUSSDInterface()
2510
97
    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_USSD),
2511
98
      mPriv(new Private(this))
2512
99
{
2513
100
}
2514
101
2515
102
BaseConnectionUSSDInterface::~BaseConnectionUSSDInterface()
2516
103
{
2517
104
    delete mPriv;
2518
105
}
2519
106
2520
107
void BaseConnectionUSSDInterface::setInitiateCallback(const InitiateCallback &cb)
2521
108
{
2522
109
    mPriv->initiateCB = cb;
2523
110
}
2524
111
2525
112
void BaseConnectionUSSDInterface::setRespondCallback(const RespondCallback &cb)
2526
113
{
2527
114
    mPriv->respondCB = cb;
2528
115
}
2529
116
2530
117
void BaseConnectionUSSDInterface::setCancelCallback(const CancelCallback &cb)
2531
118
{
2532
119
    mPriv->cancelCB = cb;
2533
120
}
2534
121
2535
122
QString BaseConnectionUSSDInterface::state() const
2536
123
{
2537
124
    return mPriv->state;
2538
125
}
2539
126
2540
127
void BaseConnectionUSSDInterface::setSerial(const QString &serial) const
2541
128
{
2542
129
    mPriv->serial = serial;
2543
130
}
2544
131
2545
132
2546
133
QString BaseConnectionUSSDInterface::serial() const
2547
134
{
2548
135
    return mPriv->serial;
2549
136
}
2550
137
2551
138
void BaseConnectionUSSDInterface::StateChanged(const QString &state)
2552
139
{
2553
140
    mPriv->state = state;
2554
141
    Q_EMIT mPriv->adaptee->stateChanged(state);
2555
142
}
2556
143
2557
144
void BaseConnectionUSSDInterface::InitiateUSSDComplete(const QString &ussdResp)
2558
145
{
2559
146
    Q_EMIT mPriv->adaptee->initiateUSSDComplete(ussdResp);
2560
147
}
2561
148
2562
149
void BaseConnectionUSSDInterface::RespondComplete(bool success, const QString &ussdResp)
2563
150
{
2564
151
    Q_EMIT mPriv->adaptee->respondComplete(success, ussdResp);
2565
152
}
2566
153
2567
154
void BaseConnectionUSSDInterface::BarringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap)
2568
155
{
2569
156
    Q_EMIT mPriv->adaptee->barringComplete(ssOp, cbService, cbMap);
2570
157
}
2571
158
2572
159
void BaseConnectionUSSDInterface::ForwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap)
2573
160
{
2574
161
    Q_EMIT mPriv->adaptee->forwardingComplete(ssOp, cfService, cfMap);
2575
162
}
2576
163
2577
164
void BaseConnectionUSSDInterface::WaitingComplete(const QString &ssOp, const QVariantMap &cwMap)
2578
165
{
2579
166
    Q_EMIT mPriv->adaptee->waitingComplete(ssOp, cwMap);
2580
167
}
2581
168
2582
169
void BaseConnectionUSSDInterface::CallingLinePresentationComplete(const QString &ssOp, const QString &status)
2583
170
{
2584
171
    Q_EMIT mPriv->adaptee->callingLinePresentationComplete(ssOp, status);
2585
172
}
2586
173
2587
174
void BaseConnectionUSSDInterface::ConnectedLinePresentationComplete(const QString &ssOp, const QString &status)
2588
175
{
2589
176
    Q_EMIT mPriv->adaptee->connectedLinePresentationComplete(ssOp, status);
2590
177
}
2591
178
2592
179
void BaseConnectionUSSDInterface::CallingLineRestrictionComplete(const QString &ssOp, const QString &status)
2593
180
{
2594
181
    Q_EMIT mPriv->adaptee->callingLineRestrictionComplete(ssOp, status);
2595
182
}
2596
183
2597
184
void BaseConnectionUSSDInterface::ConnectedLineRestrictionComplete(const QString &ssOp, const QString &status)
2598
185
{
2599
186
    Q_EMIT mPriv->adaptee->connectedLineRestrictionComplete(ssOp, status);
2600
187
}
2601
188
2602
189
void BaseConnectionUSSDInterface::InitiateFailed()
2603
190
{
2604
191
    Q_EMIT mPriv->adaptee->initiateFailed();
2605
192
}
2606
193
2607
194
void BaseConnectionUSSDInterface::NotificationReceived(const QString &message)
2608
195
{
2609
196
    Q_EMIT mPriv->adaptee->notificationReceived(message);
2610
197
}
2611
198
2612
199
void BaseConnectionUSSDInterface::RequestReceived(const QString &message)
2613
200
{
2614
201
    Q_EMIT mPriv->adaptee->requestReceived(message);
2615
202
}
2616
203
2617
204
2618
205
QVariantMap BaseConnectionUSSDInterface::immutableProperties() const
2619
206
{
2620
207
    QVariantMap map;
2621
208
    return map;
2622
209
}
2623
210
2624
211
void BaseConnectionUSSDInterface::createAdaptor()
2625
212
{
2626
213
    (void) new ConnectionInterfaceUSSDAdaptor(dbusObject()->dbusConnection(),
2627
214
            mPriv->adaptee, dbusObject());
2628
215
}
2629
216
2630
217
2631
218
ConnectionInterfaceUSSDAdaptor::ConnectionInterfaceUSSDAdaptor(const QDBusConnection& bus, QObject* adaptee, QObject* parent)
2632
219
    : Tp::AbstractAdaptor(bus, adaptee, parent)
2633
220
{
2634
221
    connect(adaptee, SIGNAL(notificationReceived(const QString &)), SIGNAL(NotificationReceived(const QString &)));
2635
222
    connect(adaptee, SIGNAL(requestReceived(const QString &)), SIGNAL(RequestReceived(const QString &)));
2636
223
2637
224
    connect(adaptee, SIGNAL(initiateUSSDComplete(const QString &)), SIGNAL(InitiateUSSDComplete(const QString &)));
2638
225
2639
226
    connect(adaptee, SIGNAL(barringComplete(const QString &, const QString &, const QVariantMap &)), 
2640
227
        SIGNAL(BarringComplete(const QString &, const QString &, const QVariantMap &)));
2641
228
2642
229
    connect(adaptee, SIGNAL(forwardingComplete(const QString &, const QString &, const QVariantMap &)), 
2643
230
        SIGNAL(ForwardingComplete(const QString &, const QString &, const QVariantMap &)));
2644
231
2645
232
    connect(adaptee, SIGNAL(waitingComplete(const QString &, const QVariantMap &)), 
2646
233
        SIGNAL(WaitingComplete(const QString &, const QVariantMap &)));
2647
234
2648
235
    connect(adaptee, SIGNAL(callingLinePresentationComplete(const QString &, const QString &)), 
2649
236
        SIGNAL(CallingLinePresentationComplete(const QString &, const QString &)));
2650
237
2651
238
    connect(adaptee, SIGNAL(connectedLinePresentationComplete(const QString &, const QString &)), 
2652
239
        SIGNAL(ConnectedLinePresentationComplete(const QString &, const QString &)));
2653
240
2654
241
    connect(adaptee, SIGNAL(callingLineRestrictionComplete(const QString &, const QString &)), 
2655
242
        SIGNAL(CallingLineRestrictionComplete(const QString &, const QString &)));
2656
243
2657
244
    connect(adaptee, SIGNAL(connectedLineRestrictionComplete(const QString &, const QString &)), 
2658
245
        SIGNAL(ConnectedLineRestrictionComplete(const QString &, const QString &)));
2659
246
2660
247
    connect(adaptee, SIGNAL(initiateFailed()), SIGNAL(InitiateFailed()));
2661
248
2662
249
    connect(adaptee, SIGNAL(stateChanged(const QString&)), SIGNAL(StateChanged(const QString&)));
2663
250
2664
251
    connect(adaptee, SIGNAL(respondComplete(bool, const QString &)), SIGNAL(RespondComplete(bool, const QString &)));
2665
252
}
2666
253
2667
254
ConnectionInterfaceUSSDAdaptor::~ConnectionInterfaceUSSDAdaptor()
2668
255
{
2669
256
}
2670
257
2671
258
void ConnectionInterfaceUSSDAdaptor::Initiate(const QString &command, const QDBusMessage& dbusMessage)
2672
259
{
2673
260
    if (!adaptee()->metaObject()->indexOfMethod("initiate(const QString &,ConnectionInterfaceUSSDAdaptor::InitiateContextPtr)") == -1) {
2674
261
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
2675
262
        return;
2676
263
    }
2677
264
2678
265
    InitiateContextPtr ctx = InitiateContextPtr(
2679
266
            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
2680
267
    QMetaObject::invokeMethod(adaptee(), "initiate",
2681
268
        Q_ARG(QString, command),
2682
269
        Q_ARG(ConnectionInterfaceUSSDAdaptor::InitiateContextPtr, ctx));
2683
270
    return;
2684
271
}
2685
272
2686
273
void ConnectionInterfaceUSSDAdaptor::Respond(const QString &reply, const QDBusMessage& dbusMessage)
2687
274
{
2688
275
    if (!adaptee()->metaObject()->indexOfMethod("respond(QConnectionInterfaceUSSDAdaptor::RespondContextPtr)") == -1) {
2689
276
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
2690
277
        return;
2691
278
    }
2692
279
2693
280
    RespondContextPtr ctx = RespondContextPtr(
2694
281
            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
2695
282
    QMetaObject::invokeMethod(adaptee(), "respond",
2696
283
        Q_ARG(QString, reply),
2697
284
        Q_ARG(ConnectionInterfaceUSSDAdaptor::RespondContextPtr, ctx));
2698
285
    return;
2699
286
}
2700
287
2701
288
void ConnectionInterfaceUSSDAdaptor::Cancel(const QDBusMessage& dbusMessage)
2702
289
{
2703
290
    if (!adaptee()->metaObject()->indexOfMethod("cancel(ConnectionInterfaceUSSDAdaptor::CancelContextPtr)") == -1) {
2704
291
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
2705
292
        return;
2706
293
    }
2707
294
2708
295
    CancelContextPtr ctx = CancelContextPtr(
2709
296
            new Tp::MethodInvocationContext< >(dbusConnection(), dbusMessage));
2710
297
    QMetaObject::invokeMethod(adaptee(), "cancel",
2711
298
        Q_ARG(ConnectionInterfaceUSSDAdaptor::CancelContextPtr, ctx));
2712
299
    return;
2713
300
}
2714
301
2715
302
QString ConnectionInterfaceUSSDAdaptor::Serial() const
2716
303
{
2717
304
    return qvariant_cast< QString >(adaptee()->property("serial"));
2718
305
}
2719
306
2720
307
2721
308
QString ConnectionInterfaceUSSDAdaptor::State() const
2722
309
{
2723
310
    return qvariant_cast< QString >(adaptee()->property("state"));
2724
311
}
2725
312
2726
0
313
2727
=== added file 'tests/common/mock/ussdiface.h'
2728
--- tests/common/mock/ussdiface.h	1970-01-01 00:00:00 +0000
2729
+++ tests/common/mock/ussdiface.h	2015-03-30 20:55:55 +0000
2730
@@ -0,0 +1,244 @@
2731
1
/**
2732
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
2733
3
 *
2734
4
 * This program is free software: you can redistribute it and/or modify it under
2735
5
 * the terms of the GNU General Public License version 3, as published by
2736
6
 * the Free Software Foundation.
2737
7
 *
2738
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
2739
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
2740
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2741
11
 * General Public License for more details.
2742
12
 *
2743
13
 * You should have received a copy of the GNU General Public License
2744
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2745
15
 *
2746
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
2747
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
2748
18
 */
2749
19
2750
20
#ifndef OFONOUSSDIFACE_H
2751
21
#define OFONOUSSDIFACE_H
2752
22
2753
23
// telepathy-qt
2754
24
#include <TelepathyQt/Constants>
2755
25
#include <TelepathyQt/BaseConnection>
2756
26
#include <TelepathyQt/AbstractAdaptor>
2757
27
#include <TelepathyQt/DBusError>
2758
28
#include <TelepathyQt/Callbacks>
2759
29
2760
30
class BaseConnectionUSSDInterface;
2761
31
2762
32
typedef Tp::SharedPtr<BaseConnectionUSSDInterface> BaseConnectionUSSDInterfacePtr;
2763
33
2764
34
#define TP_QT_IFACE_CONNECTION_USSD "com.canonical.Telephony.USSD"
2765
35
2766
36
class TP_QT_EXPORT BaseConnectionUSSDInterface : public Tp::AbstractConnectionInterface
2767
37
{
2768
38
    Q_OBJECT
2769
39
    Q_DISABLE_COPY(BaseConnectionUSSDInterface)
2770
40
2771
41
public:
2772
42
    static BaseConnectionUSSDInterfacePtr create() {
2773
43
        return BaseConnectionUSSDInterfacePtr(new BaseConnectionUSSDInterface());
2774
44
    }
2775
45
    template<typename BaseConnectionUSSDInterfaceSubclass>
2776
46
    static Tp::SharedPtr<BaseConnectionUSSDInterfaceSubclass> create() {
2777
47
        return Tp::SharedPtr<BaseConnectionUSSDInterfaceSubclass>(
2778
48
                   new BaseConnectionUSSDInterfaceSubclass());
2779
49
    }
2780
50
    QVariantMap immutableProperties() const;
2781
51
    virtual ~BaseConnectionUSSDInterface();
2782
52
2783
53
    typedef Tp::Callback2<void, const QString&, Tp::DBusError*> InitiateCallback;
2784
54
    void setInitiateCallback(const InitiateCallback &cb);
2785
55
2786
56
    typedef Tp::Callback2<void, const QString&, Tp::DBusError*> RespondCallback;
2787
57
    void setRespondCallback(const RespondCallback &cb);
2788
58
2789
59
    typedef Tp::Callback1<void, Tp::DBusError*> CancelCallback;
2790
60
    void setCancelCallback(const CancelCallback &cb);
2791
61
2792
62
2793
63
    QString state() const;
2794
64
    QString serial() const;
2795
65
2796
66
public Q_SLOTS:
2797
67
    void NotificationReceived(const QString &message);
2798
68
    void RequestReceived(const QString &message);
2799
69
2800
70
    void InitiateUSSDComplete(const QString &ussdResp);
2801
71
    void RespondComplete(bool success, const QString &ussdResp);
2802
72
    void BarringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap);
2803
73
    void ForwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap);
2804
74
    void WaitingComplete(const QString &ssOp, const QVariantMap &cwMap);
2805
75
    void CallingLinePresentationComplete(const QString &ssOp, const QString &status);
2806
76
    void ConnectedLinePresentationComplete(const QString &ssOp, const QString &status);
2807
77
    void CallingLineRestrictionComplete(const QString &ssOp, const QString &status);
2808
78
    void ConnectedLineRestrictionComplete(const QString &ssOp, const QString &status);
2809
79
    void InitiateFailed();
2810
80
    void StateChanged(const QString &state);
2811
81
2812
82
    void setSerial(const QString& serial) const;
2813
83
protected:
2814
84
    BaseConnectionUSSDInterface();
2815
85
2816
86
private:
2817
87
    void createAdaptor();
2818
88
2819
89
    class Adaptee;
2820
90
    friend class Adaptee;
2821
91
    struct Private;
2822
92
    friend struct Private;
2823
93
    Private *mPriv;
2824
94
};
2825
95
2826
96
2827
97
class TP_QT_EXPORT ConnectionInterfaceUSSDAdaptor : public Tp::AbstractAdaptor
2828
98
{
2829
99
    Q_OBJECT
2830
100
    Q_CLASSINFO("D-Bus Interface", TP_QT_IFACE_CONNECTION_USSD)
2831
101
    Q_CLASSINFO("D-Bus Introspection", ""
2832
102
"  <interface name=\"com.canonical.Telephony.USSD\">\n"
2833
103
"    <property access=\"read\" type=\"s\" name=\"State\"/>\n"
2834
104
"    <property access=\"read\" type=\"s\" name=\"Serial\"/>\n"
2835
105
"    <method name=\"Initiate\">\n"
2836
106
"      <arg direction=\"in\" type=\"s\" name=\"command\"/>\n"
2837
107
"    </method>\n"
2838
108
"    <method name=\"Respond\">\n"
2839
109
"      <arg direction=\"in\" type=\"s\" name=\"reply\"/>\n"
2840
110
"    </method>\n"
2841
111
"    <method name=\"Cancel\" />\n"
2842
112
"    <signal name=\"NotificationReceived\">\n"
2843
113
"      <arg type=\"s\" name=\"message\"/>\n"
2844
114
"    </signal>\n"
2845
115
"    <signal name=\"RequestReceived\">\n"
2846
116
"      <arg type=\"s\" name=\"message\"/>\n"
2847
117
"    </signal>\n"
2848
118
"    <signal name=\"InitiateUSSDComplete\">\n"
2849
119
"      <arg type=\"s\" name=\"response\"/>\n"
2850
120
"    </signal>\n"
2851
121
"    <signal name=\"RespondComplete\">\n"
2852
122
"      <arg type=\"b\" name=\"success\"/>\n"
2853
123
"      <arg type=\"s\" name=\"response\"/>\n"
2854
124
"    </signal>\n"
2855
125
"    <signal name=\"BarringComplete\">\n"
2856
126
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2857
127
"      <arg type=\"s\" name=\"cbService\"/>\n"
2858
128
"      <arg type=\"a{sv}\" name=\"cbMap\"/>\n"
2859
129
"    </signal>\n"
2860
130
"    <signal name=\"ForwardingComplete\">\n"
2861
131
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2862
132
"      <arg type=\"s\" name=\"cfService\"/>\n"
2863
133
"      <arg type=\"a{sv}\" name=\"cfMap\"/>\n"
2864
134
"    </signal>\n"
2865
135
"    <signal name=\"WaitingComplete\">\n"
2866
136
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2867
137
"      <arg type=\"a{sv}\" name=\"cwMap\"/>\n"
2868
138
"    </signal>\n"
2869
139
"    <signal name=\"CallingLinePresentationComplete\">\n"
2870
140
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2871
141
"      <arg type=\"s\" name=\"status\"/>\n"
2872
142
"    </signal>\n"
2873
143
"    <signal name=\"ConnectedLinePresentationComplete\">\n"
2874
144
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2875
145
"      <arg type=\"s\" name=\"status\"/>\n"
2876
146
"    </signal>\n"
2877
147
"    <signal name=\"CallingLineRestrictionComplete\">\n"
2878
148
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2879
149
"      <arg type=\"s\" name=\"status\"/>\n"
2880
150
"    </signal>\n"
2881
151
"    <signal name=\"ConnectedLineRestrictionComplete\">\n"
2882
152
"      <arg type=\"s\" name=\"ssOp\"/>\n"
2883
153
"      <arg type=\"s\" name=\"status\"/>\n"
2884
154
"    </signal>\n"
2885
155
"    <signal name=\"InitiateFailed\" />\n"
2886
156
"    <signal name=\"StateChanged\">\n"
2887
157
"      <arg type=\"s\" name=\"state\"/>\n"
2888
158
"    </signal>\n"
2889
159
"  </interface>\n"
2890
160
"")
2891
161
    Q_PROPERTY(QString State READ State)
2892
162
    Q_PROPERTY(QString Serial READ Serial)
2893
163
2894
164
public:
2895
165
    ConnectionInterfaceUSSDAdaptor(const QDBusConnection& dbusConnection, QObject* adaptee, QObject* parent);
2896
166
    virtual ~ConnectionInterfaceUSSDAdaptor();
2897
167
2898
168
    typedef Tp::MethodInvocationContextPtr< > InitiateContextPtr;
2899
169
    typedef Tp::MethodInvocationContextPtr< > RespondContextPtr;
2900
170
    typedef Tp::MethodInvocationContextPtr< > CancelContextPtr;
2901
171
2902
172
public Q_SLOTS: // METHODS
2903
173
    void Initiate(const QString &command, const QDBusMessage& dbusMessage);
2904
174
    void Respond(const QString &reply, const QDBusMessage& dbusMessage);
2905
175
    void Cancel(const QDBusMessage& dbusMessage);
2906
176
2907
177
    QString State() const;
2908
178
    QString Serial() const;
2909
179
2910
180
Q_SIGNALS: // SIGNALS
2911
181
    void NotificationReceived(const QString &message);
2912
182
    void RequestReceived(const QString &message);
2913
183
2914
184
    void InitiateUSSDComplete(const QString &ussdResp);
2915
185
    void RespondComplete(bool success, const QString &ussdResp);
2916
186
    void BarringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap);
2917
187
    void ForwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap);
2918
188
    void WaitingComplete(const QString &ssOp, const QVariantMap &cwMap);
2919
189
    void CallingLinePresentationComplete(const QString &ssOp, const QString &status);
2920
190
    void ConnectedLinePresentationComplete(const QString &ssOp, const QString &status);
2921
191
    void CallingLineRestrictionComplete(const QString &ssOp, const QString &status);
2922
192
    void ConnectedLineRestrictionComplete(const QString &ssOp, const QString &status);
2923
193
    void InitiateFailed();
2924
194
2925
195
    void StateChanged(const QString &state);
2926
196
};
2927
197
2928
198
2929
199
class TP_QT_NO_EXPORT BaseConnectionUSSDInterface::Adaptee : public QObject
2930
200
{
2931
201
    Q_OBJECT
2932
202
    Q_PROPERTY(QString state READ state)
2933
203
    Q_PROPERTY(QString serial READ serial)
2934
204
2935
205
public:
2936
206
    Adaptee(BaseConnectionUSSDInterface *interface);
2937
207
    ~Adaptee();
2938
208
    QString state() const
2939
209
    {
2940
210
        return mInterface->state();
2941
211
    }
2942
212
    QString serial() const
2943
213
    {
2944
214
        return mInterface->serial();
2945
215
    }
2946
216
2947
217
2948
218
private Q_SLOTS:
2949
219
    void initiate(const QString &command, const ConnectionInterfaceUSSDAdaptor::InitiateContextPtr &context);
2950
220
    void respond(const QString &reply, const ConnectionInterfaceUSSDAdaptor::RespondContextPtr &context);
2951
221
    void cancel(const ConnectionInterfaceUSSDAdaptor::CancelContextPtr &context);
2952
222
2953
223
Q_SIGNALS:
2954
224
    void notificationReceived(const QString &message);
2955
225
    void requestReceived(const QString &message);
2956
226
2957
227
    void initiateUSSDComplete(const QString &ussdResp);
2958
228
    void barringComplete(const QString &ssOp, const QString &cbService, const QVariantMap &cbMap);
2959
229
    void forwardingComplete(const QString &ssOp, const QString &cfService, const QVariantMap &cfMap);
2960
230
    void waitingComplete(const QString &ssOp, const QVariantMap &cwMap);
2961
231
    void callingLinePresentationComplete(const QString &ssOp, const QString &status);
2962
232
    void connectedLinePresentationComplete(const QString &ssOp, const QString &status);
2963
233
    void callingLineRestrictionComplete(const QString &ssOp, const QString &status);
2964
234
    void connectedLineRestrictionComplete(const QString &ssOp, const QString &status);
2965
235
    void initiateFailed();
2966
236
    void respondComplete(bool success, const QString &response);
2967
237
2968
238
    void stateChanged(const QString &state);
2969
239
2970
240
public:
2971
241
    BaseConnectionUSSDInterface *mInterface;
2972
242
};
2973
243
2974
244
#endif
2975
0
245
2976
=== added file 'tests/common/mock/voicemailiface.cpp'
2977
--- tests/common/mock/voicemailiface.cpp	1970-01-01 00:00:00 +0000
2978
+++ tests/common/mock/voicemailiface.cpp	2015-03-30 20:55:55 +0000
2979
@@ -0,0 +1,202 @@
2980
1
/**
2981
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
2982
3
 *
2983
4
 * This program is free software: you can redistribute it and/or modify it under
2984
5
 * the terms of the GNU General Public License version 3, as published by
2985
6
 * the Free Software Foundation.
2986
7
 *
2987
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
2988
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
2989
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
2990
11
 * General Public License for more details.
2991
12
 *
2992
13
 * You should have received a copy of the GNU General Public License
2993
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2994
15
 *
2995
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
2996
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
2997
18
 */
2998
19
2999
20
#include <QDebug>
3000
21
3001
22
#include <TelepathyQt/Constants>
3002
23
#include <TelepathyQt/DBusObject>
3003
24
3004
25
#include "voicemailiface.h"
3005
26
3006
27
// Conn.I.Voicemail
3007
28
BaseConnectionVoicemailInterface::Adaptee::Adaptee(BaseConnectionVoicemailInterface *interface)
3008
29
    : QObject(interface),
3009
30
      mInterface(interface)
3010
31
{
3011
32
}
3012
33
3013
34
3014
35
struct TP_QT_NO_EXPORT BaseConnectionVoicemailInterface::Private {
3015
36
    Private(BaseConnectionVoicemailInterface *parent)
3016
37
        : adaptee(new BaseConnectionVoicemailInterface::Adaptee(parent)) {
3017
38
    }
3018
39
    VoicemailCountCallback voicemailCountCB;
3019
40
    VoicemailNumberCallback voicemailNumberCB;
3020
41
    VoicemailIndicatorCallback voicemailIndicatorCB;
3021
42
    BaseConnectionVoicemailInterface::Adaptee *adaptee;
3022
43
};
3023
44
3024
45
BaseConnectionVoicemailInterface::Adaptee::~Adaptee()
3025
46
{
3026
47
}
3027
48
3028
49
void BaseConnectionVoicemailInterface::Adaptee::voicemailIndicator(const ConnectionInterfaceVoicemailAdaptor::VoicemailIndicatorContextPtr &context)
3029
50
{
3030
51
    if (!mInterface->mPriv->voicemailIndicatorCB.isValid()) {
3031
52
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
3032
53
        return;
3033
54
    }
3034
55
    Tp::DBusError error;
3035
56
    bool active = mInterface->mPriv->voicemailIndicatorCB(&error);
3036
57
    if (error.isValid()) {
3037
58
        context->setFinishedWithError(error.name(), error.message());
3038
59
        return;
3039
60
    }
3040
61
    context->setFinished(active);
3041
62
}
3042
63
3043
64
void BaseConnectionVoicemailInterface::Adaptee::voicemailNumber(const ConnectionInterfaceVoicemailAdaptor::VoicemailNumberContextPtr &context)
3044
65
{
3045
66
    if (!mInterface->mPriv->voicemailNumberCB.isValid()) {
3046
67
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
3047
68
        return;
3048
69
    }
3049
70
    Tp::DBusError error;
3050
71
    QString number = mInterface->mPriv->voicemailNumberCB(&error);
3051
72
    if (error.isValid()) {
3052
73
        context->setFinishedWithError(error.name(), error.message());
3053
74
        return;
3054
75
    }
3055
76
    context->setFinished(number);
3056
77
}
3057
78
3058
79
void BaseConnectionVoicemailInterface::Adaptee::voicemailCount(const ConnectionInterfaceVoicemailAdaptor::VoicemailCountContextPtr &context)
3059
80
{
3060
81
    if (!mInterface->mPriv->voicemailCountCB.isValid()) {
3061
82
        context->setFinishedWithError(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented"));
3062
83
        return;
3063
84
    }
3064
85
    Tp::DBusError error;
3065
86
    uint count = mInterface->mPriv->voicemailCountCB(&error);
3066
87
    if (error.isValid()) {
3067
88
        context->setFinishedWithError(error.name(), error.message());
3068
89
        return;
3069
90
    }
3070
91
    context->setFinished(count);
3071
92
}
3072
93
3073
94
3074
95
BaseConnectionVoicemailInterface::BaseConnectionVoicemailInterface()
3075
96
    : AbstractConnectionInterface(TP_QT_IFACE_CONNECTION_VOICEMAIL),
3076
97
      mPriv(new Private(this))
3077
98
{
3078
99
}
3079
100
3080
101
BaseConnectionVoicemailInterface::~BaseConnectionVoicemailInterface()
3081
102
{
3082
103
    delete mPriv;
3083
104
}
3084
105
3085
106
void BaseConnectionVoicemailInterface::setVoicemailIndicatorCallback(const VoicemailIndicatorCallback &cb)
3086
107
{
3087
108
    mPriv->voicemailIndicatorCB = cb;
3088
109
}
3089
110
3090
111
void BaseConnectionVoicemailInterface::setVoicemailNumberCallback(const VoicemailNumberCallback &cb)
3091
112
{
3092
113
    mPriv->voicemailNumberCB = cb;
3093
114
}
3094
115
3095
116
void BaseConnectionVoicemailInterface::setVoicemailCountCallback(const VoicemailCountCallback &cb)
3096
117
{
3097
118
    mPriv->voicemailCountCB = cb;
3098
119
}
3099
120
3100
121
void BaseConnectionVoicemailInterface::setVoicemailCount(int count)
3101
122
{
3102
123
    Q_EMIT mPriv->adaptee->voicemailCountChanged(uint(count));
3103
124
}
3104
125
3105
126
void BaseConnectionVoicemailInterface::setVoicemailNumber(const QString &voicemailNumber)
3106
127
{
3107
128
    Q_EMIT mPriv->adaptee->voicemailNumberChanged(voicemailNumber);
3108
129
}
3109
130
3110
131
void BaseConnectionVoicemailInterface::setVoicemailIndicator(bool active)
3111
132
{
3112
133
    Q_EMIT mPriv->adaptee->voicemailIndicatorChanged(active);
3113
134
}
3114
135
3115
136
QVariantMap BaseConnectionVoicemailInterface::immutableProperties() const
3116
137
{
3117
138
    QVariantMap map;
3118
139
    return map;
3119
140
}
3120
141
3121
142
void BaseConnectionVoicemailInterface::createAdaptor()
3122
143
{
3123
144
    (void) new ConnectionInterfaceVoicemailAdaptor(dbusObject()->dbusConnection(),
3124
145
            mPriv->adaptee, dbusObject());
3125
146
}
3126
147
3127
148
3128
149
ConnectionInterfaceVoicemailAdaptor::ConnectionInterfaceVoicemailAdaptor(const QDBusConnection& bus, QObject* adaptee, QObject* parent)
3129
150
    : Tp::AbstractAdaptor(bus, adaptee, parent)
3130
151
{
3131
152
    connect(adaptee, SIGNAL(voicemailCountChanged(uint)), SIGNAL(VoicemailCountChanged(uint)));
3132
153
    connect(adaptee, SIGNAL(voicemailIndicatorChanged(bool)), SIGNAL(VoicemailIndicatorChanged(bool)));
3133
154
    connect(adaptee, SIGNAL(voicemailNumberChanged(QString)), SIGNAL(VoicemailNumberChanged(QString)));
3134
155
}
3135
156
3136
157
ConnectionInterfaceVoicemailAdaptor::~ConnectionInterfaceVoicemailAdaptor()
3137
158
{
3138
159
}
3139
160
3140
161
bool ConnectionInterfaceVoicemailAdaptor::VoicemailIndicator(const QDBusMessage& dbusMessage)
3141
162
{
3142
163
    if (!adaptee()->metaObject()->indexOfMethod("voicemailIndicator(ConnectionInterfaceVoicemailAdaptor::VoicemailIndicatorContextPtr)") == -1) {
3143
164
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
3144
165
        return bool();
3145
166
    }
3146
167
3147
168
    VoicemailIndicatorContextPtr ctx = VoicemailIndicatorContextPtr(
3148
169
            new Tp::MethodInvocationContext< bool >(dbusConnection(), dbusMessage));
3149
170
    QMetaObject::invokeMethod(adaptee(), "voicemailIndicator",
3150
171
        Q_ARG(ConnectionInterfaceVoicemailAdaptor::VoicemailIndicatorContextPtr, ctx));
3151
172
    return bool();
3152
173
}
3153
174
3154
175
QString ConnectionInterfaceVoicemailAdaptor::VoicemailNumber(const QDBusMessage& dbusMessage)
3155
176
{
3156
177
    if (!adaptee()->metaObject()->indexOfMethod("voicemailNumber(ConnectionInterfaceVoicemailAdaptor::VoicemailNumberContextPtr)") == -1) {
3157
178
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
3158
179
        return QString();
3159
180
    }
3160
181
3161
182
    VoicemailNumberContextPtr ctx = VoicemailNumberContextPtr(
3162
183
            new Tp::MethodInvocationContext< QString >(dbusConnection(), dbusMessage));
3163
184
    QMetaObject::invokeMethod(adaptee(), "voicemailNumber",
3164
185
        Q_ARG(ConnectionInterfaceVoicemailAdaptor::VoicemailNumberContextPtr, ctx));
3165
186
    return QString();
3166
187
}
3167
188
3168
189
uint ConnectionInterfaceVoicemailAdaptor::VoicemailCount(const QDBusMessage& dbusMessage)
3169
190
{
3170
191
    if (!adaptee()->metaObject()->indexOfMethod("voicemailCount(ConnectionInterfaceVoicemailAdaptor::VoicemailCountContextPtr)") == -1) {
3171
192
        dbusConnection().send(dbusMessage.createErrorReply(TP_QT_ERROR_NOT_IMPLEMENTED, QLatin1String("Not implemented")));
3172
193
        return uint();
3173
194
    }
3174
195
3175
196
    VoicemailCountContextPtr ctx = VoicemailCountContextPtr(
3176
197
            new Tp::MethodInvocationContext< uint >(dbusConnection(), dbusMessage));
3177
198
    QMetaObject::invokeMethod(adaptee(), "voicemailCount",
3178
199
        Q_ARG(ConnectionInterfaceVoicemailAdaptor::VoicemailCountContextPtr, ctx));
3179
200
    return uint();
3180
201
}
3181
202
3182
0
203
3183
=== added file 'tests/common/mock/voicemailiface.h'
3184
--- tests/common/mock/voicemailiface.h	1970-01-01 00:00:00 +0000
3185
+++ tests/common/mock/voicemailiface.h	2015-03-30 20:55:55 +0000
3186
@@ -0,0 +1,150 @@
3187
1
/**
3188
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
3189
3
 *
3190
4
 * This program is free software: you can redistribute it and/or modify it under
3191
5
 * the terms of the GNU General Public License version 3, as published by
3192
6
 * the Free Software Foundation.
3193
7
 *
3194
8
 * This program is distributed in the hope that it will be useful, but WITHOUT
3195
9
 * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
3196
10
 * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
3197
11
 * General Public License for more details.
3198
12
 *
3199
13
 * You should have received a copy of the GNU General Public License
3200
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3201
15
 *
3202
16
 * Authors: Tiago Salem Herrmann <tiago.herrmann@canonical.com>
3203
17
            Gustavo Pichorim Boiko <gustavo.boiko@canonical.com>
3204
18
 */
3205
19
3206
20
#ifndef OFONOVOICEMAILIFACE_H
3207
21
#define OFONOVOICEMAILIFACE_H
3208
22
3209
23
// telepathy-qt
3210
24
#include <TelepathyQt/Constants>
3211
25
#include <TelepathyQt/BaseConnection>
3212
26
#include <TelepathyQt/AbstractAdaptor>
3213
27
#include <TelepathyQt/DBusError>
3214
28
#include <TelepathyQt/Callbacks>
3215
29
3216
30
class BaseConnectionVoicemailInterface;
3217
31
3218
32
typedef Tp::SharedPtr<BaseConnectionVoicemailInterface> BaseConnectionVoicemailInterfacePtr;
3219
33
3220
34
#define TP_QT_IFACE_CONNECTION_VOICEMAIL "com.canonical.Telephony.Voicemail"
3221
35
3222
36
class TP_QT_EXPORT BaseConnectionVoicemailInterface : public Tp::AbstractConnectionInterface
3223
37
{
3224
38
    Q_OBJECT
3225
39
    Q_DISABLE_COPY(BaseConnectionVoicemailInterface)
3226
40
3227
41
public:
3228
42
    static BaseConnectionVoicemailInterfacePtr create() {
3229
43
        return BaseConnectionVoicemailInterfacePtr(new BaseConnectionVoicemailInterface());
3230
44
    }
3231
45
    template<typename BaseConnectionVoicemailInterfaceSubclass>
3232
46
    static Tp::SharedPtr<BaseConnectionVoicemailInterfaceSubclass> create() {
3233
47
        return Tp::SharedPtr<BaseConnectionVoicemailInterfaceSubclass>(
3234
48
                   new BaseConnectionVoicemailInterfaceSubclass());
3235
49
    }
3236
50
    QVariantMap immutableProperties() const;
3237
51
    virtual ~BaseConnectionVoicemailInterface();
3238
52
3239
53
    typedef Tp::Callback1<uint, Tp::DBusError*> VoicemailCountCallback;
3240
54
    void setVoicemailCountCallback(const VoicemailCountCallback &cb);
3241
55
3242
56
    typedef Tp::Callback1<bool, Tp::DBusError*> VoicemailIndicatorCallback;
3243
57
    void setVoicemailIndicatorCallback(const VoicemailIndicatorCallback &cb);
3244
58
3245
59
    typedef Tp::Callback1<QString, Tp::DBusError*> VoicemailNumberCallback;
3246
60
    void setVoicemailNumberCallback(const VoicemailNumberCallback &cb);
3247
61
3248
62
public Q_SLOTS:
3249
63
    void setVoicemailCount(int count);
3250
64
    void setVoicemailIndicator(bool active);
3251
65
    void setVoicemailNumber(const QString &voicemailNumber);
3252
66
3253
67
protected:
3254
68
    BaseConnectionVoicemailInterface();
3255
69
3256
70
private:
3257
71
    void createAdaptor();
3258
72
3259
73
    class Adaptee;
3260
74
    friend class Adaptee;
3261
75
    struct Private;
3262
76
    friend struct Private;
3263
77
    Private *mPriv;
3264
78
};
3265
79
3266
80
3267
81
class TP_QT_EXPORT ConnectionInterfaceVoicemailAdaptor : public Tp::AbstractAdaptor
3268
82
{
3269
83
    Q_OBJECT
3270
84
    Q_CLASSINFO("D-Bus Interface", TP_QT_IFACE_CONNECTION_VOICEMAIL)
3271
85
    Q_CLASSINFO("D-Bus Introspection", ""
3272
86
"  <interface name=\"com.canonical.Telephony.Voicemail\">\n"
3273
87
"    <method name=\"VoicemailIndicator\">\n"
3274
88
"      <arg direction=\"out\" type=\"b\" name=\"voicemailIndicator\"/>\n"
3275
89
"    </method>\n"
3276
90
"    <method name=\"VoicemailNumber\">\n"
3277
91
"      <arg direction=\"out\" type=\"s\" name=\"voicemailNumber\"/>\n"
3278
92
"    </method>\n"
3279
93
"    <method name=\"VoicemailCount\">\n"
3280
94
"      <arg direction=\"out\" type=\"u\" name=\"voicemailCount\"/>\n"
3281
95
"    </method>\n"
3282
96
"    <signal name=\"VoicemailCountChanged\">\n"
3283
97
"      <arg type=\"u\" name=\"count\"/>\n"
3284
98
"    </signal>\n"
3285
99
"    <signal name=\"VoicemailIndicatorChanged\">\n"
3286
100
"      <arg type=\"b\" name=\"active\"/>\n"
3287
101
"    </signal>\n"
3288
102
"    <signal name=\"VoicemailNumberChanged\">\n"
3289
103
"      <arg type=\"s\" name=\"voicemailNumber\"/>\n"
3290
104
"    </signal>\n"
3291
105
"  </interface>\n"
3292
106
"")
3293
107
3294
108
public:
3295
109
    ConnectionInterfaceVoicemailAdaptor(const QDBusConnection& dbusConnection, QObject* adaptee, QObject* parent);
3296
110
    virtual ~ConnectionInterfaceVoicemailAdaptor();
3297
111
3298
112
    typedef Tp::MethodInvocationContextPtr< bool > VoicemailIndicatorContextPtr;
3299
113
    typedef Tp::MethodInvocationContextPtr< QString > VoicemailNumberContextPtr;
3300
114
    typedef Tp::MethodInvocationContextPtr< uint > VoicemailCountContextPtr;
3301
115
3302
116
public Q_SLOTS: // METHODS
3303
117
    bool VoicemailIndicator(const QDBusMessage& dbusMessage);
3304
118
    QString VoicemailNumber(const QDBusMessage& dbusMessage);
3305
119
    uint VoicemailCount(const QDBusMessage& dbusMessage);
3306
120
3307
121
Q_SIGNALS: // SIGNALS
3308
122
    void VoicemailCountChanged(uint count);
3309
123
    void VoicemailIndicatorChanged(bool active);
3310
124
    void VoicemailNumberChanged(const QString &voicemailNumber);
3311
125
};
3312
126
3313
127
3314
128
class TP_QT_NO_EXPORT BaseConnectionVoicemailInterface::Adaptee : public QObject
3315
129
{
3316
130
    Q_OBJECT
3317
131
3318
132
public:
3319
133
    Adaptee(BaseConnectionVoicemailInterface *interface);
3320
134
    ~Adaptee();
3321
135
3322
136
private Q_SLOTS:
3323
137
    void voicemailIndicator(const ConnectionInterfaceVoicemailAdaptor::VoicemailIndicatorContextPtr &context);
3324
138
    void voicemailNumber(const ConnectionInterfaceVoicemailAdaptor::VoicemailNumberContextPtr &context);
3325
139
    void voicemailCount(const ConnectionInterfaceVoicemailAdaptor::VoicemailCountContextPtr &context);
3326
140
3327
141
Q_SIGNALS:
3328
142
    void voicemailCountChanged(uint count);
3329
143
    void voicemailIndicatorChanged(bool active);
3330
144
    void voicemailNumberChanged(const QString &voicemailNumber);
3331
145
3332
146
public:
3333
147
    BaseConnectionVoicemailInterface *mInterface;
3334
148
};
3335
149
3336
150
#endif
3337
0
151
3338
=== renamed file 'handler/tests/mockcontroller.cpp' => 'tests/common/mockcontroller.cpp'
3339
--- handler/tests/mockcontroller.cpp	2014-03-20 21:03:26 +0000
3340
+++ tests/common/mockcontroller.cpp	2015-03-30 20:55:55 +0000
3341
@@ -21,27 +21,34 @@
3342
21
#include "mockcontroller.h"
21
#include "mockcontroller.h"
3343
22
#include <QDBusReply>
22
#include <QDBusReply>
3344
23
23
3366
24
#define MOCK_SERVICE "com.canonical.MockConnection"
24
static const QString mockService("com.canonical.MockConnection");
3367
25
#define MOCK_OBJECT "/com/canonical/MockConnection"
25
static const QString mockObject("/com/canonical/MockConnection/%1");
3368
26
#define MOCK_INTERFACE "com.canonical.MockConnection"
26
static const QString mockInterface("com.canonical.MockConnection");
3369
27
27
3370
28
MockController::MockController(QObject *parent) :
28
MockController::MockController(const QString &protocol, QObject *parent) :
3371
29
    QObject(parent),
29
    QObject(parent), mProtocol(protocol), mMockObject(mockObject.arg(protocol)),
3372
30
    mMockInterface(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE)
30
    mMockInterface(mockService, mockObject.arg(protocol), mockInterface)
3373
31
{
31
{
3374
32
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "MessageSent", this, SIGNAL(messageSent(QString, QVariantMap)));
32
    connect(&mMockInterface, SIGNAL(MessageRead(QString)),
3375
33
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "CallReceived", this, SIGNAL(callReceived(QString)));
33
            this, SIGNAL(messageRead(QString)));
3376
34
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "CallEnded", this, SIGNAL(callEnded(QString)));
34
    connect(&mMockInterface, SIGNAL(MessageSent(QString, QVariantMap)),
3377
35
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "CallStateChanged", this, SIGNAL(callStateChanged(QString,QString,QString)));
35
            this, SIGNAL(messageSent(QString, QVariantMap)));
3378
36
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "ConferenceCreated", this, SIGNAL(conferenceCreated(QString)));
36
    connect(&mMockInterface, SIGNAL(CallReceived(QString)),
3379
37
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "ChannelMerged", this, SIGNAL(channelMerged(QString)));
37
            this, SIGNAL(callReceived(QString)));
3380
38
    QDBusConnection::sessionBus().connect(MOCK_SERVICE, MOCK_OBJECT, MOCK_INTERFACE, "ChannelSplitted", this, SIGNAL(channelSplitted(QString)));
38
    connect(&mMockInterface, SIGNAL(CallEnded(QString)),
3381
39
}
39
            this, SIGNAL(callEnded(QString)));
3382
40
40
    connect(&mMockInterface, SIGNAL(CallStateChanged(QString, QString, QString)),
3383
41
MockController *MockController::instance()
41
            this, SIGNAL(callStateChanged(QString,QString,QString)));
3384
42
{
42
    connect(&mMockInterface, SIGNAL(ConferenceCreated(QString)),
3385
43
    static MockController *self = new MockController();
43
            this, SIGNAL(conferenceCreated(QString)));
3386
44
    return self;
44
    connect(&mMockInterface, SIGNAL(ChannelMerged(QString)),
3387
45
            this, SIGNAL(channelMerged(QString)));
3388
46
    connect(&mMockInterface, SIGNAL(ChannelSplitted(QString)),
3389
47
            this, SIGNAL(channelSplitted(QString)));
3390
48
    connect(&mMockInterface, SIGNAL(Disconnected()),
3391
49
            this, SIGNAL(disconnected()));
3392
50
    connect(&mMockInterface, SIGNAL(Destroyed()),
3393
51
            this, SIGNAL(connectionDestroyed()));
3394
45
}
52
}
3395
46
53
3396
47
void MockController::placeIncomingMessage(const QString &message, const QVariantMap &properties)
54
void MockController::placeIncomingMessage(const QString &message, const QVariantMap &properties)
3397
@@ -64,3 +71,43 @@
3398
64
{
71
{
3399
65
    mMockInterface.call("SetCallState", phoneNumber, state);
72
    mMockInterface.call("SetCallState", phoneNumber, state);
3400
66
}
73
}
3401
74
3402
75
void MockController::setOnline(bool online)
3403
76
{
3404
77
    mMockInterface.call("SetOnline", online);
3405
78
}
3406
79
3407
80
void MockController::setPresence(const QString &status, const QString &statusMessage)
3408
81
{
3409
82
    mMockInterface.call("SetPresence", status, statusMessage);
3410
83
}
3411
84
3412
85
void MockController::setVoicemailNumber(const QString &number)
3413
86
{
3414
87
    mMockInterface.call("SetVoicemailNumber", number);
3415
88
}
3416
89
3417
90
void MockController::setVoicemailIndicator(bool active)
3418
91
{
3419
92
    mMockInterface.call("SetVoicemailIndicator", active);
3420
93
}
3421
94
3422
95
void MockController::setVoicemailCount(int count)
3423
96
{
3424
97
    mMockInterface.call("SetVoicemailCount", count);
3425
98
}
3426
99
3427
100
void MockController::setEmergencyNumbers(const QStringList &numbers)
3428
101
{
3429
102
    mMockInterface.call("SetEmergencyNumbers", numbers);
3430
103
}
3431
104
3432
105
QString MockController::serial()
3433
106
{
3434
107
    QDBusReply<QString> reply = mMockInterface.call("Serial");
3435
108
    if (!reply.isValid()) {
3436
109
        return QString::null;
3437
110
    }
3438
111
3439
112
    return reply.value();
3440
113
}
3441
67
114
3442
=== renamed file 'handler/tests/mockcontroller.h' => 'tests/common/mockcontroller.h'
3443
--- handler/tests/mockcontroller.h	2014-03-20 21:03:26 +0000
3444
+++ tests/common/mockcontroller.h	2015-03-30 20:55:55 +0000
3445
@@ -28,9 +28,10 @@
3446
28
{
28
{
3447
29
    Q_OBJECT
29
    Q_OBJECT
3448
30
public:
30
public:
3450
31
    static MockController *instance();
31
    explicit MockController(const QString &protocol, QObject *parent = 0);
3451
32
32
3452
33
Q_SIGNALS:
33
Q_SIGNALS:
3453
34
    void messageRead(const QString &messageId);
3454
34
    void messageSent(const QString &message, const QVariantMap &properties);
35
    void messageSent(const QString &message, const QVariantMap &properties);
3455
35
    void callReceived(const QString &callerId);
36
    void callReceived(const QString &callerId);
3456
36
    void callEnded(const QString &callerId);
37
    void callEnded(const QString &callerId);
3457
@@ -38,16 +39,32 @@
3458
38
    void conferenceCreated(const QString &objectPath);
39
    void conferenceCreated(const QString &objectPath);
3459
39
    void channelMerged(const QString &objectPath);
40
    void channelMerged(const QString &objectPath);
3460
40
    void channelSplitted(const QString &objectPath);
41
    void channelSplitted(const QString &objectPath);
3461
42
    void disconnected();
3462
43
    void connectionDestroyed();
3463
41
44
3464
42
public Q_SLOTS:
45
public Q_SLOTS:
3465
43
    void placeIncomingMessage(const QString &message, const QVariantMap &properties);
46
    void placeIncomingMessage(const QString &message, const QVariantMap &properties);
3466
44
    QString placeCall(const QVariantMap &properties);
47
    QString placeCall(const QVariantMap &properties);
3467
45
    void hangupCall(const QString &callerId);
48
    void hangupCall(const QString &callerId);
3468
46
    void setCallState(const QString &phoneNumber, const QString &state);
49
    void setCallState(const QString &phoneNumber, const QString &state);
3469
50
    void setOnline(bool online);
3470
51
    void setPresence(const QString &status, const QString &statusMessage);
3471
52
3472
53
    // voicemail stuff
3473
54
    void setVoicemailNumber(const QString &number);
3474
55
    void setVoicemailIndicator(bool active);
3475
56
    void setVoicemailCount(int count);
3476
57
3477
58
    // emergency numbers stuff
3478
59
    void setEmergencyNumbers(const QStringList &numbers);
3479
60
3480
61
    // USSD stuff
3481
62
    QString serial();
3482
47
63
3483
48
private:
64
private:
3484
49
    explicit MockController(QObject *parent = 0);
3485
50
    QDBusInterface mMockInterface;
65
    QDBusInterface mMockInterface;
3486
66
    QString mProtocol;
3487
67
    QString mMockObject;
3488
51
};
68
};
3489
52
69
3490
53
#endif // MOCKCONTROLLER_H
70
#endif // MOCKCONTROLLER_H
3491
54
71
3492
=== added file 'tests/common/telepathytest.cpp'
3493
--- tests/common/telepathytest.cpp	1970-01-01 00:00:00 +0000
3494
+++ tests/common/telepathytest.cpp	2015-03-30 20:55:55 +0000
3495
@@ -0,0 +1,140 @@
3496
1
/*
3497
2
 * Copyright (C) 2015 Canonical, Ltd.
3498
3
 *
3499
4
 * This file is part of telephony-service.
3500
5
 *
3501
6
 * telephony-service is free software; you can redistribute it and/or modify
3502
7
 * it under the terms of the GNU General Public License as published by
3503
8
 * the Free Software Foundation; version 3.
3504
9
 *
3505
10
 * telephony-service is distributed in the hope that it will be useful,
3506
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3507
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3508
13
 * GNU General Public License for more details.
3509
14
 *
3510
15
 * You should have received a copy of the GNU General Public License
3511
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3512
17
 */
3513
18
3514
19
#include <QtCore/QObject>
3515
20
#include <QtTest/QtTest>
3516
21
#include <TelepathyQt/PendingAccount>
3517
22
#include <TelepathyQt/PendingOperation>
3518
23
#include <TelepathyQt/Account>
3519
24
#include "telepathytest.h"
3520
25
#include "telepathyhelper.h"
3521
26
#include "accountentry.h"
3522
27
3523
28
void TelepathyTest::initialize()
3524
29
{
3525
30
    Tp::registerTypes();
3526
31
3527
32
    QSignalSpy spy(TelepathyHelper::instance(), SIGNAL(setupReady()));
3528
33
    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, DEFAULT_TIMEOUT);
3529
34
3530
35
    // just in case, remove any existing account that might be a leftover from
3531
36
    // previous test runs
3532
37
    Q_FOREACH(const AccountEntry *account, TelepathyHelper::instance()->accounts()) {
3533
38
        QVERIFY(removeAccount(account->account()));
3534
39
    }
3535
40
3536
41
    // create an account manager instance to help testing
3537
42
    Tp::Features accountFeatures;
3538
43
    accountFeatures << Tp::Account::FeatureCore
3539
44
                    << Tp::Account::FeatureProtocolInfo;
3540
45
    Tp::Features contactFeatures;
3541
46
    contactFeatures << Tp::Contact::FeatureAlias
3542
47
                    << Tp::Contact::FeatureAvatarData
3543
48
                    << Tp::Contact::FeatureAvatarToken
3544
49
                    << Tp::Contact::FeatureCapabilities
3545
50
                    << Tp::Contact::FeatureSimplePresence;
3546
51
    Tp::Features connectionFeatures;
3547
52
    connectionFeatures << Tp::Connection::FeatureCore
3548
53
                       << Tp::Connection::FeatureSelfContact
3549
54
                       << Tp::Connection::FeatureSimplePresence;
3550
55
3551
56
    Tp::ChannelFactoryPtr channelFactory = Tp::ChannelFactory::create(QDBusConnection::sessionBus());
3552
57
    channelFactory->addCommonFeatures(Tp::Channel::FeatureCore);
3553
58
3554
59
    mAccountManager = Tp::AccountManager::create(
3555
60
            Tp::AccountFactory::create(QDBusConnection::sessionBus(), accountFeatures),
3556
61
            Tp::ConnectionFactory::create(QDBusConnection::sessionBus(), connectionFeatures),
3557
62
            channelFactory,
3558
63
            Tp::ContactFactory::create(contactFeatures));
3559
64
3560
65
    mReady = false;
3561
66
    connect(mAccountManager->becomeReady(Tp::AccountManager::FeatureCore),
3562
67
            &Tp::PendingOperation::finished, [=]{
3563
68
        mReady = true;
3564
69
    });
3565
70
3566
71
    QTRY_VERIFY(mReady);
3567
72
3568
73
    // give some time for telepathy stuff to settle
3569
74
    QTest::qWait(1000);
3570
75
}
3571
76
3572
77
void TelepathyTest::doCleanup()
3573
78
{
3574
79
    // remove all accounts on every test to prevent garbage to go from one test to another
3575
80
    Q_FOREACH(const Tp::AccountPtr &account, mAccounts) {
3576
81
        QVERIFY(removeAccount(account));
3577
82
    }
3578
83
    QVERIFY(mAccounts.isEmpty());
3579
84
}
3580
85
3581
86
3582
87
Tp::AccountPtr TelepathyTest::addAccount(const QString &manager, const QString &protocol, const QString &displayName, const QVariantMap &parameters)
3583
88
{
3584
89
    bool finished = false;
3585
90
    Tp::AccountPtr account;
3586
91
    connect(mAccountManager->createAccount(manager, protocol, displayName, parameters), &Tp::PendingOperation::finished,
3587
92
            [&](Tp::PendingOperation *op) {
3588
93
        Tp::PendingAccount *pa = qobject_cast<Tp::PendingAccount*>(op);
3589
94
        if (op->isError() || !pa) {
3590
95
            qCritical() << "Failed to create account:" << op->errorName() << op->errorMessage();
3591
96
            finished = true;
3592
97
            return;
3593
98
        }
3594
99
3595
100
        account = pa->account();
3596
101
        finished = true;
3597
102
    });
3598
103
3599
104
    while (!finished) {
3600
105
        QTest::qWait(100);
3601
106
    }
3602
107
    mAccounts << account;
3603
108
    return account;
3604
109
}
3605
110
3606
111
bool TelepathyTest::removeAccount(const Tp::AccountPtr &account)
3607
112
{
3608
113
    bool success = false;
3609
114
    bool finished = false;
3610
115
3611
116
    connect(account->remove(), &Tp::PendingOperation::finished,
3612
117
            [&](Tp::PendingOperation *op) {
3613
118
        success = !op->isError();
3614
119
        finished = true;
3615
120
    });
3616
121
3617
122
    while (!finished) {
3618
123
        QTest::qWait(100);
3619
124
    }
3620
125
    if (success) {
3621
126
        mAccounts.removeAll(account);
3622
127
    }
3623
128
    return success;
3624
129
}
3625
130
3626
131
3627
132
QList<Tp::AccountPtr> TelepathyTest::accounts() const
3628
133
{
3629
134
    return mAccounts;
3630
135
}
3631
136
3632
137
void TelepathyTest::cleanup()
3633
138
{
3634
139
    doCleanup();
3635
140
}
3636
0
141
3637
=== added file 'tests/common/telepathytest.h'
3638
--- tests/common/telepathytest.h	1970-01-01 00:00:00 +0000
3639
+++ tests/common/telepathytest.h	2015-03-30 20:55:55 +0000
3640
@@ -0,0 +1,54 @@
3641
1
/*
3642
2
 * Copyright (C) 2015 Canonical, Ltd.
3643
3
 *
3644
4
 * This file is part of telephony-service.
3645
5
 *
3646
6
 * telephony-service is free software; you can redistribute it and/or modify
3647
7
 * it under the terms of the GNU General Public License as published by
3648
8
 * the Free Software Foundation; version 3.
3649
9
 *
3650
10
 * telephony-service is distributed in the hope that it will be useful,
3651
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
3652
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3653
13
 * GNU General Public License for more details.
3654
14
 *
3655
15
 * You should have received a copy of the GNU General Public License
3656
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
3657
17
 */
3658
18
3659
19
#ifndef TELEPATHYTEST_H
3660
20
#define TELEPATHYTEST_H
3661
21
3662
22
#include <QtCore/QObject>
3663
23
#include <TelepathyQt/Account>
3664
24
#include "telepathyhelper.h"
3665
25
3666
26
#define DEFAULT_TIMEOUT 15000
3667
27
3668
28
class TelepathyTest : public QObject
3669
29
{
3670
30
    Q_OBJECT
3671
31
3672
32
protected:
3673
33
    void initialize();
3674
34
    void doCleanup();
3675
35
3676
36
    // helper slots
3677
37
    void onAccountManagerReady(Tp::PendingOperation *op);
3678
38
    Tp::AccountPtr addAccount(const QString &manager,
3679
39
                              const QString &protocol,
3680
40
                              const QString &displayName,
3681
41
                              const QVariantMap &parameters = QVariantMap());
3682
42
    bool removeAccount(const Tp::AccountPtr &account);
3683
43
    QList<Tp::AccountPtr> accounts() const;
3684
44
3685
45
private Q_SLOTS:
3686
46
    void cleanup();
3687
47
3688
48
private:
3689
49
    Tp::AccountManagerPtr mAccountManager;
3690
50
    bool mReady;
3691
51
    QList<Tp::AccountPtr> mAccounts;
3692
52
};
3693
53
3694
54
#endif //TELEPATHYTEST_H
3695
0
55
3696
=== renamed directory 'handler/tests' => 'tests/handler'
3697
=== modified file 'tests/handler/CMakeLists.txt'
3698
--- handler/tests/CMakeLists.txt	2014-01-22 12:33:43 +0000
3699
+++ tests/handler/CMakeLists.txt	2015-03-30 20:55:55 +0000
3700
@@ -1,43 +1,9 @@
3701
1
include_directories(
1
include_directories(
3702
2
    ${CMAKE_CURRENT_BINARY_DIR}
2
    ${CMAKE_CURRENT_BINARY_DIR}
3703
3
    ${CMAKE_CURRENT_SOURCE_DIR}/../common
3704
3
    ${CMAKE_SOURCE_DIR}
4
    ${CMAKE_SOURCE_DIR}
3705
5
    ${CMAKE_SOURCE_DIR}/libtelephonyservice
3706
6
    ${TP_QT5_INCLUDE_DIRS}
3707
4
    )
7
    )
3708
5
8
3747
6
macro(generate_test TESTNAME USE_DBUS)
9
generate_telepathy_test(HandlerTest SOURCES HandlerTest.cpp handlercontroller.cpp approver.cpp)
3710
7
    add_executable(${TESTNAME} ${ARGN} ${TESTNAME}.cpp)
3711
8
    qt5_use_modules(${TESTNAME} Core DBus Test)
3712
9
    set(TEST_COMMAND )
3713
10
    if (${USE_DBUS})
3714
11
        set(TEST_COMMAND -p ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} -p -xunitxml -p -o -p ${CMAKE_BINARY_DIR}/test_${TESTNAME}.xml)
3715
12
        add_test(${TESTNAME} ${DBUS_RUNNER} --keep-env
3716
13
                                            --task ${CMAKE_CURRENT_BINARY_DIR}/dbus-test-wrapper.sh ${TEST_COMMAND})
3717
14
    else (${USE_DBUS})
3718
15
        add_test(${TESTNAME} ${CMAKE_CURRENT_BINARY_DIR}/${TESTNAME} -xunitxml -o ${CMAKE_BINARY_DIR}/test_${TESTNAME}.xml)
3719
16
    endif(${USE_DBUS})
3720
17
    # force telepathy not to use system approvers when available,
3721
18
    # also force usage of memory backend in history-service
3722
19
    set(TMPDIR "/tmp/telephony_service_test_home")
3723
20
    set(TEST_ENVIRONMENT "HOME=${TMPDIR};"
3724
21
                         "HISTORY_SQLITE_DBPATH=:memory:;"
3725
22
                         "XDG_CONFIG_HOME=${TMPDIR};
3726
23
                          XDG_DATA_HOME=${TMPDIR};
3727
24
                          XDG_CACHE_DIR=${TMPDIR};
3728
25
                          XDG_CACHE_HOME=${TMPDIR};
3729
26
                          XDG_DATA_DIRS=${TMPDIR};
3730
27
                          MC_ACCOUNT_DIR=${TMPDIR};
3731
28
                          MC_MANAGER_DIR=${TMPDIR}")
3732
29
    set_tests_properties(${TESTNAME} PROPERTIES
3733
30
                          ENVIRONMENT "${TEST_ENVIRONMENT}"
3734
31
                          TIMEOUT 30)
3735
32
    target_link_libraries(${TESTNAME}
3736
33
                          ${TP_QT5_LIBRARIES}
3737
34
                         )
3738
35
endmacro(generate_test)
3739
36
3740
37
configure_file(dbus-test-wrapper.sh.in ${CMAKE_CURRENT_BINARY_DIR}/dbus-test-wrapper.sh)
3741
38
3742
39
if (DBUS_RUNNER)
3743
40
    generate_test(HandlerTest True telepathyhelper.cpp handlercontroller.cpp mockcontroller.cpp approver.cpp)
3744
41
endif(DBUS_RUNNER)
3745
42
3746
43
add_subdirectory(mock)
3748
44
10
3749
=== modified file 'tests/handler/HandlerTest.cpp'
3750
--- handler/tests/HandlerTest.cpp	2014-08-18 17:37:19 +0000
3751
+++ tests/handler/HandlerTest.cpp	2015-03-30 20:55:55 +0000
3752
@@ -1,5 +1,5 @@
3753
1
/*
1
/*
3755
2
 * Copyright (C) 2013 Canonical, Ltd.
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
3756
3
 *
3
 *
3757
4
 * This file is part of telephony-service.
4
 * This file is part of telephony-service.
3758
5
 *
5
 *
3759
@@ -18,19 +18,22 @@
3760
18
18
3761
19
#include <QtCore/QObject>
19
#include <QtCore/QObject>
3762
20
#include <QtTest/QtTest>
20
#include <QtTest/QtTest>
3763
21
#include "telepathytest.h"
3764
21
#include "handlercontroller.h"
22
#include "handlercontroller.h"
3765
22
#include "mockcontroller.h"
23
#include "mockcontroller.h"
3766
23
#include "approver.h"
24
#include "approver.h"
3767
25
#include "accountentry.h"
3768
26
#include "accountentryfactory.h"
3769
24
#include "telepathyhelper.h"
27
#include "telepathyhelper.h"
3770
25
28
3774
26
#define DEFAULT_TIMEOUT 15000
29
class HandlerTest : public TelepathyTest
3772
27
3773
28
class HandlerTest : public QObject
3775
29
{
30
{
3776
30
    Q_OBJECT
31
    Q_OBJECT
3777
31
32
3778
32
private Q_SLOTS:
33
private Q_SLOTS:
3779
33
    void initTestCase();
34
    void initTestCase();
3780
35
    void init();
3781
36
    void cleanup();
3782
34
    void testMakingCalls();
37
    void testMakingCalls();
3783
35
    void testHangUpCall();
38
    void testHangUpCall();
3784
36
    void testCallHold();
39
    void testCallHold();
3785
@@ -42,34 +45,51 @@
3786
42
private:
45
private:
3787
43
    void waitForCallActive(const QString &callerId);
46
    void waitForCallActive(const QString &callerId);
3788
44
    Approver *mApprover;
47
    Approver *mApprover;
3789
48
    MockController *mMockController;
3790
49
    Tp::AccountPtr mTpAccount;
3791
45
};
50
};
3792
46
51
3793
47
void HandlerTest::initTestCase()
52
void HandlerTest::initTestCase()
3794
48
{
53
{
3798
49
    QSignalSpy spy(TelepathyHelper::instance(), SIGNAL(accountReady()));
54
    initialize();
3796
50
    QTRY_COMPARE_WITH_TIMEOUT(spy.count(), 1, DEFAULT_TIMEOUT);
3797
51
    QTRY_VERIFY_WITH_TIMEOUT(TelepathyHelper::instance()->connected(), DEFAULT_TIMEOUT);
3799
52
55
3800
53
    // register the approver
56
    // register the approver
3801
54
    mApprover = new Approver(this);
57
    mApprover = new Approver(this);
3802
55
    TelepathyHelper::instance()->registerClient(mApprover, "TelephonyTestApprover");
58
    TelepathyHelper::instance()->registerClient(mApprover, "TelephonyTestApprover");
3803
56
    // Tp-qt does not set registered status to approvers
59
    // Tp-qt does not set registered status to approvers
3804
57
    QTRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
60
    QTRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(TELEPHONY_SERVICE_APPROVER));
3808
58
61
}
3809
59
    // we need to wait in order to give telepathy time to notify about the approver
62
3810
60
    QTest::qWait(3000);
63
void HandlerTest::init()
3811
64
{
3812
65
    mTpAccount = addAccount("mock", "mock", "the account");
3813
66
    QVERIFY(!mTpAccount.isNull());
3814
67
    QTRY_VERIFY(mTpAccount->isReady(Tp::Account::FeatureCore));
3815
68
3816
69
    // make sure the connection is available
3817
70
    QTRY_VERIFY(!mTpAccount->connection().isNull());
3818
71
    QTRY_COMPARE(mTpAccount->connection()->selfContact()->presence().type(), Tp::ConnectionPresenceTypeAvailable);
3819
72
3820
73
    // and create the mock controller
3821
74
    mMockController = new MockController("mock", this);
3822
75
}
3823
76
3824
77
void HandlerTest::cleanup()
3825
78
{
3826
79
    doCleanup();
3827
80
    mMockController->deleteLater();
3828
61
}
81
}
3829
62
82
3830
63
void HandlerTest::testMakingCalls()
83
void HandlerTest::testMakingCalls()
3831
64
{
84
{
3832
65
    QString callerId("1234567");
85
    QString callerId("1234567");
3834
66
    QSignalSpy callReceivedSpy(MockController::instance(), SIGNAL(callReceived(QString)));
86
    QSignalSpy callReceivedSpy(mMockController, SIGNAL(callReceived(QString)));
3835
67
    // FIXME: add support for multiple accounts
87
    // FIXME: add support for multiple accounts
3837
68
    HandlerController::instance()->startCall(callerId, TelepathyHelper::instance()->accountId());
88
    HandlerController::instance()->startCall(callerId, mTpAccount->uniqueIdentifier());
3838
69
    QTRY_COMPARE(callReceivedSpy.count(), 1);
89
    QTRY_COMPARE(callReceivedSpy.count(), 1);
3839
70
    QCOMPARE(callReceivedSpy.first().first().toString(), callerId);
90
    QCOMPARE(callReceivedSpy.first().first().toString(), callerId);
3840
71
91
3842
72
    MockController::instance()->hangupCall(callerId);
92
    mMockController->hangupCall(callerId);
3843
73
}
93
}
3844
74
94
3845
75
void HandlerTest::testHangUpCall()
95
void HandlerTest::testHangUpCall()
3846
@@ -81,7 +101,7 @@
3847
81
    properties["State"] = "incoming";
101
    properties["State"] = "incoming";
3848
82
102
3849
83
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
103
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
3851
84
    QString objectPath = MockController::instance()->placeCall(properties);
104
    QString objectPath = mMockController->placeCall(properties);
3852
85
    QVERIFY(!objectPath.isEmpty());
105
    QVERIFY(!objectPath.isEmpty());
3853
86
106
3854
87
    // wait for the channel to hit the approver
107
    // wait for the channel to hit the approver
3855
@@ -91,7 +111,7 @@
3856
91
    waitForCallActive(callerId);
111
    waitForCallActive(callerId);
3857
92
112
3858
93
    // and finally request the hangup
113
    // and finally request the hangup
3860
94
    QSignalSpy callEndedSpy(MockController::instance(), SIGNAL(callEnded(QString)));
114
    QSignalSpy callEndedSpy(mMockController, SIGNAL(callEnded(QString)));
3861
95
    HandlerController::instance()->hangUpCall(objectPath);
115
    HandlerController::instance()->hangUpCall(objectPath);
3862
96
    QTRY_COMPARE(callEndedSpy.count(), 1);
116
    QTRY_COMPARE(callEndedSpy.count(), 1);
3863
97
}
117
}
3864
@@ -105,7 +125,7 @@
3865
105
    properties["State"] = "incoming";
125
    properties["State"] = "incoming";
3866
106
126
3867
107
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
127
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
3869
108
    QString objectPath = MockController::instance()->placeCall(properties);
128
    QString objectPath = mMockController->placeCall(properties);
3870
109
    QVERIFY(!objectPath.isEmpty());
129
    QVERIFY(!objectPath.isEmpty());
3871
110
130
3872
111
    // wait for the channel to hit the approver
131
    // wait for the channel to hit the approver
3873
@@ -114,7 +134,7 @@
3874
114
134
3875
115
    waitForCallActive(callerId);
135
    waitForCallActive(callerId);
3876
116
136
3878
117
    QSignalSpy callStateSpy(MockController::instance(), SIGNAL(callStateChanged(QString,QString,QString)));
137
    QSignalSpy callStateSpy(mMockController, SIGNAL(callStateChanged(QString,QString,QString)));
3879
118
138
3880
119
    // set the call on hold
139
    // set the call on hold
3881
120
    HandlerController::instance()->setHold(objectPath, true);
140
    HandlerController::instance()->setHold(objectPath, true);
3882
@@ -127,7 +147,7 @@
3883
127
    QTRY_COMPARE(callStateSpy.count(), 1);
147
    QTRY_COMPARE(callStateSpy.count(), 1);
3884
128
    QCOMPARE(callStateSpy.first()[2].toString(), QString("active"));
148
    QCOMPARE(callStateSpy.first()[2].toString(), QString("active"));
3885
129
149
3887
130
    MockController::instance()->hangupCall(callerId);
150
    mMockController->hangupCall(callerId);
3888
131
}
151
}
3889
132
152
3890
133
void HandlerTest::testCallProperties()
153
void HandlerTest::testCallProperties()
3891
@@ -140,7 +160,7 @@
3892
140
160
3893
141
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
161
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
3894
142
    QSignalSpy handlerCallPropertiesSpy(HandlerController::instance(), SIGNAL(callPropertiesChanged(QString,QVariantMap)));
162
    QSignalSpy handlerCallPropertiesSpy(HandlerController::instance(), SIGNAL(callPropertiesChanged(QString,QVariantMap)));
3896
143
    MockController::instance()->placeCall(properties);
163
    mMockController->placeCall(properties);
3897
144
164
3898
145
    // wait for the channel to hit the approver
165
    // wait for the channel to hit the approver
3899
146
    QTRY_COMPARE(approverCallSpy.count(), 1);
166
    QTRY_COMPARE(approverCallSpy.count(), 1);
3900
@@ -183,6 +203,7 @@
3901
183
    QCOMPARE(dtmfStringFromMethod, dtmfString);
203
    QCOMPARE(dtmfStringFromMethod, dtmfString);
3902
184
204
3903
185
    HandlerController::instance()->hangUpCall(objectPath);
205
    HandlerController::instance()->hangUpCall(objectPath);
3904
206
    QTest::qWait(500);
3905
186
}
207
}
3906
187
208
3907
188
void HandlerTest::testConferenceCall()
209
void HandlerTest::testConferenceCall()
3908
@@ -196,7 +217,7 @@
3909
196
    properties["State"] = "incoming";
217
    properties["State"] = "incoming";
3910
197
218
3911
198
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
219
    QSignalSpy approverCallSpy(mApprover, SIGNAL(newCall()));
3913
199
    QString call1 = MockController::instance()->placeCall(properties);
220
    QString call1 = mMockController->placeCall(properties);
3914
200
221
3915
201
    // wait for the channel to hit the approver
222
    // wait for the channel to hit the approver
3916
202
    QTRY_COMPARE(approverCallSpy.count(), 1);
223
    QTRY_COMPARE(approverCallSpy.count(), 1);
3917
@@ -206,7 +227,7 @@
3918
206
227
3919
207
    // make a second call
228
    // make a second call
3920
208
    properties["Caller"] = callerId2;
229
    properties["Caller"] = callerId2;
3922
209
    QString call2 = MockController::instance()->placeCall(properties);
230
    QString call2 = mMockController->placeCall(properties);
3923
210
    // wait for the channel to hit the approver
231
    // wait for the channel to hit the approver
3924
211
    QTRY_COMPARE(approverCallSpy.count(), 1);
232
    QTRY_COMPARE(approverCallSpy.count(), 1);
3925
212
    mApprover->acceptCall();
233
    mApprover->acceptCall();
3926
@@ -214,27 +235,27 @@
3927
214
    waitForCallActive(callerId2);
235
    waitForCallActive(callerId2);
3928
215
236
3929
216
    // now create the conf call
237
    // now create the conf call
3931
217
    QSignalSpy conferenceCreatedSpy(MockController::instance(), SIGNAL(conferenceCreated(QString)));
238
    QSignalSpy conferenceCreatedSpy(mMockController, SIGNAL(conferenceCreated(QString)));
3932
218
    HandlerController::instance()->createConferenceCall(QStringList() << call1 << call2);
239
    HandlerController::instance()->createConferenceCall(QStringList() << call1 << call2);
3933
219
    QTRY_COMPARE(conferenceCreatedSpy.count(), 1);
240
    QTRY_COMPARE(conferenceCreatedSpy.count(), 1);
3934
220
    QString conferenceObjectPath = conferenceCreatedSpy.first().first().toString();
241
    QString conferenceObjectPath = conferenceCreatedSpy.first().first().toString();
3935
221
242
3936
222
    // now place a third call and try to merge it
243
    // now place a third call and try to merge it
3937
223
    properties["Caller"] = callerId3;
244
    properties["Caller"] = callerId3;
3939
224
    QString call3 = MockController::instance()->placeCall(properties);
245
    QString call3 = mMockController->placeCall(properties);
3940
225
    QTRY_COMPARE(approverCallSpy.count(), 1);
246
    QTRY_COMPARE(approverCallSpy.count(), 1);
3941
226
    mApprover->acceptCall();
247
    mApprover->acceptCall();
3942
227
    approverCallSpy.clear();
248
    approverCallSpy.clear();
3943
228
    waitForCallActive(callerId3);
249
    waitForCallActive(callerId3);
3944
229
250
3945
230
    // merge that call on the conference
251
    // merge that call on the conference
3947
231
    QSignalSpy channelMergedSpy(MockController::instance(), SIGNAL(channelMerged(QString)));
252
    QSignalSpy channelMergedSpy(mMockController, SIGNAL(channelMerged(QString)));
3948
232
    HandlerController::instance()->mergeCall(conferenceObjectPath, call3);
253
    HandlerController::instance()->mergeCall(conferenceObjectPath, call3);
3949
233
    QTRY_COMPARE(channelMergedSpy.count(), 1);
254
    QTRY_COMPARE(channelMergedSpy.count(), 1);
3950
234
    QCOMPARE(channelMergedSpy.first().first().toString(), call3);
255
    QCOMPARE(channelMergedSpy.first().first().toString(), call3);
3951
235
256
3952
236
    // now try to split one of the channels
257
    // now try to split one of the channels
3954
237
    QSignalSpy channelSplittedSpy(MockController::instance(), SIGNAL(channelSplitted(QString)));
258
    QSignalSpy channelSplittedSpy(mMockController, SIGNAL(channelSplitted(QString)));
3955
238
    HandlerController::instance()->splitCall(call2);
259
    HandlerController::instance()->splitCall(call2);
3956
239
    QTRY_COMPARE(channelSplittedSpy.count(), 1);
260
    QTRY_COMPARE(channelSplittedSpy.count(), 1);
3957
240
    QCOMPARE(channelSplittedSpy.first().first().toString(), call2);
261
    QCOMPARE(channelSplittedSpy.first().first().toString(), call2);
3958
@@ -244,15 +265,18 @@
3959
244
    HandlerController::instance()->hangUpCall(call1);
265
    HandlerController::instance()->hangUpCall(call1);
3960
245
    HandlerController::instance()->hangUpCall(call2);
266
    HandlerController::instance()->hangUpCall(call2);
3961
246
    HandlerController::instance()->hangUpCall(call3);
267
    HandlerController::instance()->hangUpCall(call3);
3962
268
3963
269
    // just to make sure it is all done before removing the accounts
3964
270
    QTest::qWait(500);
3965
247
}
271
}
3966
248
272
3967
249
void HandlerTest::testSendMessage()
273
void HandlerTest::testSendMessage()
3968
250
{
274
{
3969
251
    QString recipient("22222222");
275
    QString recipient("22222222");
3970
252
    QString message("Hello, world!");
276
    QString message("Hello, world!");
3972
253
    QSignalSpy messageSentSpy(MockController::instance(), SIGNAL(messageSent(QString,QVariantMap)));
277
    QSignalSpy messageSentSpy(mMockController, SIGNAL(messageSent(QString,QVariantMap)));
3973
254
    // FIXME: add support for multiple accounts
278
    // FIXME: add support for multiple accounts
3975
255
    HandlerController::instance()->sendMessage(recipient, message, TelepathyHelper::instance()->accountId());
279
    HandlerController::instance()->sendMessage(recipient, message, mTpAccount->uniqueIdentifier());
3976
256
    QTRY_COMPARE(messageSentSpy.count(), 1);
280
    QTRY_COMPARE(messageSentSpy.count(), 1);
3977
257
    QString sentMessage = messageSentSpy.first().first().toString();
281
    QString sentMessage = messageSentSpy.first().first().toString();
3978
258
    QVariantMap messageProperties = messageSentSpy.first().last().value<QVariantMap>();
282
    QVariantMap messageProperties = messageSentSpy.first().last().value<QVariantMap>();
3979
@@ -284,7 +308,7 @@
3980
284
void HandlerTest::waitForCallActive(const QString &callerId)
308
void HandlerTest::waitForCallActive(const QString &callerId)
3981
285
{
309
{
3982
286
    // wait until the call state is "accepted"
310
    // wait until the call state is "accepted"
3984
287
    QSignalSpy callStateSpy(MockController::instance(), SIGNAL(callStateChanged(QString,QString,QString)));
311
    QSignalSpy callStateSpy(mMockController, SIGNAL(callStateChanged(QString,QString,QString)));
3985
288
    QString state;
312
    QString state;
3986
289
    QString objectPath;
313
    QString objectPath;
3987
290
    QString caller;
314
    QString caller;
3988
291
315
3989
=== modified file 'tests/handler/approver.cpp'
3990
--- handler/tests/approver.cpp	2014-01-07 19:53:45 +0000
3991
+++ tests/handler/approver.cpp	2015-03-30 20:55:55 +0000
3992
@@ -115,6 +115,7 @@
3993
115
            if (dispatchOperation->possibleHandlers().contains(TELEPHONY_SERVICE_HANDLER)) {
115
            if (dispatchOperation->possibleHandlers().contains(TELEPHONY_SERVICE_HANDLER)) {
3994
116
                dispatchOperation->handleWith(TELEPHONY_SERVICE_HANDLER);
116
                dispatchOperation->handleWith(TELEPHONY_SERVICE_HANDLER);
3995
117
                mDispatchOps.removeAll(dispatchOperation);
117
                mDispatchOps.removeAll(dispatchOperation);
3996
118
                break;
3997
118
            }
119
            }
3998
119
        }
120
        }
3999
120
    }
121
    }
4000
121
122
4001
=== renamed directory 'libtelephonyservice/tests' => 'tests/libtelephonyservice'
4002
=== added file 'tests/libtelephonyservice/AccountEntryFactoryTest.cpp'
4003
--- tests/libtelephonyservice/AccountEntryFactoryTest.cpp	1970-01-01 00:00:00 +0000
4004
+++ tests/libtelephonyservice/AccountEntryFactoryTest.cpp	2015-03-30 20:55:55 +0000
4005
@@ -0,0 +1,67 @@
4006
1
/*
4007
2
 * Copyright (C) 2015 Canonical, Ltd.
4008
3
 *
4009
4
 * This file is part of telephony-service.
4010
5
 *
4011
6
 * telephony-service is free software; you can redistribute it and/or modify
4012
7
 * it under the terms of the GNU General Public License as published by
4013
8
 * the Free Software Foundation; version 3.
4014
9
 *
4015
10
 * telephony-service is distributed in the hope that it will be useful,
4016
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4017
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4018
13
 * GNU General Public License for more details.
4019
14
 *
4020
15
 * You should have received a copy of the GNU General Public License
4021
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4022
17
 */
4023
18
4024
19
#include <QtCore/QObject>
4025
20
#include <QtTest/QtTest>
4026
21
#include "telepathytest.h"
4027
22
#include "accountentry.h"
4028
23
#include "accountentryfactory.h"
4029
24
#include "ofonoaccountentry.h"
4030
25
#include "telepathyhelper.h"
4031
26
4032
27
class AccountEntryFactoryTest : public TelepathyTest
4033
28
{
4034
29
    Q_OBJECT
4035
30
4036
31
private Q_SLOTS:
4037
32
    void initTestCase();
4038
33
    void testCorrectInstancesCreated();
4039
34
    void testNullAccount();
4040
35
};
4041
36
4042
37
void AccountEntryFactoryTest::initTestCase()
4043
38
{
4044
39
    initialize();
4045
40
}
4046
41
4047
42
void AccountEntryFactoryTest::testCorrectInstancesCreated()
4048
43
{
4049
44
    Tp::AccountPtr genericTpAccount = addAccount("mock", "mock", "generic");
4050
45
    QVERIFY(!genericTpAccount.isNull());
4051
46
    AccountEntry *genericAccount = AccountEntryFactory::createEntry(genericTpAccount, this);
4052
47
    QVERIFY(genericAccount);
4053
48
    QCOMPARE(genericAccount->type(), AccountEntry::GenericAccount);
4054
49
    QVERIFY(!qobject_cast<OfonoAccountEntry*>(genericAccount));
4055
50
4056
51
    Tp::AccountPtr ofonoTpAccount = addAccount("mock", "ofono", "phone account");
4057
52
    AccountEntry *ofonoAccount = AccountEntryFactory::createEntry(ofonoTpAccount, this);
4058
53
    QVERIFY(ofonoAccount);
4059
54
    QCOMPARE(ofonoAccount->type(), AccountEntry::PhoneAccount);
4060
55
    QVERIFY(qobject_cast<OfonoAccountEntry*>(ofonoAccount));
4061
56
}
4062
57
4063
58
void AccountEntryFactoryTest::testNullAccount()
4064
59
{
4065
60
    AccountEntry *nullAccount = AccountEntryFactory::createEntry(Tp::AccountPtr(), this);
4066
61
    QVERIFY(nullAccount);
4067
62
    QVERIFY(nullAccount->accountId().isNull());
4068
63
}
4069
64
4070
65
4071
66
QTEST_MAIN(AccountEntryFactoryTest)
4072
67
#include "AccountEntryFactoryTest.moc"
4073
0
68
4074
=== added file 'tests/libtelephonyservice/AccountEntryTest.cpp'
4075
--- tests/libtelephonyservice/AccountEntryTest.cpp	1970-01-01 00:00:00 +0000
4076
+++ tests/libtelephonyservice/AccountEntryTest.cpp	2015-03-30 20:55:55 +0000
4077
@@ -0,0 +1,228 @@
4078
1
/*
4079
2
 * Copyright (C) 2015 Canonical, Ltd.
4080
3
 *
4081
4
 * This file is part of telephony-service.
4082
5
 *
4083
6
 * telephony-service is free software; you can redistribute it and/or modify
4084
7
 * it under the terms of the GNU General Public License as published by
4085
8
 * the Free Software Foundation; version 3.
4086
9
 *
4087
10
 * telephony-service is distributed in the hope that it will be useful,
4088
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4089
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4090
13
 * GNU General Public License for more details.
4091
14
 *
4092
15
 * You should have received a copy of the GNU General Public License
4093
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4094
17
 */
4095
18
4096
19
#include <QtCore/QObject>
4097
20
#include <QtTest/QtTest>
4098
21
#include "telepathytest.h"
4099
22
#include "accountentry.h"
4100
23
#include "accountentryfactory.h"
4101
24
#include "telepathyhelper.h"
4102
25
#include "mockcontroller.h"
4103
26
4104
27
class AccountEntryTest : public TelepathyTest
4105
28
{
4106
29
    Q_OBJECT
4107
30
4108
31
private Q_SLOTS:
4109
32
    void initTestCase();
4110
33
    void init();
4111
34
    void cleanup();
4112
35
    void testAccountId();
4113
36
    void testActive();
4114
37
    void testDisplayName();
4115
38
    void testStatus();
4116
39
    void testStatusMessage();
4117
40
    void testConnected();
4118
41
    void testCompareIds_data();
4119
42
    void testCompareIds();
4120
43
    void testAddressableVCardFields();
4121
44
4122
45
private:
4123
46
    AccountEntry *mAccount;
4124
47
    Tp::AccountPtr mTpAccount;
4125
48
    AccountEntry *mNullAccount;
4126
49
    MockController *mMockController;
4127
50
};
4128
51
4129
52
void AccountEntryTest::initTestCase()
4130
53
{
4131
54
    initialize();
4132
55
4133
56
    // create a null account
4134
57
    mNullAccount = AccountEntryFactory::createEntry(Tp::AccountPtr(), this);
4135
58
}
4136
59
4137
60
void AccountEntryTest::init()
4138
61
{
4139
62
    mTpAccount = addAccount("mock", "mock", "the account");
4140
63
    QVERIFY(!mTpAccount.isNull());
4141
64
    QTRY_VERIFY(mTpAccount->isReady(Tp::Account::FeatureCore));
4142
65
4143
66
    mAccount = AccountEntryFactory::createEntry(mTpAccount, this);
4144
67
    QVERIFY(mAccount);
4145
68
4146
69
    // make sure the connection is available
4147
70
    QTRY_VERIFY(!mTpAccount->connection().isNull());
4148
71
    QTRY_COMPARE(mTpAccount->connection()->selfContact()->presence().type(), Tp::ConnectionPresenceTypeAvailable);
4149
72
    QTRY_VERIFY(mAccount->connected());
4150
73
4151
74
    // and create the mock controller
4152
75
    mMockController = new MockController("mock", this);
4153
76
4154
77
    // just in case, wait some time
4155
78
    QTest::qWait(500);
4156
79
}
4157
80
4158
81
void AccountEntryTest::cleanup()
4159
82
{
4160
83
    doCleanup();
4161
84
4162
85
    mAccount->deleteLater();
4163
86
    mMockController->deleteLater();
4164
87
}
4165
88
4166
89
void AccountEntryTest::testAccountId()
4167
90
{
4168
91
    QCOMPARE(mAccount->accountId(), mTpAccount->uniqueIdentifier());
4169
92
    QVERIFY(mNullAccount->accountId().isNull());
4170
93
}
4171
94
4172
95
void AccountEntryTest::testActive()
4173
96
{
4174
97
    QSignalSpy activeChangedSpy(mAccount, SIGNAL(activeChanged()));
4175
98
4176
99
    // the mock account is enabled/connected by default, so make sure it is like that
4177
100
    QVERIFY(mAccount->active());
4178
101
4179
102
    // now set the account offline and see if the active flag changes correctly
4180
103
    mMockController->setOnline(false);
4181
104
    QTRY_VERIFY(!mAccount->active());
4182
105
    QCOMPARE(activeChangedSpy.count(), 1);
4183
106
4184
107
    // now re-enable the account and check that the entry is updated
4185
108
    activeChangedSpy.clear();
4186
109
    mMockController->setOnline(true);
4187
110
    QTRY_VERIFY(mAccount->active());
4188
111
    QCOMPARE(activeChangedSpy.count(), 1);
4189
112
4190
113
    // check that for a null account active is false
4191
114
    QVERIFY(!mNullAccount->active());
4192
115
}
4193
116
4194
117
void AccountEntryTest::testDisplayName()
4195
118
{
4196
119
    QSignalSpy displayNameChangedSpy(mAccount, SIGNAL(displayNameChanged()));
4197
120
4198
121
    // check that the value is correct already
4199
122
    QCOMPARE(mAccount->displayName(), mTpAccount->displayName());
4200
123
4201
124
    // now try to set the display in the telepathy account directly and see that the entry gets updated
4202
125
    QString newDisplayName = "some other display name";
4203
126
    mTpAccount->setDisplayName(newDisplayName);
4204
127
    QTRY_COMPARE(mAccount->displayName(), newDisplayName);
4205
128
    QCOMPARE(displayNameChangedSpy.count(), 1);
4206
129
4207
130
    // and try setting the display name in the entry itself
4208
131
    displayNameChangedSpy.clear();
4209
132
    newDisplayName = "changing again";
4210
133
    mAccount->setDisplayName(newDisplayName);
4211
134
    QTRY_COMPARE(mAccount->displayName(), newDisplayName);
4212
135
    QCOMPARE(displayNameChangedSpy.count(), 1);
4213
136
    QCOMPARE(mTpAccount->displayName(), newDisplayName);
4214
137
4215
138
    // check that for a null account the displayName is null
4216
139
    QVERIFY(mNullAccount->displayName().isNull());
4217
140
}
4218
141
4219
142
void AccountEntryTest::testStatus()
4220
143
{
4221
144
    QSignalSpy statusChangedSpy(mAccount, SIGNAL(statusChanged()));
4222
145
4223
146
    // check that the value is correct already
4224
147
    QCOMPARE(mAccount->status(), mTpAccount->connection()->selfContact()->presence().status());
4225
148
4226
149
    // and now set a new value
4227
150
    Tp::Presence presence(Tp::ConnectionPresenceTypeAway, "away", "away");
4228
151
    mTpAccount->setRequestedPresence(presence);
4229
152
4230
153
    QTRY_COMPARE(mAccount->status(), QString("away"));
4231
154
    QCOMPARE(statusChangedSpy.count(), 1);
4232
155
4233
156
    // check that for a null account the status is null
4234
157
    QVERIFY(mNullAccount->status().isNull());
4235
158
}
4236
159
4237
160
void AccountEntryTest::testStatusMessage()
4238
161
{
4239
162
    QSignalSpy statusMessageChangedSpy(mAccount, SIGNAL(statusMessageChanged()));
4240
163
4241
164
    // check that the value is correct already
4242
165
    QTRY_COMPARE(mAccount->statusMessage(), mTpAccount->connection()->selfContact()->presence().statusMessage());
4243
166
4244
167
    // and now set a new value
4245
168
    QString statusMessage("I am online");
4246
169
    Tp::Presence presence(Tp::ConnectionPresenceTypeAvailable, "available", statusMessage);
4247
170
    mTpAccount->setRequestedPresence(presence);
4248
171
4249
172
    QTRY_COMPARE(mAccount->statusMessage(), statusMessage);
4250
173
    QCOMPARE(statusMessageChangedSpy.count(), 1);
4251
174
4252
175
    // check that for a null account the displayName is null
4253
176
    QVERIFY(mNullAccount->statusMessage().isNull());
4254
177
}
4255
178
4256
179
void AccountEntryTest::testConnected()
4257
180
{
4258
181
    QSignalSpy connectedChangedSpy(mAccount, SIGNAL(connectedChanged()));
4259
182
4260
183
    // the mock account is enabled/connected by default, so make sure it is like that
4261
184
    QVERIFY(mAccount->connected());
4262
185
4263
186
    // now set the account offline and see if the active flag changes correctly
4264
187
    mMockController->setOnline(false);
4265
188
    QTRY_VERIFY(!mAccount->connected());
4266
189
    QTRY_COMPARE(connectedChangedSpy.count(), 1);
4267
190
4268
191
    // now re-enable the account and check that the entry is updated
4269
192
    connectedChangedSpy.clear();
4270
193
    mMockController->setOnline(true);
4271
194
    QTRY_VERIFY(mAccount->connected());
4272
195
    QTRY_COMPARE(connectedChangedSpy.count(), 1);
4273
196
4274
197
    // check that for a null account the displayName is null
4275
198
    QVERIFY(!mNullAccount->connected());
4276
199
}
4277
200
4278
201
void AccountEntryTest::testCompareIds_data()
4279
202
{
4280
203
    QTest::addColumn<QString>("first");
4281
204
    QTest::addColumn<QString>("second");
4282
205
    QTest::addColumn<bool>("expectedResult");
4283
206
4284
207
    QTest::newRow("identical values") << "1234567" << "1234567" << true;
4285
208
    QTest::newRow("case difference") << "TestId" << "testid" << false;
4286
209
    QTest::newRow("phone prefix") << "1234567" << "1231234567" << false;
4287
210
}
4288
211
4289
212
void AccountEntryTest::testCompareIds()
4290
213
{
4291
214
    QFETCH(QString, first);
4292
215
    QFETCH(QString, second);
4293
216
    QFETCH(bool, expectedResult);
4294
217
4295
218
    QCOMPARE(mAccount->compareIds(first, second), expectedResult);
4296
219
}
4297
220
4298
221
void AccountEntryTest::testAddressableVCardFields()
4299
222
{
4300
223
    QVERIFY(!mAccount->addressableVCardFields().isEmpty());
4301
224
    QCOMPARE(mAccount->addressableVCardFields(), mTpAccount->protocolInfo().addressableVCardFields());
4302
225
}
4303
226
4304
227
QTEST_MAIN(AccountEntryTest)
4305
228
#include "AccountEntryTest.moc"
4306
0
229
4307
=== modified file 'tests/libtelephonyservice/CMakeLists.txt'
4308
--- libtelephonyservice/tests/CMakeLists.txt	2014-07-01 16:05:21 +0000
4309
+++ tests/libtelephonyservice/CMakeLists.txt	2015-03-30 20:55:55 +0000
4310
@@ -1,44 +1,28 @@
4311
1
set(LIBTELEPHONYSERVICE_DIR ${CMAKE_SOURCE_DIR}/libtelephonyservice)
4312
1
include_directories(
2
include_directories(
4313
2
    ${CMAKE_CURRENT_BINARY_DIR}
3
    ${CMAKE_CURRENT_BINARY_DIR}
4315
3
    ${CMAKE_SOURCE_DIR}/libtelephonyservice
4
    ${LIBTELEPHONYSERVICE_DIR}
4316
5
    ${TP_QT5_INCLUDE_DIRS}
4317
6
    ${CMAKE_SOURCE_DIR}/tests/common
4318
4
    )
7
    )
4319
5
8
4320
6
add_executable(GreeterContactsTestServerExe GreeterContactsTestServer.cpp)
9
add_executable(GreeterContactsTestServerExe GreeterContactsTestServer.cpp)
4321
7
qt5_use_modules(GreeterContactsTestServerExe Core DBus)
10
qt5_use_modules(GreeterContactsTestServerExe Core DBus)
4322
8
11
4359
9
add_executable(GreeterContactsTestExe GreeterContactsTest.cpp ../greetercontacts.cpp)
12
generate_test(GreeterContactsTest USE_DBUS
4360
10
set_target_properties(GreeterContactsTestExe PROPERTIES COMPILE_DEFINITIONS "AS_BUSNAME=sessionBus;CMAKE_SOURCE_DIR=\"${CMAKE_SOURCE_DIR}\"")
13
              SOURCES GreeterContactsTest.cpp ${LIBTELEPHONYSERVICE_DIR}/greetercontacts.cpp
4361
11
qt5_use_modules(GreeterContactsTestExe Contacts Core DBus Test)
14
              QT5_MODULES Contacts Core DBus Test
4362
12
15
              ENVIRONMENT XDG_SESSION_CLASS=greeter XDG_GREETER_DATA_DIR=${CMAKE_BINARY_DIR}/Testing/Temporary
4363
13
add_test(NAME GreeterContactsTest
16
              TASKS --task env --ignore-return --task ${CMAKE_CURRENT_BINARY_DIR}/GreeterContactsTestServerExe --task-name server --ignore-return
4364
14
    COMMAND env
17
              WAIT_FOR org.freedesktop.Accounts)
4365
15
        -u LD_PRELOAD  # fakeroot's preload doesn't play well with dbus-test-runner
18
set_target_properties(GreeterContactsTest PROPERTIES COMPILE_DEFINITIONS "AS_BUSNAME=sessionBus;CMAKE_SOURCE_DIR=\"${CMAKE_SOURCE_DIR}\"")
4366
16
        -u LD_LIBRARY_PATH  # fakeroot fills this too
19
add_dependencies(GreeterContactsTest GreeterContactsTestServerExe)
4367
17
        XDG_SESSION_CLASS=greeter
20
4368
18
        XDG_GREETER_DATA_DIR=${CMAKE_BINARY_DIR}/Testing/Temporary
21
generate_test(ContactUtilsTest SOURCES ContactUtilsTest.cpp QT5_MODULES Contacts Core Test LIBRARIES telephonyservice USE_UI)
4369
19
        dbus-test-runner
22
generate_test(PhoneUtilsTest SOURCES PhoneUtilsTest.cpp LIBRARIES telephonyservice USE_UI)
4370
20
        --task ${CMAKE_CURRENT_BINARY_DIR}/GreeterContactsTestServerExe
23
4371
21
        --task-name server
24
generate_telepathy_test(AccountEntryFactoryTest SOURCES AccountEntryFactoryTest.cpp)
4372
22
        --ignore-return
25
generate_telepathy_test(AccountEntryTest SOURCES AccountEntryTest.cpp)
4373
23
        --task ${CMAKE_CURRENT_BINARY_DIR}/GreeterContactsTestExe
26
generate_telepathy_test(ChatManagerTest SOURCES ChatManagerTest.cpp)
4374
24
        --task-name test
27
generate_telepathy_test(OfonoAccountEntryTest SOURCES OfonoAccountEntryTest.cpp)
4375
25
        --wait-for org.freedesktop.Accounts
28
generate_telepathy_test(TelepathyHelperTest SOURCES TelepathyHelperTest.cpp)
4340
26
        -p -xunitxml -p -o -p ${CMAKE_BINARY_DIR}/test_GreeterContactsTest.xml
4341
27
    DEPENDENCIES GreeterContactsTestServerExe GreeterContactsTestExe
4342
28
    )
4343
29
4344
30
macro(generate_tests)
4345
31
    foreach(test ${ARGN})
4346
32
        add_executable(${test} ${test}.cpp)
4347
33
        qt5_use_modules(${test} Contacts Core DBus Qml Test)
4348
34
        target_link_libraries(${test}
4349
35
            telephonyservice
4350
36
            )
4351
37
        add_test(${test} ${CMAKE_CURRENT_BINARY_DIR}/${test} -platform offscreen -xunitxml -o ${CMAKE_BINARY_DIR}/test_${test}.xml)
4352
38
    endforeach(test)
4353
39
endmacro(generate_tests)
4354
40
4355
41
generate_tests(
4356
42
    ContactUtilsTest
4357
43
    PhoneUtilsTest
4358
44
    )
4376
45
29
4377
=== added file 'tests/libtelephonyservice/ChatManagerTest.cpp'
4378
--- tests/libtelephonyservice/ChatManagerTest.cpp	1970-01-01 00:00:00 +0000
4379
+++ tests/libtelephonyservice/ChatManagerTest.cpp	2015-03-30 20:55:55 +0000
4380
@@ -0,0 +1,177 @@
4381
1
/*
4382
2
 * Copyright (C) 2013-2015 Canonical, Ltd.
4383
3
 *
4384
4
 * This file is part of telephony-service.
4385
5
 *
4386
6
 * telephony-service is free software; you can redistribute it and/or modify
4387
7
 * it under the terms of the GNU General Public License as published by
4388
8
 * the Free Software Foundation; version 3.
4389
9
 *
4390
10
 * telephony-service is distributed in the hope that it will be useful,
4391
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4392
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4393
13
 * GNU General Public License for more details.
4394
14
 *
4395
15
 * You should have received a copy of the GNU General Public License
4396
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4397
17
 */
4398
18
4399
19
#include <QtCore/QObject>
4400
20
#include <QtTest/QtTest>
4401
21
#include "telepathytest.h"
4402
22
#include "accountentry.h"
4403
23
#include "chatmanager.h"
4404
24
#include "telepathyhelper.h"
4405
25
#include "mockcontroller.h"
4406
26
4407
27
class ChatManagerTest : public TelepathyTest
4408
28
{
4409
29
    Q_OBJECT
4410
30
4411
31
private Q_SLOTS:
4412
32
    void initTestCase();
4413
33
    void init();
4414
34
    void cleanup();
4415
35
    void testSendMessage_data();
4416
36
    void testSendMessage();
4417
37
    void testMessageReceived();
4418
38
    void testAcknowledgeMessages();
4419
39
4420
40
private:
4421
41
    Tp::AccountPtr mGenericTpAccount;
4422
42
    Tp::AccountPtr mPhoneTpAccount;
4423
43
    MockController *mGenericMockController;
4424
44
    MockController *mPhoneMockController;
4425
45
};
4426
46
4427
47
void ChatManagerTest::initTestCase()
4428
48
{
4429
49
    initialize();
4430
50
4431
51
    TelepathyHelper::instance()->registerChannelObserver();
4432
52
4433
53
    // just give telepathy some time to register the observer
4434
54
    QTest::qWait(1000);
4435
55
}
4436
56
4437
57
void ChatManagerTest::init()
4438
58
{
4439
59
    // add two accounts
4440
60
    mGenericTpAccount = addAccount("mock", "mock", "the generic account");
4441
61
    QTRY_VERIFY(!mGenericTpAccount->connection().isNull());
4442
62
4443
63
    mPhoneTpAccount = addAccount("mock", "ofono", "the phone account");
4444
64
    QTRY_VERIFY(!mPhoneTpAccount->connection().isNull());
4445
65
4446
66
    // and create the mock controller
4447
67
    mGenericMockController = new MockController("mock", this);
4448
68
    mPhoneMockController = new MockController("ofono", this);
4449
69
}
4450
70
4451
71
void ChatManagerTest::cleanup()
4452
72
{
4453
73
    // the accounts are removed in the parent class.
4454
74
    doCleanup();
4455
75
4456
76
    mGenericMockController->deleteLater();
4457
77
    mPhoneMockController->deleteLater();
4458
78
}
4459
79
4460
80
void ChatManagerTest::testSendMessage_data()
4461
81
{
4462
82
    QTest::addColumn<QStringList>("recipients");
4463
83
    QTest::addColumn<QString>("message");
4464
84
    QTest::addColumn<QString>("accountId");
4465
85
4466
86
    QTest::newRow("message via the generic account") << (QStringList() << "recipient1") << QString("Hello world") << QString("mock/mock/account0");
4467
87
    QTest::newRow("message via the phone account") << (QStringList() << "recipient2") << QString("Hello Phone World") << QString("mock/ofono/account0");
4468
88
    QTest::newRow("multiple recipients") << (QStringList() << "123" << "456" << "789") << QString("Hi friends!") << QString("mock/mock/account0");
4469
89
}
4470
90
4471
91
void ChatManagerTest::testSendMessage()
4472
92
{
4473
93
    QFETCH(QStringList, recipients);
4474
94
    QFETCH(QString, message);
4475
95
    QFETCH(QString, accountId);
4476
96
4477
97
    // just to make it easier, sort the recipients
4478
98
    qSort(recipients);
4479
99
4480
100
    MockController *controller = accountId.startsWith("mock/mock") ? mGenericMockController : mPhoneMockController;
4481
101
    QSignalSpy controllerMessageSentSpy(controller, SIGNAL(messageSent(QString,QVariantMap)));
4482
102
    QSignalSpy messageSentSpy(ChatManager::instance(), SIGNAL(messageSent(QStringList,QString)));
4483
103
4484
104
    ChatManager::instance()->sendMessage(recipients, message, accountId);
4485
105
4486
106
    QTRY_COMPARE(controllerMessageSentSpy.count(), 1);
4487
107
    QString messageText = controllerMessageSentSpy.first()[0].toString();
4488
108
    QVariantMap messageProperties = controllerMessageSentSpy.first()[1].toMap();
4489
109
    QStringList messageRecipients = messageProperties["Recipients"].toStringList();
4490
110
    qSort(messageRecipients);
4491
111
    QCOMPARE(messageText, message);
4492
112
    QCOMPARE(messageRecipients, recipients);
4493
113
4494
114
    QTRY_COMPARE(messageSentSpy.count(), 1);
4495
115
    messageRecipients = messageSentSpy.first()[0].toStringList();
4496
116
    qSort(messageRecipients);
4497
117
    messageText = messageSentSpy.first()[1].toString();
4498
118
    QCOMPARE(messageText, message);
4499
119
    QCOMPARE(messageRecipients, recipients);
4500
120
}
4501
121
4502
122
void ChatManagerTest::testMessageReceived()
4503
123
{
4504
124
    QSignalSpy messageReceivedSpy(ChatManager::instance(), SIGNAL(messageReceived(QString,QString,QDateTime,QString,bool)));
4505
125
4506
126
    QVariantMap properties;
4507
127
    properties["Sender"] = "12345";
4508
128
    properties["Recipients"] = (QStringList() << "12345");
4509
129
    QString message("Hi there");
4510
130
    mGenericMockController->placeIncomingMessage(message, properties);
4511
131
4512
132
    QTRY_COMPARE(messageReceivedSpy.count(), 1);
4513
133
    QString sender = messageReceivedSpy.first()[0].toString();
4514
134
    QString receivedMessage = messageReceivedSpy.first()[1].toString();
4515
135
    QCOMPARE(sender, properties["Sender"].toString());
4516
136
    QCOMPARE(receivedMessage, message);
4517
137
}
4518
138
4519
139
void ChatManagerTest::testAcknowledgeMessages()
4520
140
{
4521
141
    QSignalSpy messageReceivedSpy(ChatManager::instance(), SIGNAL(messageReceived(QString,QString,QDateTime,QString,bool)));
4522
142
4523
143
    QVariantMap properties;
4524
144
    properties["Sender"] = "12345";
4525
145
    properties["Recipients"] = (QStringList() << "12345");
4526
146
    QStringList messages;
4527
147
    messages << "Hi there" << "How are you" << "Always look on the bright side of life";
4528
148
    Q_FOREACH(const QString &message, messages) {
4529
149
        mGenericMockController->placeIncomingMessage(message, properties);
4530
150
        QTest::qWait(100);
4531
151
    }
4532
152
    QTRY_COMPARE(messageReceivedSpy.count(), messages.count());
4533
153
4534
154
    QStringList messageIds;
4535
155
    for (int i = 0; i < messages.count(); ++i) {
4536
156
        QString messageId = messageReceivedSpy[i][3].toString();
4537
157
        messageIds << messageId;
4538
158
    }
4539
159
4540
160
    QSignalSpy messageReadSpy(mGenericMockController, SIGNAL(messageRead(QString)));
4541
161
    Q_FOREACH(const QString &messageId, messageIds) {
4542
162
        ChatManager::instance()->acknowledgeMessage(properties["Recipients"].toStringList(), messageId, "mock/mock/account0");
4543
163
    }
4544
164
4545
165
    QTRY_COMPARE(messageReadSpy.count(), messageIds.count());
4546
166
    QStringList receivedIds;
4547
167
    for (int i = 0; i < messageReadSpy.count(); ++i) {
4548
168
        receivedIds << messageReadSpy[i][0].toString();
4549
169
    }
4550
170
4551
171
    qSort(receivedIds);
4552
172
    qSort(messageIds);
4553
173
    QCOMPARE(receivedIds, messageIds);
4554
174
}
4555
175
4556
176
QTEST_MAIN(ChatManagerTest)
4557
177
#include "ChatManagerTest.moc"
4558
0
178
4559
=== modified file 'tests/libtelephonyservice/ContactUtilsTest.cpp'
4560
--- libtelephonyservice/tests/ContactUtilsTest.cpp	2013-08-13 22:25:18 +0000
4561
+++ tests/libtelephonyservice/ContactUtilsTest.cpp	2015-03-30 20:55:55 +0000
4562
@@ -34,8 +34,6 @@
4563
34
    void testSharedManagerCreation();
34
    void testSharedManagerCreation();
4564
35
};
35
};
4565
36
36
4566
37
4567
38
4568
39
void ContactUtilsTest::testFormatContactName_data()
37
void ContactUtilsTest::testFormatContactName_data()
4569
40
{
38
{
4570
41
    QTest::addColumn<QString>("firstName");
39
    QTest::addColumn<QString>("firstName");
4571
42
40
4572
=== modified file 'tests/libtelephonyservice/GreeterContactsTest.cpp'
4573
--- libtelephonyservice/tests/GreeterContactsTest.cpp	2014-07-01 16:10:33 +0000
4574
+++ tests/libtelephonyservice/GreeterContactsTest.cpp	2015-03-30 20:55:55 +0000
4575
@@ -281,8 +281,7 @@
4576
281
                         "com.canonical.TelephonyServiceApprover",
281
                         "com.canonical.TelephonyServiceApprover",
4577
282
                         QDBusConnection::sessionBus());
282
                         QDBusConnection::sessionBus());
4578
283
    QSignalSpy spy(&iface, SIGNAL(InitialQueriesDone()));
283
    QSignalSpy spy(&iface, SIGNAL(InitialQueriesDone()));
4581
284
    QVERIFY(spy.wait());
284
    QTRY_COMPARE(spy.count(), 1);
4580
285
    QCOMPARE(spy.count(), 1);
4582
286
}
285
}
4583
287
286
4584
288
void GreeterContactsTest::makeGreeterContacts()
287
void GreeterContactsTest::makeGreeterContacts()
4585
@@ -293,8 +292,7 @@
4586
293
292
4587
294
void GreeterContactsTest::waitForUpdatedSignal(bool convertedPath)
293
void GreeterContactsTest::waitForUpdatedSignal(bool convertedPath)
4588
295
{
294
{
4591
296
    QVERIFY(mSpy->wait());
295
    QTRY_COMPARE(mSpy->count(), 1);
4590
297
    QCOMPARE(mSpy->count(), 1);
4592
298
296
4593
299
    QList<QVariant> arguments = mSpy->takeFirst();
297
    QList<QVariant> arguments = mSpy->takeFirst();
4594
300
    QContact expectedContact = makeTestContact(convertedPath);
298
    QContact expectedContact = makeTestContact(convertedPath);
4595
301
299
4596
=== modified file 'tests/libtelephonyservice/GreeterContactsTestServer.cpp'
4597
--- libtelephonyservice/tests/GreeterContactsTestServer.cpp	2014-07-01 16:05:21 +0000
4598
+++ tests/libtelephonyservice/GreeterContactsTestServer.cpp	2015-03-30 20:55:55 +0000
4599
@@ -24,7 +24,6 @@
4600
24
#include <QStringList>
24
#include <QStringList>
4601
25
#include <unistd.h>
25
#include <unistd.h>
4602
26
26
4603
27
4604
28
#include <QDebug>
27
#include <QDebug>
4605
29
bool listGetCalled = false;
28
bool listGetCalled = false;
4606
30
bool userGetCalled = false;
29
bool userGetCalled = false;
4607
31
30
4608
=== added file 'tests/libtelephonyservice/OfonoAccountEntryTest.cpp'
4609
--- tests/libtelephonyservice/OfonoAccountEntryTest.cpp	1970-01-01 00:00:00 +0000
4610
+++ tests/libtelephonyservice/OfonoAccountEntryTest.cpp	2015-03-30 20:55:55 +0000
4611
@@ -0,0 +1,273 @@
4612
1
/*
4613
2
 * Copyright (C) 2015 Canonical, Ltd.
4614
3
 *
4615
4
 * This file is part of telephony-service.
4616
5
 *
4617
6
 * telephony-service is free software; you can redistribute it and/or modify
4618
7
 * it under the terms of the GNU General Public License as published by
4619
8
 * the Free Software Foundation; version 3.
4620
9
 *
4621
10
 * telephony-service is distributed in the hope that it will be useful,
4622
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4623
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4624
13
 * GNU General Public License for more details.
4625
14
 *
4626
15
 * You should have received a copy of the GNU General Public License
4627
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4628
17
 */
4629
18
4630
19
#include <QtCore/QObject>
4631
20
#include <QtTest/QtTest>
4632
21
#include "telepathytest.h"
4633
22
#include "ofonoaccountentry.h"
4634
23
#include "accountentryfactory.h"
4635
24
#include "mockcontroller.h"
4636
25
4637
26
class OfonoAccountEntryTest : public TelepathyTest
4638
27
{
4639
28
    Q_OBJECT
4640
29
4641
30
private Q_SLOTS:
4642
31
    void initTestCase();
4643
32
    void init();
4644
33
    void cleanup();
4645
34
    void testAccountType();
4646
35
    void testConnected();
4647
36
    void testCompareIds_data();
4648
37
    void testCompareIds();
4649
38
    void testEmergencyNumbers();
4650
39
    void testSerial();
4651
40
    void testVoicemailIndicator();
4652
41
    void testVoicemailNumber();
4653
42
    void testVoicemailCount();
4654
43
    void testSimLocked();
4655
44
    void testEmergencyCallsAvailable_data();
4656
45
    void testEmergencyCallsAvailable();
4657
46
    void testNetworkName();
4658
47
    void testAddressableVCardFields();
4659
48
4660
49
private:
4661
50
    OfonoAccountEntry *mAccount;
4662
51
    Tp::AccountPtr mTpAccount;
4663
52
    MockController *mMockController;
4664
53
};
4665
54
4666
55
void OfonoAccountEntryTest::initTestCase()
4667
56
{
4668
57
    initialize();
4669
58
}
4670
59
4671
60
void OfonoAccountEntryTest::init()
4672
61
{
4673
62
    mTpAccount = addAccount("mock", "ofono", "phone account");
4674
63
    QVERIFY(!mTpAccount.isNull());
4675
64
    QTRY_VERIFY(mTpAccount->isReady(Tp::Account::FeatureCore));
4676
65
4677
66
    mAccount = qobject_cast<OfonoAccountEntry*>(AccountEntryFactory::createEntry(mTpAccount, this));
4678
67
    QVERIFY(mAccount);
4679
68
4680
69
    // make sure the connection is available
4681
70
    QTRY_VERIFY(!mTpAccount->connection().isNull());
4682
71
    QTRY_COMPARE(mTpAccount->connection()->selfContact()->presence().type(), Tp::ConnectionPresenceTypeAvailable);
4683
72
    QTRY_VERIFY(mAccount->connected());
4684
73
4685
74
    // create the mock controller
4686
75
    mMockController = new MockController("ofono", this);
4687
76
4688
77
    // just in case, wait some time
4689
78
    QTest::qWait(500);
4690
79
}
4691
80
4692
81
void OfonoAccountEntryTest::cleanup()
4693
82
{
4694
83
    doCleanup();
4695
84
    mAccount->deleteLater();
4696
85
    mMockController->deleteLater();
4697
86
}
4698
87
4699
88
void OfonoAccountEntryTest::testAccountType()
4700
89
{
4701
90
    QCOMPARE(mAccount->type(), AccountEntry::PhoneAccount);
4702
91
}
4703
92
4704
93
void OfonoAccountEntryTest::testConnected()
4705
94
{
4706
95
    // the mock account is enabled/connected by default, so make sure it is like that
4707
96
    QTRY_VERIFY(mAccount->connected());
4708
97
4709
98
    // right now the ofono account connection status behave exactly like the generic class,
4710
99
    // but as the code path is different, test it again
4711
100
    QSignalSpy connectedChangedSpy(mAccount, SIGNAL(connectedChanged()));
4712
101
4713
102
    // now set the account offline and see if the active flag changes correctly
4714
103
    mMockController->setOnline(false);
4715
104
    QTRY_VERIFY(!mAccount->connected());
4716
105
    QCOMPARE(connectedChangedSpy.count(), 1);
4717
106
4718
107
    // now re-enable the account and check that the entry is updated
4719
108
    connectedChangedSpy.clear();
4720
109
    mMockController->setOnline(true);
4721
110
    QTRY_VERIFY(mAccount->connected());
4722
111
    QCOMPARE(connectedChangedSpy.count(), 1);
4723
112
}
4724
113
4725
114
void OfonoAccountEntryTest::testCompareIds_data()
4726
115
{
4727
116
    QTest::addColumn<QString>("first");
4728
117
    QTest::addColumn<QString>("second");
4729
118
    QTest::addColumn<bool>("expectedResult");
4730
119
4731
120
    QTest::newRow("identical values") << "1234567" << "1234567" << true;
4732
121
    QTest::newRow("case difference") << "TestId" << "testid" << false;
4733
122
    QTest::newRow("phone prefix") << "1234567" << "1231234567" << true;
4734
123
}
4735
124
4736
125
void OfonoAccountEntryTest::testCompareIds()
4737
126
{
4738
127
    QFETCH(QString, first);
4739
128
    QFETCH(QString, second);
4740
129
    QFETCH(bool, expectedResult);
4741
130
4742
131
    QCOMPARE(mAccount->compareIds(first, second), expectedResult);
4743
132
}
4744
133
4745
134
void OfonoAccountEntryTest::testEmergencyNumbers()
4746
135
{
4747
136
    QSignalSpy emergencyNumbersChangedSpy(mAccount, SIGNAL(emergencyNumbersChanged()));
4748
137
4749
138
    // check that the list is not empty at startup
4750
139
    QVERIFY(!mAccount->emergencyNumbers().isEmpty());
4751
140
4752
141
    QStringList numbers;
4753
142
    numbers << "111" << "190" << "911";
4754
143
    qSort(numbers);
4755
144
    mMockController->setEmergencyNumbers(numbers);
4756
145
    QTRY_COMPARE(emergencyNumbersChangedSpy.count(), 1);
4757
146
4758
147
    QStringList emergencyNumbers = mAccount->emergencyNumbers();
4759
148
    qSort(emergencyNumbers);
4760
149
4761
150
    QCOMPARE(emergencyNumbers, numbers);
4762
151
}
4763
152
4764
153
void OfonoAccountEntryTest::testSerial()
4765
154
{
4766
155
    QTRY_COMPARE(mAccount->serial(), mMockController->serial());
4767
156
}
4768
157
4769
158
void OfonoAccountEntryTest::testVoicemailIndicator()
4770
159
{
4771
160
    // voicemail indicator is off by default on the mock CM
4772
161
    QVERIFY(!mAccount->voicemailIndicator());
4773
162
4774
163
    QSignalSpy voiceMailIndicatorSpy(mAccount, SIGNAL(voicemailIndicatorChanged()));
4775
164
4776
165
    // set to true
4777
166
    mMockController->setVoicemailIndicator(true);
4778
167
    QTRY_COMPARE(voiceMailIndicatorSpy.count(), 1);
4779
168
    QVERIFY(mAccount->voicemailIndicator());
4780
169
4781
170
    // and set back to false
4782
171
    voiceMailIndicatorSpy.clear();
4783
172
    mMockController->setVoicemailIndicator(false);
4784
173
    QTRY_COMPARE(voiceMailIndicatorSpy.count(), 1);
4785
174
    QVERIFY(!mAccount->voicemailIndicator());
4786
175
}
4787
176
4788
177
void OfonoAccountEntryTest::testVoicemailNumber()
4789
178
{
4790
179
    QSignalSpy voicemailNumberSpy(mAccount, SIGNAL(voicemailNumberChanged()));
4791
180
4792
181
    // check that the number is not empty at startup
4793
182
    QVERIFY(!mAccount->voicemailNumber().isEmpty());
4794
183
4795
184
    // try changing the number
4796
185
    QString number("12345");
4797
186
    mMockController->setVoicemailNumber(number);
4798
187
    QTRY_COMPARE(voicemailNumberSpy.count(), 1);
4799
188
    QCOMPARE(mAccount->voicemailNumber(), number);
4800
189
}
4801
190
4802
191
void OfonoAccountEntryTest::testVoicemailCount()
4803
192
{
4804
193
    QSignalSpy voicemailCountSpy(mAccount, SIGNAL(voicemailCountChanged()));
4805
194
4806
195
    // check that the count is zero at startup
4807
196
    QCOMPARE((int)mAccount->voicemailCount(), 0);
4808
197
4809
198
    // set it to a bigger value
4810
199
    int count = 10;
4811
200
    mMockController->setVoicemailCount(count);
4812
201
    QTRY_COMPARE(voicemailCountSpy.count(), 1);
4813
202
    QCOMPARE((int)mAccount->voicemailCount(), count);
4814
203
4815
204
    // and back to zero
4816
205
    voicemailCountSpy.clear();
4817
206
    mMockController->setVoicemailCount(0);
4818
207
    QTRY_COMPARE(voicemailCountSpy.count(), 1);
4819
208
    QCOMPARE((int)mAccount->voicemailCount(), 0);
4820
209
}
4821
210
4822
211
void OfonoAccountEntryTest::testSimLocked()
4823
212
{
4824
213
    QSignalSpy simLockedSpy(mAccount, SIGNAL(simLockedChanged()));
4825
214
4826
215
    // check that it is not locked by default
4827
216
    QVERIFY(!mAccount->simLocked());
4828
217
4829
218
    // now try to set the status to simlocked
4830
219
    mMockController->setPresence("simlocked", "simlocked");
4831
220
    QTRY_COMPARE(simLockedSpy.count(), 1);
4832
221
    QVERIFY(mAccount->simLocked());
4833
222
}
4834
223
4835
224
void OfonoAccountEntryTest::testEmergencyCallsAvailable_data()
4836
225
{
4837
226
    QTest::addColumn<QString>("status");
4838
227
    QTest::addColumn<bool>("available");
4839
228
4840
229
    QTest::newRow("available") << "available" << true;
4841
230
    QTest::newRow("away") << "away" << true;
4842
231
    QTest::newRow("simlocked") << "simlocked" << true;
4843
232
    QTest::newRow("flightmode") << "flightmode" << false;
4844
233
    QTest::newRow("nosim") << "nosim" << true;
4845
234
    QTest::newRow("nomodem") << "nomodem" << false;
4846
235
    QTest::newRow("registered") << "registered" << true;
4847
236
    QTest::newRow("roaming") << "roaming" << true;
4848
237
    QTest::newRow("unregistered") << "unregistered" << true;
4849
238
    QTest::newRow("denied") << "denied" << true;
4850
239
    QTest::newRow("unknown") << "unknown" << true;
4851
240
    QTest::newRow("searching") << "searching" << true;
4852
241
}
4853
242
4854
243
void OfonoAccountEntryTest::testEmergencyCallsAvailable()
4855
244
{
4856
245
    QFETCH(QString, status);
4857
246
    QFETCH(bool, available);
4858
247
4859
248
    mMockController->setPresence(status, "");
4860
249
    QTRY_COMPARE(mAccount->status(), status);
4861
250
    QCOMPARE(mAccount->emergencyCallsAvailable(), available);
4862
251
}
4863
252
4864
253
void OfonoAccountEntryTest::testNetworkName()
4865
254
{
4866
255
    QSignalSpy networkNameChangedSpy(mAccount, SIGNAL(statusMessageChanged()));
4867
256
4868
257
    // set the value
4869
258
    QString statusMessage("SomeNetwork");
4870
259
    Tp::Presence presence(Tp::ConnectionPresenceTypeAvailable, "available", statusMessage);
4871
260
    mTpAccount->setRequestedPresence(presence);
4872
261
4873
262
    QTRY_COMPARE(mAccount->networkName(), statusMessage);
4874
263
    QCOMPARE(networkNameChangedSpy.count(), 1);
4875
264
}
4876
265
4877
266
void OfonoAccountEntryTest::testAddressableVCardFields()
4878
267
{
4879
268
    QVERIFY(!mAccount->addressableVCardFields().isEmpty());
4880
269
    QCOMPARE(mAccount->addressableVCardFields(), mTpAccount->protocolInfo().addressableVCardFields());
4881
270
}
4882
271
4883
272
QTEST_MAIN(OfonoAccountEntryTest)
4884
273
#include "OfonoAccountEntryTest.moc"
4885
0
274
4886
=== added file 'tests/libtelephonyservice/TelepathyHelperTest.cpp'
4887
--- tests/libtelephonyservice/TelepathyHelperTest.cpp	1970-01-01 00:00:00 +0000
4888
+++ tests/libtelephonyservice/TelepathyHelperTest.cpp	2015-03-30 20:55:55 +0000
4889
@@ -0,0 +1,286 @@
4890
1
/*
4891
2
 * Copyright (C) 2015 Canonical, Ltd.
4892
3
 *
4893
4
 * This file is part of telephony-service.
4894
5
 *
4895
6
 * telephony-service is free software; you can redistribute it and/or modify
4896
7
 * it under the terms of the GNU General Public License as published by
4897
8
 * the Free Software Foundation; version 3.
4898
9
 *
4899
10
 * telephony-service is distributed in the hope that it will be useful,
4900
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
4901
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4902
13
 * GNU General Public License for more details.
4903
14
 *
4904
15
 * You should have received a copy of the GNU General Public License
4905
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
4906
17
 */
4907
18
4908
19
#include <QtCore/QObject>
4909
20
#include <QtTest/QtTest>
4910
21
#include <TelepathyQt/PendingAccount>
4911
22
#include <TelepathyQt/PendingOperation>
4912
23
#include <TelepathyQt/Account>
4913
24
#include "telepathytest.h"
4914
25
#include "accountentry.h"
4915
26
#include "accountentryfactory.h"
4916
27
#include "telepathyhelper.h"
4917
28
#include "mockcontroller.h"
4918
29
4919
30
class TelepathyHelperTest : public TelepathyTest
4920
31
{
4921
32
    Q_OBJECT
4922
33
4923
34
private Q_SLOTS:
4924
35
    void initTestCase();
4925
36
    void init();
4926
37
    void cleanup();
4927
38
    void testConnected();
4928
39
    void testAccounts();
4929
40
    void testAccountSorting();
4930
41
    void testAccountIds();
4931
42
    void testActiveAccounts();
4932
43
    void testAccountForId();
4933
44
    void testAccountForConnection();
4934
45
    void testEmergencyCallsAvailable();
4935
46
4936
47
private:
4937
48
    Tp::AccountPtr mGenericTpAccount;
4938
49
    Tp::AccountPtr mPhoneTpAccount;
4939
50
    MockController *mGenericController;
4940
51
    MockController *mPhoneController;
4941
52
};
4942
53
4943
54
void TelepathyHelperTest::initTestCase()
4944
55
{
4945
56
    initialize();
4946
57
}
4947
58
4948
59
void TelepathyHelperTest::init()
4949
60
{
4950
61
    // add two accounts
4951
62
    mGenericTpAccount = addAccount("mock", "mock", "the generic account");
4952
63
    QTRY_VERIFY(!mGenericTpAccount->connection().isNull());
4953
64
4954
65
    mPhoneTpAccount = addAccount("mock", "ofono", "the phone account");
4955
66
    QTRY_VERIFY(!mPhoneTpAccount->connection().isNull());
4956
67
4957
68
    // and create the mock controller
4958
69
    mGenericController = new MockController("mock", this);
4959
70
    mPhoneController = new MockController("ofono", this);
4960
71
}
4961
72
4962
73
void TelepathyHelperTest::cleanup()
4963
74
{
4964
75
    // the accounts are removed in the parent class.
4965
76
    doCleanup();
4966
77
4967
78
    mGenericController->deleteLater();
4968
79
    mPhoneController->deleteLater();
4969
80
}
4970
81
4971
82
void TelepathyHelperTest::testConnected()
4972
83
{
4973
84
    QSignalSpy connectedChangedSpy(TelepathyHelper::instance(), SIGNAL(connectedChanged()));
4974
85
4975
86
    // check that the default status is connected (always true for mock accounts)
4976
87
    QVERIFY(TelepathyHelper::instance()->connected());
4977
88
4978
89
    // set one of the accounts offline and check that the connected status stays true
4979
90
    mGenericController->setOnline(false);
4980
91
    QTest::qWait(1000);
4981
92
    QCOMPARE(connectedChangedSpy.count(), 0);
4982
93
    QVERIFY(TelepathyHelper::instance()->connected());
4983
94
4984
95
    // and set the other account as offline too. This time connected needs to change to false
4985
96
    mPhoneController->setOnline(false);
4986
97
    QTRY_COMPARE(connectedChangedSpy.count(), 1);
4987
98
    QVERIFY(!TelepathyHelper::instance()->connected());
4988
99
4989
100
    // now set one of the accounts back online
4990
101
    connectedChangedSpy.clear();
4991
102
    mPhoneController->setOnline(true);
4992
103
    QTRY_COMPARE(connectedChangedSpy.count(), 1);
4993
104
    QVERIFY(TelepathyHelper::instance()->connected());
4994
105
4995
106
    // and the other one just in case
4996
107
    connectedChangedSpy.clear();
4997
108
    mGenericController->setOnline(true);
4998
109
    QTest::qWait(1000);
4999
110
    QCOMPARE(connectedChangedSpy.count(), 0);
5000
111
    QVERIFY(TelepathyHelper::instance()->connected());
Status:	Merged
Approved by:	Tiago Salem Herrmann on 2015-03-30
Approved revision:	1078
Merged at revision:	1046
Proposed branch:	lp:~boiko/telephony-service/non_phone_accounts_tests
Merge into:	lp:telephony-service
Prerequisite:	lp:~boiko/telephony-service/support_non_phone_accounts
Diff against target:	5175 lines (+3357/-703) 63 files modified .bzrignore (+9/-6) CMakeLists.txt (+29/-19) Ubuntu/Telephony/CMakeLists.txt (+2/-1) Ubuntu/Telephony/contactwatcher.cpp (+4/-0) approver/CMakeLists.txt (+2/-0) cmake/modules/GenerateTest.cmake (+133/-0) handler/CMakeLists.txt (+2/-6) handler/handler.cpp (+1/-0) handler/tests/dbus-test-wrapper.sh.in (+0/-35) handler/tests/telepathyhelper.cpp (+0/-279) handler/tests/telepathyhelper.h (+0/-95) indicator/CMakeLists.txt (+2/-0) libtelephonyservice/CMakeLists.txt (+1/-1) libtelephonyservice/accountentry.cpp (+8/-10) libtelephonyservice/accountentryfactory.cpp (+1/-5) libtelephonyservice/accountentryfactory.h (+0/-2) libtelephonyservice/channelobserver.cpp (+1/-0) libtelephonyservice/chatmanager.cpp (+7/-2) libtelephonyservice/chatmanager.h (+2/-2) libtelephonyservice/ofonoaccountentry.cpp (+0/-1) libtelephonyservice/telepathyhelper.cpp (+11/-5) libtelephonyservice/telepathyhelper.h (+1/-0) tests/CMakeLists.txt (+6/-0) tests/Ubuntu.Telephony/CMakeLists.txt (+13/-29) tests/Ubuntu.Telephony/ContactWatcherTest.cpp (+5/-0) tests/common/CMakeLists.txt (+14/-0) tests/common/dbus-services/CMakeLists.txt (+9/-0) tests/common/dbus-session.conf.in (+42/-0) tests/common/mock/CMakeLists.txt (+4/-1) tests/common/mock/MockConnection.xml (+60/-0) tests/common/mock/callchannel.cpp (+1/-1) tests/common/mock/connection.cpp (+215/-50) tests/common/mock/connection.h (+41/-4) tests/common/mock/emergencymodeiface.cpp (+133/-0) tests/common/mock/emergencymodeiface.h (+121/-0) tests/common/mock/main.cpp (+7/-0) tests/common/mock/mockconnectiondbus.cpp (+52/-2) tests/common/mock/mockconnectiondbus.h (+19/-0) tests/common/mock/protocol.cpp (+13/-0) tests/common/mock/protocol.h (+1/-0) tests/common/mock/speakeriface.h (+5/-4) tests/common/mock/textchannel.cpp (+70/-8) tests/common/mock/textchannel.h (+10/-2) tests/common/mock/ussdiface.cpp (+312/-0) tests/common/mock/ussdiface.h (+244/-0) tests/common/mock/voicemailiface.cpp (+202/-0) tests/common/mock/voicemailiface.h (+150/-0) tests/common/mockcontroller.cpp (+68/-21) tests/common/mockcontroller.h (+19/-2) tests/common/telepathytest.cpp (+140/-0) tests/common/telepathytest.h (+54/-0) tests/handler/CMakeLists.txt (+4/-38) tests/handler/HandlerTest.cpp (+52/-28) tests/handler/approver.cpp (+1/-0) tests/libtelephonyservice/AccountEntryFactoryTest.cpp (+67/-0) tests/libtelephonyservice/AccountEntryTest.cpp (+228/-0) tests/libtelephonyservice/CMakeLists.txt (+21/-37) tests/libtelephonyservice/ChatManagerTest.cpp (+177/-0) tests/libtelephonyservice/ContactUtilsTest.cpp (+0/-2) tests/libtelephonyservice/GreeterContactsTest.cpp (+2/-4) tests/libtelephonyservice/GreeterContactsTestServer.cpp (+0/-1) tests/libtelephonyservice/OfonoAccountEntryTest.cpp (+273/-0) tests/libtelephonyservice/TelepathyHelperTest.cpp (+286/-0)
To merge this branch:	bzr merge lp:~boiko/telephony-service/non_phone_accounts_tests
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Tiago Salem Herrmann (community)		2015-03-10	Approve on 2015-03-30
PS Jenkins bot	continuous-integration		Needs Fixing on 2015-03-30
Review via email: mp+252522@code.launchpad.net