1
=== modified file '3rd_party/CMakeLists.txt'
2
--- 3rd_party/CMakeLists.txt	2013-03-21 03:32:59 +0000
3
+++ 3rd_party/CMakeLists.txt	2013-04-03 18:49:21 +0000
4
@@ -28,10 +28,8 @@
5
28
  add_subdirectory(android-fbtype)
28
  add_subdirectory(android-fbtype)
6
29
endif()
29
endif()
7
30
30
12
31
if (NOT MIR_DISABLE_INPUT)
31
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/android-deps)
13
32
  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/android-deps)
32
add_subdirectory(android-input)
10
33
  add_subdirectory(android-input)
11
34
endif()
14
35
33
15
36
set(MIR_ANDROID_INCLUDE_DIRECTORIES ${MIR_ANDROID_INCLUDE_DIRECTORIES} PARENT_SCOPE)
34
set(MIR_ANDROID_INCLUDE_DIRECTORIES ${MIR_ANDROID_INCLUDE_DIRECTORIES} PARENT_SCOPE)
16
37
set(
35
set(
17
@@ -39,9 +37,7 @@
18
39
  ${MIR_ANDROID_INPUT_COMPILE_FLAGS}
37
  ${MIR_ANDROID_INPUT_COMPILE_FLAGS}
19
40
  PARENT_SCOPE)
38
  PARENT_SCOPE)
20
41
  
39
  
21
42
if (NOT MIR_DISABLE_INPUT)
22
43
target_link_libraries(
40
target_link_libraries(
23
44
  3rd_party
41
  3rd_party
24
45
42
25
46
  android-input)
43
  android-input)
26
47
endif()
27
48
44
28
=== modified file '3rd_party/android-deps/std/SortedVector.h'
29
--- 3rd_party/android-deps/std/SortedVector.h	2013-03-13 04:54:15 +0000
30
+++ 3rd_party/android-deps/std/SortedVector.h	2013-04-03 18:49:21 +0000
31
@@ -133,7 +133,7 @@
32
133
    ssize_t remove(const ValueType& item)
133
    ssize_t remove(const ValueType& item)
33
134
    {
134
    {
34
135
        auto remove_pos = lower_bound(begin(), end(), item);
135
        auto remove_pos = lower_bound(begin(), end(), item);
36
136
        if (*remove_pos == item)
136
        if (remove_pos != end() && *remove_pos == item)
37
137
        {
137
        {
38
138
            auto removed_at = erase(remove_pos);
138
            auto removed_at = erase(remove_pos);
39
139
            return distance(begin(), removed_at);
139
            return distance(begin(), removed_at);
40
140
140
41
=== modified file '3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h'
42
--- 3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h	2013-03-13 04:54:15 +0000
43
+++ 3rd_party/android-input/android/frameworks/base/include/androidfw/InputTransport.h	2013-04-03 18:49:21 +0000
44
@@ -43,6 +43,8 @@
45
43
 * Intermediate representation used to send input events and related signals.
43
 * Intermediate representation used to send input events and related signals.
46
44
 */
44
 */
47
45
struct InputMessage {
45
struct InputMessage {
48
46
    InputMessage();
49
47
50
46
    enum {
48
    enum {
51
47
        TYPE_KEY = 1,
49
        TYPE_KEY = 1,
52
48
        TYPE_MOTION = 2,
50
        TYPE_MOTION = 2,
53
49
51
54
=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp'
55
--- 3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp	2013-02-11 11:51:22 +0000
56
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputTransport.cpp	2013-04-03 18:49:21 +0000
57
@@ -63,6 +63,11 @@
58
63
63
59
64
// --- InputMessage ---
64
// --- InputMessage ---
60
65
65
61
66
InputMessage::InputMessage()
62
67
{
63
68
    memset(this, 0, sizeof(InputMessage));
64
69
}
65
70
66
66
bool InputMessage::isValid(size_t actualSize) const {
71
bool InputMessage::isValid(size_t actualSize) const {
67
67
    if (size() == actualSize) {
72
    if (size() == actualSize) {
68
68
        switch (header.type) {
73
        switch (header.type) {
69
69
74
70
=== modified file 'CMakeLists.txt'
71
--- CMakeLists.txt	2013-03-28 14:20:06 +0000
72
+++ CMakeLists.txt	2013-04-03 18:49:21 +0000
73
@@ -103,13 +103,6 @@
74
103
  "graphics backend to build (options are 'gbm' or 'android')"
103
  "graphics backend to build (options are 'gbm' or 'android')"
75
104
)
104
)
76
105
105
77
106
set (MIR_DISABLE_INPUT
78
107
  false
79
108
  CACHE
80
109
  BOOL
81
110
  "Don't build the input subsystem"
82
111
)
83
112
84
113
set (MIR_INPUT_USE_ANDROID_TYPES
106
set (MIR_INPUT_USE_ANDROID_TYPES
85
114
  false
107
  false
86
115
  CACHE
108
  CACHE
87
116
109
88
=== modified file 'cross-compile-chroot.sh'
89
--- cross-compile-chroot.sh	2013-03-26 15:55:51 +0000
90
+++ cross-compile-chroot.sh	2013-04-03 18:49:21 +0000
91
@@ -26,7 +26,6 @@
92
26
      -DBoost_COMPILER=-gcc \
26
      -DBoost_COMPILER=-gcc \
93
27
      -DMIR_ENABLE_DEATH_TESTS=NO \
27
      -DMIR_ENABLE_DEATH_TESTS=NO \
94
28
      -DMIR_PLATFORM=android \
28
      -DMIR_PLATFORM=android \
95
29
      -DMIR_DISABLE_INPUT=true \
96
30
      .. 
29
      .. 
97
31
30
98
32
    cmake --build .
31
    cmake --build .
99
33
32
100
=== modified file 'debian/rules'
101
--- debian/rules	2013-03-13 04:54:15 +0000
102
+++ debian/rules	2013-04-03 18:49:21 +0000
103
@@ -15,7 +15,6 @@
104
15
15
105
16
COMMON_CONFIGURE_OPTIONS = \
16
COMMON_CONFIGURE_OPTIONS = \
106
17
  -DMIR_DISABLE_EPOLL_REACTOR=YES \
17
  -DMIR_DISABLE_EPOLL_REACTOR=YES \
107
18
  -DMIR_DISABLE_INPUT=YES \
108
19
  -DBUILD_DOXYGEN=YES
18
  -DBUILD_DOXYGEN=YES
109
20
19
110
21
# We need to rely on the select-based reactor to fix the ppa builds.
20
# We need to rely on the select-based reactor to fix the ppa builds.
111
22
21
112
=== modified file 'doc/building_source_for_android.md'
113
--- doc/building_source_for_android.md	2013-03-26 16:30:53 +0000
114
+++ doc/building_source_for_android.md	2013-04-03 18:49:21 +0000
115
@@ -42,7 +42,7 @@
116
42
42
117
43
       $ bzr branch lp:mir
43
       $ bzr branch lp:mir
118
44
       $ mkdir mir/build; cd mir/build
44
       $ mkdir mir/build; cd mir/build
120
45
       $ cmake -DBoost_COMPILER=-gcc -DMIR_ENABLE_DEATH_TESTS=NO -DMIR_PLATFORM=android -DMIR_DISABLE_INPUT=yes ..
45
       $ cmake -DBoost_COMPILER=-gcc -DMIR_ENABLE_DEATH_TESTS=NO -DMIR_PLATFORM=android ..
121
46
46
122
47
Cross Compile
47
Cross Compile
123
48
-------------
48
-------------
124
@@ -63,7 +63,7 @@
125
63
63
126
64
        $ bzr branch lp:mir
64
        $ bzr branch lp:mir
127
65
        $ mkdir mir/build; cd mir/build
65
        $ mkdir mir/build; cd mir/build
129
66
        $ MIR_NDK_PATH=/path/to/depenendcies/chroot cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/LinuxCrossCompile.cmake -DBoost_COMPILER=-gcc -DMIR_ENABLE_DEATH_TESTS=NO -DMIR_PLATFORM=android -DMIR_DISABLE_INPUT=yes ..
66
        $ MIR_NDK_PATH=/path/to/depenendcies/chroot cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/LinuxCrossCompile.cmake -DBoost_COMPILER=-gcc -DMIR_ENABLE_DEATH_TESTS=NO -DMIR_PLATFORM=android ..
130
67
        $ make
67
        $ make
131
68
68
132
69
N.B. The `cross-compile-android.sh` script in mir's top level directory
69
N.B. The `cross-compile-android.sh` script in mir's top level directory
133
70
70
134
=== modified file 'examples/demo_client.c'
135
--- examples/demo_client.c	2013-03-22 10:34:16 +0000
136
+++ examples/demo_client.c	2013-04-03 18:49:21 +0000
137
@@ -129,7 +129,7 @@
138
129
    /// \snippet demo_client.c surface_create_tag
129
    /// \snippet demo_client.c surface_create_tag
139
130
    ///\internal [surface_create_tag]
130
    ///\internal [surface_create_tag]
140
131
    // ...we create a surface using that format and wait for callback to complete.
131
    // ...we create a surface using that format and wait for callback to complete.
142
132
    mir_wait_for(mir_surface_create(mcd.connection, &request_params, surface_create_callback, &mcd));
132
    mir_wait_for(mir_surface_create(mcd.connection, &request_params, NULL, surface_create_callback, &mcd));
143
133
    puts("Surface created");
133
    puts("Surface created");
144
134
    ///\internal [surface_create_tag]
134
    ///\internal [surface_create_tag]
145
135
135
146
136
136
147
=== modified file 'examples/demo_client_accelerated.cpp'
148
--- examples/demo_client_accelerated.cpp	2013-03-22 10:34:16 +0000
149
+++ examples/demo_client_accelerated.cpp	2013-04-03 18:49:21 +0000
150
@@ -72,7 +72,7 @@
151
72
    MirSurfaceParameters const request_params =
72
    MirSurfaceParameters const request_params =
152
73
        {__PRETTY_FUNCTION__, 640, 480, pixel_format, mir_buffer_usage_hardware};
73
        {__PRETTY_FUNCTION__, 640, 480, pixel_format, mir_buffer_usage_hardware};
153
74
74
155
75
    surface = mir_surface_create_sync(connection, &request_params);
75
    surface = mir_surface_create_sync(connection, &request_params, NULL);
156
76
    assert(surface != NULL);
76
    assert(surface != NULL);
157
77
    assert(mir_surface_is_valid(surface));
77
    assert(mir_surface_is_valid(surface));
158
78
    assert(strcmp(mir_surface_get_error_message(surface), "") == 0);
78
    assert(strcmp(mir_surface_get_error_message(surface), "") == 0);
159
79
79
160
=== modified file 'examples/demo_client_unaccelerated.c'
161
--- examples/demo_client_unaccelerated.c	2013-03-29 16:51:35 +0000
162
+++ examples/demo_client_unaccelerated.c	2013-04-03 18:49:21 +0000
163
@@ -132,7 +132,7 @@
164
132
    MirSurfaceParameters const request_params =
132
    MirSurfaceParameters const request_params =
165
133
        {__PRETTY_FUNCTION__, 640, 480, pixel_format, mir_buffer_usage_software};
133
        {__PRETTY_FUNCTION__, 640, 480, pixel_format, mir_buffer_usage_software};
166
134
134
168
135
    surface = mir_surface_create_sync(connection, &request_params);
135
    surface = mir_surface_create_sync(connection, &request_params, NULL);
169
136
    assert(surface != NULL);
136
    assert(surface != NULL);
170
137
    assert(mir_surface_is_valid(surface));
137
    assert(mir_surface_is_valid(surface));
171
138
    assert(strcmp(mir_surface_get_error_message(surface), "") == 0);
138
    assert(strcmp(mir_surface_get_error_message(surface), "") == 0);
172
139
139
173
=== modified file 'examples/eglapp.c'
174
--- examples/eglapp.c	2013-03-20 05:03:03 +0000
175
+++ examples/eglapp.c	2013-04-03 18:49:21 +0000
176
@@ -85,6 +85,14 @@
177
85
    }
85
    }
178
86
}
86
}
179
87
87
180
88
static void mir_eglapp_handle_input(MirSurface* surface, MirEvent* ev, void* context)
181
89
{
182
90
    (void) surface;
183
91
    (void) context;
184
92
    if (ev->details.key.key_code == 45) /* Q */
185
93
        running = 0;
186
94
}
187
95
188
88
mir_eglapp_bool mir_eglapp_init(int *width, int *height)
96
mir_eglapp_bool mir_eglapp_init(int *width, int *height)
189
89
{
97
{
190
90
    EGLint attribs[] =
98
    EGLint attribs[] =
191
@@ -106,6 +114,11 @@
192
106
        mir_pixel_format_xbgr_8888,
114
        mir_pixel_format_xbgr_8888,
193
107
        mir_buffer_usage_hardware
115
        mir_buffer_usage_hardware
194
108
    };
116
    };
195
117
    MirEventDelegate delegate = 
196
118
    {
197
119
        mir_eglapp_handle_input,
198
120
        NULL
199
121
    };
200
109
    MirDisplayInfo dinfo;
122
    MirDisplayInfo dinfo;
201
110
    MirSurface *surface;
123
    MirSurface *surface;
202
111
    EGLConfig eglconfig;
124
    EGLConfig eglconfig;
203
@@ -127,7 +140,7 @@
204
127
    surfaceparm.pixel_format = dinfo.supported_pixel_format[0];
140
    surfaceparm.pixel_format = dinfo.supported_pixel_format[0];
205
128
    printf("Using pixel format #%d\n", surfaceparm.pixel_format);
141
    printf("Using pixel format #%d\n", surfaceparm.pixel_format);
206
129
142
208
130
    surface = mir_surface_create_sync(connection, &surfaceparm);
143
    surface = mir_surface_create_sync(connection, &surfaceparm, &delegate);
209
131
    CHECK(mir_surface_is_valid(surface), "Can't create a surface");
144
    CHECK(mir_surface_is_valid(surface), "Can't create a surface");
210
132
145
211
133
    egldisplay = eglGetDisplay(
146
    egldisplay = eglGetDisplay(
212
134
147
213
=== modified file 'examples/render_surfaces.cpp'
214
--- examples/render_surfaces.cpp	2013-04-02 09:36:09 +0000
215
+++ examples/render_surfaces.cpp	2013-04-03 18:49:21 +0000
216
@@ -23,7 +23,7 @@
217
23
#include "mir/geometry/size.h"
23
#include "mir/geometry/size.h"
218
24
#include "mir/graphics/buffer_initializer.h"
24
#include "mir/graphics/buffer_initializer.h"
219
25
#include "mir/graphics/display.h"
25
#include "mir/graphics/display.h"
221
26
#include "mir/input/input_manager.h"
26
#include "mir/input/null_input_manager.h"
222
27
#include "mir/shell/surface_builder.h"
27
#include "mir/shell/surface_builder.h"
223
28
#include "mir/surfaces/surface.h"
28
#include "mir/surfaces/surface.h"
224
29
#include "mir/default_server_configuration.h"
29
#include "mir/default_server_configuration.h"
225
@@ -380,20 +380,6 @@
226
380
// Stub out input.
380
// Stub out input.
227
381
std::shared_ptr<mi::InputManager> RenderSurfacesServerConfiguration::the_input_manager()
381
std::shared_ptr<mi::InputManager> RenderSurfacesServerConfiguration::the_input_manager()
228
382
{
382
{
244
383
    struct NullInputManager : public mi::InputManager
383
    return std::make_shared<mi::NullInputManager>();
230
384
    {
231
385
        void start() {}
232
386
        void stop() {}
233
387
        std::shared_ptr<mi::InputChannel> make_input_channel()
234
388
        {
235
389
            return std::shared_ptr<mi::InputChannel>();
236
390
        }
237
391
        void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */,
238
392
                                std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
239
393
        {
240
394
        }
241
395
    };
242
396
243
397
    return std::make_shared<NullInputManager>();
245
398
}
384
}
246
399
///\internal [NullInputManager_tag]
385
///\internal [NullInputManager_tag]
247
400
386
248
=== modified file 'include/client/mir_toolkit/mir_client_library.h'
249
--- include/client/mir_toolkit/mir_client_library.h	2013-03-29 11:39:30 +0000
250
+++ include/client/mir_toolkit/mir_client_library.h	2013-04-03 18:49:21 +0000
251
@@ -124,6 +124,7 @@
252
124
MirWaitHandle *mir_surface_create(
124
MirWaitHandle *mir_surface_create(
253
125
    MirConnection *connection,
125
    MirConnection *connection,
254
126
    MirSurfaceParameters const *surface_parameters,
126
    MirSurfaceParameters const *surface_parameters,
255
127
    MirEventDelegate const *event_handler,
256
127
    mir_surface_lifecycle_callback callback,
128
    mir_surface_lifecycle_callback callback,
257
128
    void *context);
129
    void *context);
258
129
130
259
@@ -135,7 +136,8 @@
260
135
 *   \return                 The resulting surface
136
 *   \return                 The resulting surface
261
136
 */
137
 */
262
137
MirSurface *mir_surface_create_sync(MirConnection *connection,
138
MirSurface *mir_surface_create_sync(MirConnection *connection,
264
138
                                    MirSurfaceParameters const *params);
139
                                    MirSurfaceParameters const *params,
265
140
                                    MirEventDelegate const *event_handler);
266
139
141
267
140
/**
142
/**
268
141
 * Get a window type that can be used for OpenGL ES 2.0 acceleration.
143
 * Get a window type that can be used for OpenGL ES 2.0 acceleration.
269
142
144
270
=== added file 'include/server/mir/input/null_input_manager.h'
271
--- include/server/mir/input/null_input_manager.h	1970-01-01 00:00:00 +0000
272
+++ include/server/mir/input/null_input_manager.h	2013-04-03 18:49:21 +0000
273
@@ -0,0 +1,56 @@
274
1
/*
275
2
 * Copyright © 2013 Canonical Ltd.
276
3
 *
277
4
 * This program is free software: you can redistribute it and/or modify it
278
5
 * under the terms of the GNU Lesser General Public License version 3,
279
6
 * as published by the Free Software Foundation.
280
7
 *
281
8
 * This program is distributed in the hope that it will be useful,
282
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
283
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
284
11
 * GNU General Public License for more details.
285
12
 *
286
13
 * You should have received a copy of the GNU Lesser General Public License
287
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
288
15
 *
289
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
290
17
 */
291
18
292
19
#ifndef MIR_INPUT_NULL_INPUT_MANAGER_H_
293
20
#define MIR_INPUT_NULL_INPUT_MANAGER_H_
294
21
295
22
#include "mir/input/input_manager.h"
296
23
297
24
namespace mir
298
25
{
299
26
namespace input
300
27
{
301
28
302
29
class NullInputManager : public InputManager
303
30
{
304
31
public:
305
32
    NullInputManager() {};
306
33
    virtual ~NullInputManager() {}
307
34
308
35
    void start() {}
309
36
    void stop() {}
310
37
311
38
    std::shared_ptr<InputChannel> make_input_channel()
312
39
    {
313
40
        return std::shared_ptr<InputChannel>();
314
41
    }
315
42
316
43
    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& /* session */,
317
44
                                    std::shared_ptr<input::SurfaceTarget> const& /* surface */)
318
45
    {
319
46
    }
320
47
321
48
protected:
322
49
    NullInputManager(const NullInputManager&) = delete;
323
50
    NullInputManager& operator=(const NullInputManager&) = delete;
324
51
};
325
52
326
53
}
327
54
}
328
55
329
56
#endif // MIR_INPUT_NULL_INPUT_MANAGER
330
0
57
331
=== added directory 'include/shared/mir/input'
332
=== added directory 'include/shared/mir/input/android'
333
=== renamed file 'src/server/input/android/android_input_lexicon.h' => 'include/shared/mir/input/android/android_input_lexicon.h'
334
--- src/server/input/android/android_input_lexicon.h	2013-03-13 04:54:15 +0000
335
+++ include/shared/mir/input/android/android_input_lexicon.h	2013-04-03 18:49:21 +0000
336
@@ -35,11 +35,18 @@
337
35
{
35
{
338
36
namespace android
36
namespace android
339
37
{
37
{
340
38
namespace transport
341
39
{
342
40
343
41
/// The Lexicon translates droidinput event types to MirEvent types prior to 
344
42
/// shell or client handling.
345
38
class Lexicon
43
class Lexicon
346
39
{
44
{
347
40
public:
45
public:
348
41
    static void translate(const droidinput::InputEvent *android_event, MirEvent &mir_event);
46
    static void translate(const droidinput::InputEvent *android_event, MirEvent &mir_event);
349
42
};
47
};
350
48
351
49
}
352
43
}
50
}
353
44
}
51
}
354
45
}
52
}
355
46
53
356
=== modified file 'include/shared/mir_toolkit/c_types.h'
357
--- include/shared/mir_toolkit/c_types.h	2013-03-29 11:27:00 +0000
358
+++ include/shared/mir_toolkit/c_types.h	2013-04-03 18:49:21 +0000
359
@@ -19,6 +19,8 @@
360
19
#ifndef MIR_TOOLKIT_C_TYPES_H_
19
#ifndef MIR_TOOLKIT_C_TYPES_H_
361
20
#define MIR_TOOLKIT_C_TYPES_H_
20
#define MIR_TOOLKIT_C_TYPES_H_
362
21
21
363
22
#include <mir_toolkit/input/event.h>
364
23
365
22
#ifdef __cplusplus
24
#ifdef __cplusplus
366
23
/**
25
/**
367
24
 * \defgroup mir_toolkit MIR graphics tools API
26
 * \defgroup mir_toolkit MIR graphics tools API
368
@@ -60,6 +62,15 @@
369
60
typedef void (*mir_surface_lifecycle_callback)(MirSurface *surface, void *client_context);
62
typedef void (*mir_surface_lifecycle_callback)(MirSurface *surface, void *client_context);
370
61
63
371
62
/**
64
/**
372
65
 * Callback member of MirEventDelegate for handling of input events.
373
66
 *   \param [in] surface     The surface on which an event has occurred
374
67
 *   \param [in] event       The event to be handled
375
68
 *   \param [in,out] context The context provided by client during delegate
376
69
 *                           registration.
377
70
 */
378
71
typedef void (*mir_event_delegate_handle_input_callback)(MirSurface* surface, MirEvent* ev, void* context);
379
72
380
73
/**
381
63
 * The order of components in a format enum matches the
74
 * The order of components in a format enum matches the
382
64
 * order of the components as they would be written in an
75
 * order of the components as they would be written in an
383
65
 *  integer representing a pixel value of that format.
76
 *  integer representing a pixel value of that format.
384
@@ -158,6 +169,16 @@
385
158
    MirPixelFormat supported_pixel_format[mir_supported_pixel_format_max];
169
    MirPixelFormat supported_pixel_format[mir_supported_pixel_format_max];
386
159
} MirDisplayInfo;
170
} MirDisplayInfo;
387
160
171
388
172
/**
389
173
 *  MirEventDelegate may be used to specify (at surface creation time) callbacks for
390
174
 *  handling of input events
391
175
 */
392
176
typedef struct MirEventDelegate
393
177
{
394
178
    mir_event_delegate_handle_input_callback handle_input;
395
179
    void *context;
396
180
} MirEventDelegate;
397
181
398
161
#ifdef __cplusplus
182
#ifdef __cplusplus
399
162
}
183
}
400
163
/**@}*/
184
/**@}*/
401
164
185
402
=== modified file 'include/shared/mir_toolkit/input/event.h'
403
--- include/shared/mir_toolkit/input/event.h	2013-03-29 11:39:30 +0000
404
+++ include/shared/mir_toolkit/input/event.h	2013-04-03 18:49:21 +0000
405
@@ -41,7 +41,7 @@
406
41
        MIR_INPUT_EVENT_TYPE_HW_SWITCH
41
        MIR_INPUT_EVENT_TYPE_HW_SWITCH
407
42
    } MirEventType;
42
    } MirEventType;
408
43
43
410
44
    struct MirEvent
44
    typedef struct MirEvent
411
45
    {
45
    {
412
46
        /* Generic event properties */
46
        /* Generic event properties */
413
47
        MirEventType type;
47
        MirEventType type;
414
@@ -94,7 +94,7 @@
415
94
                } pointer_coordinates[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
94
                } pointer_coordinates[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
416
95
            } motion;
95
            } motion;
417
96
        } details;
96
        } details;
419
97
    };
97
    } MirEvent;
420
98
98
421
99
#ifdef __cplusplus
99
#ifdef __cplusplus
422
100
}
100
}
423
101
101
424
=== modified file 'include/test/mir_test/wait_condition.h'
425
--- include/test/mir_test/wait_condition.h	2013-03-22 16:41:59 +0000
426
+++ include/test/mir_test/wait_condition.h	2013-04-03 18:49:21 +0000
427
@@ -19,12 +19,16 @@
428
19
#ifndef MIR_TEST_WAIT_CONDITION_H_
19
#ifndef MIR_TEST_WAIT_CONDITION_H_
429
20
#define MIR_TEST_WAIT_CONDITION_H_
20
#define MIR_TEST_WAIT_CONDITION_H_
430
21
21
431
22
#include <gmock/gmock.h>
432
23
433
22
#include <chrono>
24
#include <chrono>
434
23
#include <mutex>
25
#include <mutex>
435
24
#include <condition_variable>
26
#include <condition_variable>
436
25
27
437
26
namespace mir
28
namespace mir
438
27
{
29
{
439
30
namespace test
440
31
{
441
28
struct WaitCondition
32
struct WaitCondition
442
29
{
33
{
443
30
    WaitCondition() : woken(false) {}
34
    WaitCondition() : woken(false) {}
444
@@ -46,10 +50,7 @@
445
46
    std::condition_variable condition;
50
    std::condition_variable condition;
446
47
    bool woken;
51
    bool woken;
447
48
};
52
};
448
49
}
449
50
53
450
51
namespace
451
52
{
452
53
ACTION_P(ReturnFalseAndWakeUp, wait_condition)
54
ACTION_P(ReturnFalseAndWakeUp, wait_condition)
453
54
{
55
{
454
55
    wait_condition->wake_up_everyone();
56
    wait_condition->wake_up_everyone();
455
@@ -60,5 +61,6 @@
456
60
    wait_condition->wake_up_everyone();
61
    wait_condition->wake_up_everyone();
457
61
}
62
}
458
62
}
63
}
459
64
}
460
63
65
461
64
#endif // MIR_TEST_WAIT_CONDITION_H_
66
#endif // MIR_TEST_WAIT_CONDITION_H_
462
65
67
463
=== modified file 'src/client/CMakeLists.txt'
464
--- src/client/CMakeLists.txt	2013-03-29 22:30:35 +0000
465
+++ src/client/CMakeLists.txt	2013-04-03 18:49:21 +0000
466
@@ -35,6 +35,7 @@
467
35
  mir_basic_rpc_channel.cpp
35
  mir_basic_rpc_channel.cpp
468
36
  ${PROTO_SRCS}
36
  ${PROTO_SRCS}
469
37
)
37
)
470
38
add_subdirectory(input)
471
38
39
472
39
list(APPEND CLIENT_SOURCES
40
list(APPEND CLIENT_SOURCES
473
40
  mir_socket_rpc_channel.cpp
41
  mir_socket_rpc_channel.cpp
474
@@ -82,15 +83,15 @@
475
82
  SOVERSION ${MIR_VERSION_MAJOR}
83
  SOVERSION ${MIR_VERSION_MAJOR}
476
83
)
84
)
477
84
85
481
85
target_link_libraries(
86
set(
482
86
  mirclient
87
  MIR_CLIENT_LIBRARIES
480
87
483
88
  ${Boost_LIBRARIES}
88
  ${Boost_LIBRARIES}
484
89
  ${CMAKE_THREAD_LIBS_INIT}
89
  ${CMAKE_THREAD_LIBS_INIT}
485
90
  ${LIBHARDWARE_LIBRARIES}
90
  ${LIBHARDWARE_LIBRARIES}
486
91
  ${PROTOBUF_LIBRARIES}
91
  ${PROTOBUF_LIBRARIES}
487
92
92
488
93
  mirprotobuf
93
  mirprotobuf
489
94
  mirinputandroidtransport
490
94
95
491
95
  ${DRM_LIBRARIES}
96
  ${DRM_LIBRARIES}
492
96
  ${MIR_COMMON_PLATFORM_LIBRARIES}
97
  ${MIR_COMMON_PLATFORM_LIBRARIES}
493
@@ -98,6 +99,12 @@
494
98
  3rd_party
99
  3rd_party
495
99
)
100
)
496
100
101
497
102
target_link_libraries(
498
103
  mirclient
499
104
500
105
  ${MIR_CLIENT_LIBRARIES}
501
106
)
502
107
503
101
install(
108
install(
504
102
  TARGETS mirclient
109
  TARGETS mirclient
505
103
  LIBRARY DESTINATION lib
110
  LIBRARY DESTINATION lib
506
104
111
507
=== added directory 'src/client/input'
508
=== added file 'src/client/input/CMakeLists.txt'
509
--- src/client/input/CMakeLists.txt	1970-01-01 00:00:00 +0000
510
+++ src/client/input/CMakeLists.txt	2013-04-03 18:49:21 +0000
511
@@ -0,0 +1,12 @@
512
1
list(
513
2
  APPEND CLIENT_SOURCES
514
3
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_receiver.cpp
515
4
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_receiver_thread.cpp
516
5
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_platform.cpp
517
6
)
518
7
519
8
set(
520
9
  CLIENT_SOURCES
521
10
  ${CLIENT_SOURCES}
522
11
  PARENT_SCOPE
523
12
)
524
0
13
525
=== added file 'src/client/input/android_input_platform.cpp'
526
--- src/client/input/android_input_platform.cpp	1970-01-01 00:00:00 +0000
527
+++ src/client/input/android_input_platform.cpp	2013-04-03 18:49:21 +0000
528
@@ -0,0 +1,44 @@
529
1
/*
530
2
 * Copyright © 2013 Canonical Ltd.
531
3
 *
532
4
 * This program is free software: you can redistribute it and/or modify
533
5
 * it under the terms of the GNU General Public License version 3 as
534
6
 * published by the Free Software Foundation.
535
7
 *
536
8
 * This program is distributed in the hope that it will be useful,
537
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
538
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
539
11
 * GNU General Public License for more details.
540
12
 *
541
13
 * You should have received a copy of the GNU General Public License
542
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
543
15
 *
544
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
545
17
 */
546
18
547
19
#include "android_input_platform.h"
548
20
#include "android_input_receiver.h"
549
21
#include "android_input_receiver_thread.h"
550
22
551
23
namespace mcli = mir::client::input;
552
24
namespace mclia = mcli::android;
553
25
554
26
mclia::AndroidInputPlatform::AndroidInputPlatform()
555
27
{
556
28
}
557
29
558
30
mclia::AndroidInputPlatform::~AndroidInputPlatform()
559
31
{
560
32
}
561
33
562
34
std::shared_ptr<mcli::InputReceiverThread> mclia::AndroidInputPlatform::create_input_thread(
563
35
    int fd, std::function<void(MirEvent*)> const& callback)
564
36
{
565
37
    auto receiver = std::make_shared<mclia::InputReceiver>(fd);
566
38
    return std::make_shared<mclia::InputReceiverThread>(receiver, callback);
567
39
}
568
40
569
41
std::shared_ptr<mcli::InputPlatform> mcli::InputPlatform::create()
570
42
{
571
43
    return std::make_shared<mclia::AndroidInputPlatform>();
572
44
}
573
0
45
574
=== added file 'src/client/input/android_input_platform.h'
575
--- src/client/input/android_input_platform.h	1970-01-01 00:00:00 +0000
576
+++ src/client/input/android_input_platform.h	2013-04-03 18:49:21 +0000
577
@@ -0,0 +1,52 @@
578
1
/*
579
2
 * Copyright © 2013 Canonical Ltd.
580
3
 *
581
4
 * This program is free software: you can redistribute it and/or modify
582
5
 * it under the terms of the GNU General Public License version 3 as
583
6
 * published by the Free Software Foundation.
584
7
 *
585
8
 * This program is distributed in the hope that it will be useful,
586
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
587
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
588
11
 * GNU General Public License for more details.
589
12
 *
590
13
 * You should have received a copy of the GNU General Public License
591
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
592
15
 *
593
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
594
17
 */
595
18
596
19
#ifndef MIR_CLIENT_ANDROID_INPUT_PLATFORM_H_
597
20
#define MIR_CLIENT_ANDROID_INPUT_PLATFORM_H_
598
21
599
22
#include "input_platform.h"
600
23
601
24
namespace mir
602
25
{
603
26
namespace client
604
27
{
605
28
namespace input
606
29
{
607
30
namespace android
608
31
{
609
32
610
33
/// Implementation of client input machinery for android input stack wire protocol.
611
34
class AndroidInputPlatform : public InputPlatform
612
35
{
613
36
public:
614
37
    AndroidInputPlatform();
615
38
    virtual ~AndroidInputPlatform();  
616
39
617
40
    std::shared_ptr<InputReceiverThread> create_input_thread(int fd, std::function<void(MirEvent *)> const& callback);
618
41
619
42
protected:
620
43
    AndroidInputPlatform(const AndroidInputPlatform&) = delete;
621
44
    AndroidInputPlatform& operator=(const AndroidInputPlatform&) = delete;
622
45
};
623
46
624
47
}
625
48
}
626
49
}
627
50
} // namespace mir
628
51
629
52
#endif // MIR_CLIENT_ANDROID_INPUT_PLATFORM_H_
630
0
53
631
=== added file 'src/client/input/android_input_receiver.cpp'
632
--- src/client/input/android_input_receiver.cpp	1970-01-01 00:00:00 +0000
633
+++ src/client/input/android_input_receiver.cpp	2013-04-03 18:49:21 +0000
634
@@ -0,0 +1,91 @@
635
1
/*
636
2
 * Copyright © 2013 Canonical Ltd.
637
3
 *
638
4
 * This program is free software: you can redistribute it and/or modify
639
5
 * it under the terms of the GNU General Public License version 3 as
640
6
 * published by the Free Software Foundation.
641
7
 *
642
8
 * This program is distributed in the hope that it will be useful,
643
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
644
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645
11
 * GNU General Public License for more details.
646
12
 *
647
13
 * You should have received a copy of the GNU General Public License
648
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
649
15
 *
650
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
651
17
 */
652
18
653
19
#include "android_input_receiver.h"
654
20
#include "mir/input/android/android_input_lexicon.h"
655
21
656
22
#include <androidfw/InputTransport.h>
657
23
#include <utils/Looper.h>
658
24
659
25
namespace mclia = mir::client::input::android;
660
26
namespace miat = mir::input::android::transport;
661
27
662
28
mclia::InputReceiver::InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel)
663
29
  : input_channel(input_channel),
664
30
    input_consumer(std::make_shared<droidinput::InputConsumer>(input_channel)),
665
31
    looper(new droidinput::Looper(true)),
666
32
    fd_added(false)
667
33
{
668
34
}
669
35
670
36
mclia::InputReceiver::InputReceiver(int fd)
671
37
  : input_channel(new droidinput::InputChannel(droidinput::String8(""), fd)), 
672
38
    input_consumer(std::make_shared<droidinput::InputConsumer>(input_channel)),
673
39
    looper(new droidinput::Looper(true)),
674
40
    fd_added(false)
675
41
{
676
42
}
677
43
678
44
mclia::InputReceiver::~InputReceiver()
679
45
{
680
46
}
681
47
682
48
int mclia::InputReceiver::fd() const
683
49
{
684
50
    return input_channel->getFd();
685
51
}
686
52
687
53
// TODO: We use a droidinput::Looper here for polling functionality but it might be nice to integrate
688
54
// with the existing client io_service ~racarr ~tvoss
689
55
bool mclia::InputReceiver::next_event(std::chrono::milliseconds const& timeout, MirEvent &ev)
690
56
{
691
57
    droidinput::InputEvent *android_event;
692
58
    uint32_t event_sequence_id;
693
59
    bool handled_event = false;
694
60
695
61
    if (!fd_added)
696
62
    {
697
63
        // TODO: Why will this fail from the constructor? ~racarr
698
64
        looper->addFd(fd(), fd(), ALOOPER_EVENT_INPUT, nullptr, nullptr);
699
65
        fd_added = true;
700
66
    }
701
67
    
702
68
    auto result = looper->pollOnce(timeout.count());
703
69
    if (result == ALOOPER_POLL_WAKE)
704
70
        return false;
705
71
    else if (result == ALOOPER_POLL_ERROR) // TODO: Exception?
706
72
        return false;
707
73
708
74
    if(input_consumer->consume(&event_factory, true,
709
75
        -1, &event_sequence_id, &android_event) != droidinput::WOULD_BLOCK)
710
76
    {
711
77
        miat::Lexicon::translate(android_event, ev);
712
78
        input_consumer->sendFinishedSignal(event_sequence_id, true);
713
79
        handled_event = true;
714
80
    }
715
81
716
82
    // So far once we have sent an event to the client there is no chance for redispatch
717
83
    // so the client handles all events.
718
84
    
719
85
    return handled_event;
720
86
}
721
87
722
88
void mclia::InputReceiver::wake()
723
89
{
724
90
    looper->wake();
725
91
}
726
0
92
727
=== added file 'src/client/input/android_input_receiver.h'
728
--- src/client/input/android_input_receiver.h	1970-01-01 00:00:00 +0000
729
+++ src/client/input/android_input_receiver.h	2013-04-03 18:49:21 +0000
730
@@ -0,0 +1,84 @@
731
1
/*
732
2
 * Copyright © 2013 Canonical Ltd.
733
3
 *
734
4
 * This program is free software: you can redistribute it and/or modify
735
5
 * it under the terms of the GNU General Public License version 3 as
736
6
 * published by the Free Software Foundation.
737
7
 *
738
8
 * This program is distributed in the hope that it will be useful,
739
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
740
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
741
11
 * GNU General Public License for more details.
742
12
 *
743
13
 * You should have received a copy of the GNU General Public License
744
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
745
15
 *
746
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
747
17
 */
748
18
749
19
#ifndef MIR_INPUT_ANDROID_INPUT_RECEIVER_H_
750
20
#define MIR_INPUT_ANDROID_INPUT_RECEIVER_H_
751
21
752
22
#include "mir_toolkit/input/event.h"
753
23
754
24
#include <utils/StrongPointer.h>
755
25
#include <androidfw/Input.h>
756
26
757
27
#include <memory>
758
28
#include <chrono>
759
29
760
30
namespace droidinput = android;
761
31
762
32
namespace android
763
33
{
764
34
class InputChannel;
765
35
class InputConsumer;
766
36
class Looper;
767
37
}
768
38
769
39
namespace mir
770
40
{
771
41
namespace client
772
42
{
773
43
namespace input
774
44
{
775
45
namespace android
776
46
{
777
47
778
48
/// Synchronously receives input events in a blocking manner
779
49
class InputReceiver
780
50
{
781
51
public:
782
52
    InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel);
783
53
    InputReceiver(int fd);
784
54
785
55
    virtual ~InputReceiver();
786
56
    int fd() const;
787
57
    
788
58
    /// Synchronously receive an event with millisecond timeout. A negative timeout value
789
59
    /// is used to request indefinite polling.
790
60
    virtual bool next_event(std::chrono::milliseconds const& timeout, MirEvent &ev);
791
61
    virtual bool next_event(MirEvent &ev) { return next_event(std::chrono::milliseconds(-1), ev); }
792
62
    
793
63
    /// May be used from any thread to wake an InputReceiver blocked in next_event
794
64
    virtual void wake();
795
65
796
66
protected:
797
67
    InputReceiver(const InputReceiver&) = delete;
798
68
    InputReceiver& operator=(const InputReceiver&) = delete;
799
69
800
70
private:
801
71
    droidinput::sp<droidinput::InputChannel> input_channel;
802
72
    std::shared_ptr<droidinput::InputConsumer> input_consumer;
803
73
    droidinput::PreallocatedInputEventFactory event_factory;
804
74
    droidinput::sp<droidinput::Looper> looper;
805
75
806
76
    bool fd_added;
807
77
};
808
78
809
79
}
810
80
}
811
81
}
812
82
} // namespace mir
813
83
814
84
#endif // MIR_INPUT_ANDROID_INPUT_RECEIVER_H_
815
0
85
816
=== added file 'src/client/input/android_input_receiver_thread.cpp'
817
--- src/client/input/android_input_receiver_thread.cpp	1970-01-01 00:00:00 +0000
818
+++ src/client/input/android_input_receiver_thread.cpp	2013-04-03 18:49:21 +0000
819
@@ -0,0 +1,68 @@
820
1
/*
821
2
 * Copyright © 2013 Canonical Ltd.
822
3
 *
823
4
 * This program is free software: you can redistribute it and/or modify
824
5
 * it under the terms of the GNU General Public License version 3 as
825
6
 * published by the Free Software Foundation.
826
7
 *
827
8
 * This program is distributed in the hope that it will be useful,
828
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
829
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
830
11
 * GNU General Public License for more details.
831
12
 *
832
13
 * You should have received a copy of the GNU General Public License
833
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
834
15
 *
835
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
836
17
 */
837
18
838
19
#include "android_input_receiver_thread.h"
839
20
#include "android_input_receiver.h"
840
21
841
22
#include <thread>
842
23
843
24
namespace mclia = mir::client::input::android;
844
25
845
26
mclia::InputReceiverThread::InputReceiverThread(std::shared_ptr<mclia::InputReceiver> const& receiver,
846
27
                                                std::function<void(MirEvent*)> const& event_handling_callback)
847
28
  : receiver(receiver),
848
29
    handler(event_handling_callback),
849
30
    running(false)
850
31
{
851
32
}
852
33
853
34
mclia::InputReceiverThread::~InputReceiverThread()
854
35
{
855
36
    if (running)
856
37
        stop();
857
38
    if (thread.joinable())
858
39
        join();
859
40
}
860
41
861
42
void mclia::InputReceiverThread::start()
862
43
{
863
44
    running = true;
864
45
    thread = std::thread(std::mem_fn(&mclia::InputReceiverThread::thread_loop), this);
865
46
}
866
47
867
48
void mclia::InputReceiverThread::stop()
868
49
{
869
50
    running = false;
870
51
    receiver->wake();
871
52
}
872
53
873
54
void mclia::InputReceiverThread::join()
874
55
{
875
56
    thread.join();
876
57
}
877
58
878
59
void mclia::InputReceiverThread::thread_loop()
879
60
{
880
61
    while (running)
881
62
    {
882
63
        MirEvent ev;
883
64
        while(running && receiver->next_event(ev))
884
65
            handler(&ev);
885
66
        std::this_thread::yield(); // yield() is needed to ensure reasonable runtime under valgrind
886
67
    }
887
68
}
888
0
69
889
=== added file 'src/client/input/android_input_receiver_thread.h'
890
--- src/client/input/android_input_receiver_thread.h	1970-01-01 00:00:00 +0000
891
+++ src/client/input/android_input_receiver_thread.h	2013-04-03 18:49:21 +0000
892
@@ -0,0 +1,71 @@
893
1
/*
894
2
 * Copyright © 2013 Canonical Ltd.
895
3
 *
896
4
 * This program is free software: you can redistribute it and/or modify
897
5
 * it under the terms of the GNU General Public License version 3 as
898
6
 * published by the Free Software Foundation.
899
7
 *
900
8
 * This program is distributed in the hope that it will be useful,
901
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
902
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
903
11
 * GNU General Public License for more details.
904
12
 *
905
13
 * You should have received a copy of the GNU General Public License
906
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
907
15
 *
908
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
909
17
 */
910
18
911
19
#ifndef MIR_INPUT_ANDROID_INPUT_RECEIVER_THREAD_H_
912
20
#define MIR_INPUT_ANDROID_INPUT_RECEIVER_THREAD_H_
913
21
914
22
#include "input_receiver_thread.h"
915
23
916
24
#include "mir_toolkit/input/event.h"
917
25
918
26
#include <functional>
919
27
#include <memory>
920
28
#include <atomic>
921
29
#include <thread>
922
30
923
31
namespace mir
924
32
{
925
33
namespace client
926
34
{
927
35
namespace input
928
36
{
929
37
namespace android
930
38
{
931
39
class InputReceiver;
932
40
933
41
/// Responsible for polling an InputReceiver to read and dispatch events when appropriate.
934
42
class InputReceiverThread : public input::InputReceiverThread
935
43
{
936
44
public:
937
45
    InputReceiverThread(std::shared_ptr<InputReceiver> const& receiver, 
938
46
                        std::function<void(MirEvent*)> const& event_handling_callback);
939
47
    virtual ~InputReceiverThread();
940
48
941
49
    void start();
942
50
    void stop();
943
51
    void join();
944
52
945
53
protected:
946
54
    InputReceiverThread(const InputReceiverThread&) = delete;
947
55
    InputReceiverThread& operator=(const InputReceiverThread&) = delete;
948
56
949
57
private:
950
58
    std::shared_ptr<InputReceiver> const receiver;
951
59
    std::function<void(MirEvent*)> const handler;
952
60
    
953
61
    void thread_loop();
954
62
    std::atomic<bool> running;
955
63
    std::thread thread;
956
64
};
957
65
958
66
}
959
67
}
960
68
}
961
69
} // namespace mir
962
70
963
71
#endif // MIR_INPUT_ANDROID_INPUT_RECEIVER_THREAD_H_
964
0
72
965
=== added file 'src/client/input/input_platform.h'
966
--- src/client/input/input_platform.h	1970-01-01 00:00:00 +0000
967
+++ src/client/input/input_platform.h	2013-04-03 18:49:21 +0000
968
@@ -0,0 +1,55 @@
969
1
/*
970
2
 * Copyright © 2013 Canonical Ltd.
971
3
 *
972
4
 * This program is free software: you can redistribute it and/or modify
973
5
 * it under the terms of the GNU General Public License version 3 as
974
6
 * published by the Free Software Foundation.
975
7
 *
976
8
 * This program is distributed in the hope that it will be useful,
977
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
978
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
979
11
 * GNU General Public License for more details.
980
12
 *
981
13
 * You should have received a copy of the GNU General Public License
982
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
983
15
 *
984
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
985
17
 */
986
18
987
19
#ifndef MIR_CLIENT_INPUT_PLATFORM_H_
988
20
#define MIR_CLIENT_INPUT_PLATFORM_H_
989
21
990
22
#include "mir_toolkit/input/event.h"
991
23
992
24
#include <memory>
993
25
#include <functional>
994
26
995
27
namespace mir
996
28
{
997
29
namespace client
998
30
{
999
31
namespace input
1000
32
{
1001
33
class InputReceiverThread;
1002
34
1003
35
// Interface for MirSurface to construct input dispatcher threads.
1004
36
class InputPlatform
1005
37
{
1006
38
public:
1007
39
    virtual ~InputPlatform() {};  
1008
40
1009
41
    virtual std::shared_ptr<InputReceiverThread> create_input_thread(int fd, std::function<void(MirEvent *)> const& callback) = 0;
1010
42
    
1011
43
    static std::shared_ptr<InputPlatform> create();
1012
44
1013
45
protected:
1014
46
    InputPlatform() = default;
1015
47
    InputPlatform(const InputPlatform&) = delete;
1016
48
    InputPlatform& operator=(const InputPlatform&) = delete;
1017
49
};
1018
50
1019
51
}
1020
52
}
1021
53
} // namespace mir
1022
54
1023
55
#endif // MIR_CLIENT_INPUT_PLATFORM_H_
1024
0
56
1025
=== added file 'src/client/input/input_receiver_thread.h'
1026
--- src/client/input/input_receiver_thread.h	1970-01-01 00:00:00 +0000
1027
+++ src/client/input/input_receiver_thread.h	2013-04-03 18:49:21 +0000
1028
@@ -0,0 +1,48 @@
1029
1
/*
1030
2
 * Copyright © 2013 Canonical Ltd.
1031
3
 *
1032
4
 * This program is free software: you can redistribute it and/or modify
1033
5
 * it under the terms of the GNU General Public License version 3 as
1034
6
 * published by the Free Software Foundation.
1035
7
 *
1036
8
 * This program is distributed in the hope that it will be useful,
1037
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1038
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1039
11
 * GNU General Public License for more details.
1040
12
 *
1041
13
 * You should have received a copy of the GNU General Public License
1042
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1043
15
 *
1044
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1045
17
 */
1046
18
1047
19
#ifndef MIR_CLIENT_INPUT_RECEIVER_THREAD_H_
1048
20
#define MIR_CLIENT_INPUT_RECEIVER_THREAD_H_
1049
21
1050
22
namespace mir
1051
23
{
1052
24
namespace client
1053
25
{
1054
26
namespace input
1055
27
{
1056
28
1057
29
class InputReceiverThread
1058
30
{
1059
31
public:
1060
32
    virtual ~InputReceiverThread() {};
1061
33
1062
34
    virtual void start() = 0;
1063
35
    virtual void stop() = 0;
1064
36
    virtual void join() = 0;
1065
37
1066
38
protected:
1067
39
    InputReceiverThread() = default;
1068
40
    InputReceiverThread(const InputReceiverThread&) = delete;
1069
41
    InputReceiverThread& operator=(const InputReceiverThread&) = delete;
1070
42
};
1071
43
1072
44
}
1073
45
}
1074
46
} // namespace mir
1075
47
1076
48
#endif // MIR_CLIENT_INPUT_RECEIVER_THREAD_H_
1077
0
49
1078
=== modified file 'src/client/mir_client_library.cpp'
1079
--- src/client/mir_client_library.cpp	2013-03-29 11:27:00 +0000
1080
+++ src/client/mir_client_library.cpp	2013-04-03 18:49:21 +0000
1081
@@ -118,16 +118,17 @@
1082
118
}
118
}
1083
119
119
1084
120
MirWaitHandle* mir_surface_create(
120
MirWaitHandle* mir_surface_create(
1087
121
    MirConnection * connection,
121
    MirConnection* connection,
1088
122
    MirSurfaceParameters const * params,
122
    MirSurfaceParameters const* params,
1089
123
    MirEventDelegate const* delegate,
1090
123
    mir_surface_lifecycle_callback callback,
124
    mir_surface_lifecycle_callback callback,
1092
124
    void * context)
125
    void* context)
1093
125
{
126
{
1094
126
    if (&error_connection == connection) return 0;
127
    if (&error_connection == connection) return 0;
1095
127
128
1096
128
    try
129
    try
1097
129
    {
130
    {
1099
130
        return connection->create_surface(*params, callback, context);
131
        return connection->create_surface(*params, delegate, callback, context);
1100
131
    }
132
    }
1101
132
    catch (std::exception const&)
133
    catch (std::exception const&)
1102
133
    {
134
    {
1103
@@ -137,12 +138,15 @@
1104
137
138
1105
138
}
139
}
1106
139
140
1109
140
MirSurface *mir_surface_create_sync(
141
MirSurface* mir_surface_create_sync(
1110
141
    MirConnection *connection, MirSurfaceParameters const *params)
142
    MirConnection* connection, 
1111
143
    MirSurfaceParameters const* params,
1112
144
    MirEventDelegate const* delegate)
1113
142
{
145
{
1114
143
    MirSurface *surface = nullptr;
146
    MirSurface *surface = nullptr;
1115
144
147
1116
145
    mir_wait_for(mir_surface_create(connection, params,
148
    mir_wait_for(mir_surface_create(connection, params,
1117
149
                                    delegate,
1118
146
        reinterpret_cast<mir_surface_lifecycle_callback>(assign_result),
150
        reinterpret_cast<mir_surface_lifecycle_callback>(assign_result),
1119
147
        &surface));
151
        &surface));
1120
148
152
1121
149
153
1122
=== modified file 'src/client/mir_client_surface.h'
1123
--- src/client/mir_client_surface.h	2013-03-29 11:27:00 +0000
1124
+++ src/client/mir_client_surface.h	2013-04-03 18:49:21 +0000
1125
@@ -22,6 +22,7 @@
1126
22
#include "mir_toolkit/mir_client_library.h"
22
#include "mir_toolkit/mir_client_library.h"
1127
23
23
1128
24
#include <memory>
24
#include <memory>
1129
25
1130
25
namespace mir
26
namespace mir
1131
26
{
27
{
1132
27
namespace client
28
namespace client
1133
28
29
1134
=== modified file 'src/client/mir_connection.cpp'
1135
--- src/client/mir_connection.cpp	2013-03-29 11:27:00 +0000
1136
+++ src/client/mir_connection.cpp	2013-04-03 18:49:21 +0000
1137
@@ -25,10 +25,13 @@
1138
25
#include "client_buffer_depository.h"
25
#include "client_buffer_depository.h"
1139
26
#include "make_rpc_channel.h"
26
#include "make_rpc_channel.h"
1140
27
27
1141
28
#include "input/input_platform.h"
1142
29
1143
28
#include <thread>
30
#include <thread>
1144
29
#include <cstddef>
31
#include <cstddef>
1145
30
32
1146
31
namespace mcl = mir::client;
33
namespace mcl = mir::client;
1147
34
namespace mcli = mcl::input;
1148
32
namespace mp = mir::protobuf;
35
namespace mp = mir::protobuf;
1149
33
namespace gp = google::protobuf;
36
namespace gp = google::protobuf;
1150
34
37
1151
@@ -46,7 +49,8 @@
1152
46
        channel(channel),
49
        channel(channel),
1153
47
        server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
50
        server(channel.get(), ::google::protobuf::Service::STUB_DOESNT_OWN_CHANNEL),
1154
48
        log(log),
51
        log(log),
1156
49
        client_platform_factory(client_platform_factory)
52
        client_platform_factory(client_platform_factory),
1157
53
        input_platform(mcli::InputPlatform::create())
1158
50
{
54
{
1159
51
    {
55
    {
1160
52
        std::lock_guard<std::mutex> lock(connection_guard);
56
        std::lock_guard<std::mutex> lock(connection_guard);
1161
@@ -63,11 +67,13 @@
1162
63
67
1163
64
MirWaitHandle* MirConnection::create_surface(
68
MirWaitHandle* MirConnection::create_surface(
1164
65
    MirSurfaceParameters const & params,
69
    MirSurfaceParameters const & params,
1165
70
    MirEventDelegate const* delegate,
1166
66
    mir_surface_lifecycle_callback callback,
71
    mir_surface_lifecycle_callback callback,
1167
67
    void * context)
72
    void * context)
1168
68
{
73
{
1169
69
    auto null_log = std::make_shared<mir::client::NullLogger>();
74
    auto null_log = std::make_shared<mir::client::NullLogger>();
1171
70
    auto surface = new MirSurface(this, server, null_log, platform->create_buffer_factory(), params, callback, context);
75
    auto surface = new MirSurface(this, server, null_log, platform->create_buffer_factory(), input_platform, params, delegate, callback, context);
1172
76
1173
71
    return surface->get_create_wait_handle();
77
    return surface->get_create_wait_handle();
1174
72
}
78
}
1175
73
79
1176
74
80
1177
=== modified file 'src/client/mir_connection.h'
1178
--- src/client/mir_connection.h	2013-04-02 09:23:02 +0000
1179
+++ src/client/mir_connection.h	2013-04-03 18:49:21 +0000
1180
@@ -42,6 +42,10 @@
1181
42
class Logger;
42
class Logger;
1182
43
class ClientBufferDepository;
43
class ClientBufferDepository;
1183
44
class ClientPlatformFactory;
44
class ClientPlatformFactory;
1184
45
namespace input
1185
46
{
1186
47
class InputPlatform;
1187
48
}
1188
45
}
49
}
1189
46
}
50
}
1190
47
51
1191
@@ -60,6 +64,7 @@
1192
60
64
1193
61
    MirWaitHandle* create_surface(
65
    MirWaitHandle* create_surface(
1194
62
        MirSurfaceParameters const & params,
66
        MirSurfaceParameters const & params,
1195
67
        MirEventDelegate const* delegate,
1196
63
        mir_surface_lifecycle_callback callback,
68
        mir_surface_lifecycle_callback callback,
1197
64
        void * context);
69
        void * context);
1198
65
    MirWaitHandle* release_surface(
70
    MirWaitHandle* release_surface(
1199
@@ -114,6 +119,8 @@
1200
114
    std::shared_ptr<mir::client::ClientPlatform> platform;
119
    std::shared_ptr<mir::client::ClientPlatform> platform;
1201
115
    std::shared_ptr<EGLNativeDisplayType> native_display;
120
    std::shared_ptr<EGLNativeDisplayType> native_display;
1202
116
121
1203
122
    std::shared_ptr<mir::client::input::InputPlatform> const input_platform;
1204
123
1205
117
    std::string error_message;
124
    std::string error_message;
1206
118
125
1207
119
    MirWaitHandle connect_wait_handle;
126
    MirWaitHandle connect_wait_handle;
1208
120
127
1209
=== modified file 'src/client/mir_surface.cpp'
1210
--- src/client/mir_surface.cpp	2013-04-02 09:23:02 +0000
1211
+++ src/client/mir_surface.cpp	2013-04-03 18:49:21 +0000
1212
@@ -21,11 +21,14 @@
1213
21
#include "client_buffer.h"
21
#include "client_buffer.h"
1214
22
#include "mir_surface.h"
22
#include "mir_surface.h"
1215
23
#include "mir_connection.h"
23
#include "mir_connection.h"
1216
24
#include "input/input_receiver_thread.h"
1217
25
#include "input/input_platform.h"
1218
24
26
1219
25
#include <cassert>
27
#include <cassert>
1220
26
28
1221
27
namespace geom = mir::geometry;
29
namespace geom = mir::geometry;
1222
28
namespace mcl = mir::client;
30
namespace mcl = mir::client;
1223
31
namespace mcli = mir::client::input;
1224
29
namespace mp = mir::protobuf;
32
namespace mp = mir::protobuf;
1225
30
namespace gp = google::protobuf;
33
namespace gp = google::protobuf;
1226
31
34
1227
@@ -34,11 +37,14 @@
1228
34
    mp::DisplayServer::Stub & server,
37
    mp::DisplayServer::Stub & server,
1229
35
    std::shared_ptr<mir::client::Logger> const& logger,
38
    std::shared_ptr<mir::client::Logger> const& logger,
1230
36
    std::shared_ptr<mcl::ClientBufferFactory> const& factory,
39
    std::shared_ptr<mcl::ClientBufferFactory> const& factory,
1232
37
    MirSurfaceParameters const& params,
40
    std::shared_ptr<mcli::InputPlatform> const& input_platform,
1233
41
    MirSurfaceParameters const & params,
1234
42
    MirEventDelegate const* delegate,
1235
38
    mir_surface_lifecycle_callback callback, void * context)
43
    mir_surface_lifecycle_callback callback, void * context)
1236
39
    : server(server),
44
    : server(server),
1237
40
      connection(allocating_connection),
45
      connection(allocating_connection),
1238
41
      buffer_depository(std::make_shared<mcl::ClientBufferDepository>(factory, 3)),
46
      buffer_depository(std::make_shared<mcl::ClientBufferDepository>(factory, 3)),
1239
47
      input_platform(input_platform),
1240
42
      logger(logger)
48
      logger(logger)
1241
43
{
49
{
1242
44
    mir::protobuf::SurfaceParameters message;
50
    mir::protobuf::SurfaceParameters message;
1243
@@ -47,6 +53,9 @@
1244
47
    message.set_height(params.height);
53
    message.set_height(params.height);
1245
48
    message.set_pixel_format(params.pixel_format);
54
    message.set_pixel_format(params.pixel_format);
1246
49
    message.set_buffer_usage(params.buffer_usage);
55
    message.set_buffer_usage(params.buffer_usage);
1247
56
    
1248
57
    if (delegate)
1249
58
        handle_event_callback = std::bind(delegate->handle_input, this, std::placeholders::_1, delegate->context);
1250
50
59
1251
51
    server.create_surface(0, &message, &surface, gp::NewCallback(this, &MirSurface::created, callback, context));
60
    server.create_surface(0, &message, &surface, gp::NewCallback(this, &MirSurface::created, callback, context));
1252
52
61
1253
@@ -57,6 +66,8 @@
1254
57
66
1255
58
MirSurface::~MirSurface()
67
MirSurface::~MirSurface()
1256
59
{
68
{
1257
69
    if (input_thread)
1258
70
        input_thread->stop();
1259
60
    release_cpu_region();
71
    release_cpu_region();
1260
61
}
72
}
1261
62
73
1262
@@ -166,6 +177,13 @@
1263
166
    accelerated_window = platform->create_egl_native_window(this);
177
    accelerated_window = platform->create_egl_native_window(this);
1264
167
178
1265
168
    callback(this, context);
179
    callback(this, context);
1266
180
    
1267
181
    if (surface.fd_size() > 0 && handle_event_callback)
1268
182
    {
1269
183
        input_thread = input_platform->create_input_thread(surface.fd(0), handle_event_callback);
1270
184
        input_thread->start();
1271
185
    }
1272
186
1273
169
    create_wait_handle.result_received();
187
    create_wait_handle.result_received();
1274
170
}
188
}
1275
171
189
1276
172
190
1277
=== modified file 'src/client/mir_surface.h'
1278
--- src/client/mir_surface.h	2013-03-29 11:27:00 +0000
1279
+++ src/client/mir_surface.h	2013-04-03 18:49:21 +0000
1280
@@ -30,12 +30,19 @@
1281
30
#include "client_platform.h"
30
#include "client_platform.h"
1282
31
31
1283
32
#include <memory>
32
#include <memory>
1284
33
#include <functional>
1285
33
34
1286
34
namespace mir
35
namespace mir
1287
35
{
36
{
1288
36
namespace client
37
namespace client
1289
37
{
38
{
1290
38
class ClientBuffer;
39
class ClientBuffer;
1291
40
namespace input
1292
41
{
1293
42
class InputPlatform;
1294
43
class InputReceiverThread;
1295
44
}
1296
45
1297
39
struct MemoryRegion;
46
struct MemoryRegion;
1298
40
}
47
}
1299
41
}
48
}
1300
@@ -51,7 +58,9 @@
1301
51
        mir::protobuf::DisplayServer::Stub & server,
58
        mir::protobuf::DisplayServer::Stub & server,
1302
52
        std::shared_ptr<mir::client::Logger> const& logger,
59
        std::shared_ptr<mir::client::Logger> const& logger,
1303
53
        std::shared_ptr<mir::client::ClientBufferFactory> const& buffer_factory,
60
        std::shared_ptr<mir::client::ClientBufferFactory> const& buffer_factory,
1304
61
        std::shared_ptr<mir::client::input::InputPlatform> const& input_platform,
1305
54
        MirSurfaceParameters const& params,
62
        MirSurfaceParameters const& params,
1306
63
        MirEventDelegate const* delegate,
1307
55
        mir_surface_lifecycle_callback callback, void * context);
64
        mir_surface_lifecycle_callback callback, void * context);
1308
56
65
1309
57
    ~MirSurface();
66
    ~MirSurface();
1310
@@ -97,6 +106,7 @@
1311
97
106
1312
98
    std::shared_ptr<mir::client::MemoryRegion> secured_region;
107
    std::shared_ptr<mir::client::MemoryRegion> secured_region;
1313
99
    std::shared_ptr<mir::client::ClientBufferDepository> buffer_depository;
108
    std::shared_ptr<mir::client::ClientBufferDepository> buffer_depository;
1314
109
    std::shared_ptr<mir::client::input::InputPlatform> const input_platform;
1315
100
110
1316
101
    std::shared_ptr<mir::client::Logger> logger;
111
    std::shared_ptr<mir::client::Logger> logger;
1317
102
    std::shared_ptr<EGLNativeWindowType> accelerated_window;
112
    std::shared_ptr<EGLNativeWindowType> accelerated_window;
1318
@@ -105,6 +115,9 @@
1319
105
115
1320
106
    // Cache of latest SurfaceSettings returned from the server
116
    // Cache of latest SurfaceSettings returned from the server
1321
107
    int attrib_cache[mir_surface_attrib_arraysize_];
117
    int attrib_cache[mir_surface_attrib_arraysize_];
1322
118
1323
119
    std::function<void(MirEvent*)> handle_event_callback;
1324
120
    std::shared_ptr<mir::client::input::InputReceiverThread> input_thread;
1325
108
};
121
};
1326
109
122
1327
110
#endif /* MIR_CLIENT_PRIVATE_MIR_WAIT_HANDLE_H_ */
123
#endif /* MIR_CLIENT_PRIVATE_MIR_WAIT_HANDLE_H_ */
1328
111
124
1329
=== modified file 'src/server/CMakeLists.txt'
1330
--- src/server/CMakeLists.txt	2013-03-29 10:44:42 +0000
1331
+++ src/server/CMakeLists.txt	2013-04-03 18:49:21 +0000
1332
@@ -51,6 +51,7 @@
1333
51
  mirfrontend
51
  mirfrontend
1334
52
  mirgraphics
52
  mirgraphics
1335
53
  mirinput
53
  mirinput
1336
54
  mirinputandroidtransport
1337
54
  mirsurfaces
55
  mirsurfaces
1338
55
  mirtime
56
  mirtime
1339
56
)
57
)
1340
57
58
1341
=== modified file 'src/server/default_server_configuration.cpp'
1342
--- src/server/default_server_configuration.cpp	2013-03-28 14:20:06 +0000
1343
+++ src/server/default_server_configuration.cpp	2013-04-03 18:49:21 +0000
1344
@@ -44,6 +44,7 @@
1345
44
#include "mir/graphics/buffer_initializer.h"
44
#include "mir/graphics/buffer_initializer.h"
1346
45
#include "mir/graphics/null_display_report.h"
45
#include "mir/graphics/null_display_report.h"
1347
46
#include "mir/input/input_manager.h"
46
#include "mir/input/input_manager.h"
1348
47
#include "mir/input/null_input_manager.h"
1349
47
#include "mir/logging/logger.h"
48
#include "mir/logging/logger.h"
1350
48
#include "mir/logging/dumb_console_logger.h"
49
#include "mir/logging/dumb_console_logger.h"
1351
49
#include "mir/logging/glog_logger.h"
50
#include "mir/logging/glog_logger.h"
1352
@@ -140,6 +141,7 @@
1353
140
        "Environment variables capitalise long form with prefix \"MIR_SERVER_\" and \"_\" in place of \"-\"");
141
        "Environment variables capitalise long form with prefix \"MIR_SERVER_\" and \"_\" in place of \"-\"");
1354
141
    desc.add_options()
142
    desc.add_options()
1355
142
        ("file,f", po::value<std::string>(),    "Socket filename")
143
        ("file,f", po::value<std::string>(),    "Socket filename")
1356
144
        ("enable-input,i", po::value<bool>(),   "Enable input. [bool:default=false]")
1357
143
        (log_display, po::value<bool>(),        "Log the Display report. [bool:default=false]")
145
        (log_display, po::value<bool>(),        "Log the Display report. [bool:default=false]")
1358
144
        (log_app_mediator, po::value<bool>(),   "Log the ApplicationMediator report. [bool:default=false]")
146
        (log_app_mediator, po::value<bool>(),   "Log the ApplicationMediator report. [bool:default=false]")
1359
145
        (log_msg_processor, po::value<bool>(), "log the MessageProcessor report")
147
        (log_msg_processor, po::value<bool>(), "log the MessageProcessor report")
1360
@@ -316,9 +318,12 @@
1361
316
mir::DefaultServerConfiguration::the_input_manager()
318
mir::DefaultServerConfiguration::the_input_manager()
1362
317
{
319
{
1363
318
    return input_manager(
320
    return input_manager(
1365
319
        [&, this]()
321
        [&, this]() -> std::shared_ptr<mi::InputManager>
1366
320
        {
322
        {
1368
321
            return mi::create_input_manager(the_event_filters(), the_display());
323
            if (the_options()->get("enable-input", false))
1369
324
                return mi::create_input_manager(the_event_filters(), the_display());
1370
325
            else 
1371
326
                return std::make_shared<mi::NullInputManager>();
1372
322
        });
327
        });
1373
323
}
328
}
1374
324
329
1375
325
330
1376
=== modified file 'src/server/frontend/protobuf_message_processor.cpp'
1377
--- src/server/frontend/protobuf_message_processor.cpp	2013-03-22 03:33:00 +0000
1378
+++ src/server/frontend/protobuf_message_processor.cpp	2013-04-03 18:49:21 +0000
1379
@@ -73,12 +73,14 @@
1380
73
73
1381
74
void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Surface* response)
74
void mfd::ProtobufMessageProcessor::send_response(::google::protobuf::uint32 id, mir::protobuf::Surface* response)
1382
75
{
75
{
1384
76
    const auto& fd = response->has_buffer() ?
76
    auto const& surface_fd = extract_fds_from(response);
1385
77
    const auto& buffer_fd = response->has_buffer() ?
1386
77
        extract_fds_from(response->mutable_buffer()) :
78
        extract_fds_from(response->mutable_buffer()) :
1387
78
        std::vector<int32_t>();
79
        std::vector<int32_t>();
1388
79
80
1389
80
    send_response(id, static_cast<google::protobuf::Message*>(response));
81
    send_response(id, static_cast<google::protobuf::Message*>(response));
1391
81
    sender->send_fds(fd);
82
    sender->send_fds(surface_fd);
1392
83
    sender->send_fds(buffer_fd);
1393
82
    resource_cache->free_resource(response);
84
    resource_cache->free_resource(response);
1394
83
}
85
}
1395
84
86
1396
85
87
1397
=== modified file 'src/server/input/CMakeLists.txt'
1398
--- src/server/input/CMakeLists.txt	2013-03-13 04:54:15 +0000
1399
+++ src/server/input/CMakeLists.txt	2013-04-03 18:49:21 +0000
1400
@@ -4,14 +4,7 @@
1401
4
  event_filter_chain.cpp
4
  event_filter_chain.cpp
1402
5
)
5
)
1403
6
6
1404
7
if (NOT MIR_DISABLE_INPUT)
1405
8
add_subdirectory(android)
7
add_subdirectory(android)
1406
9
else()
1407
10
list(
1408
11
  APPEND INPUT_SOURCES
1409
12
  dummy_input_manager.cpp
1410
13
)
1411
14
endif()
1412
15
8
1413
16
add_library(
9
add_library(
1414
17
  mirinput STATIC
10
  mirinput STATIC
1415
18
11
1416
=== modified file 'src/server/input/android/CMakeLists.txt'
1417
--- src/server/input/android/CMakeLists.txt	2013-03-22 16:41:59 +0000
1418
+++ src/server/input/android/CMakeLists.txt	2013-04-03 18:49:21 +0000
1419
@@ -3,7 +3,6 @@
1420
3
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_manager.cpp
3
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_manager.cpp
1421
4
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_reader_policy.cpp
4
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_reader_policy.cpp
1422
5
  ${CMAKE_CURRENT_SOURCE_DIR}/android_pointer_controller.cpp
5
  ${CMAKE_CURRENT_SOURCE_DIR}/android_pointer_controller.cpp
1423
6
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_lexicon.cpp
1424
7
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_channel.cpp
6
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_channel.cpp
1425
8
  ${CMAKE_CURRENT_SOURCE_DIR}/rudimentary_input_reader_policy.cpp
7
  ${CMAKE_CURRENT_SOURCE_DIR}/rudimentary_input_reader_policy.cpp
1426
9
  ${CMAKE_CURRENT_SOURCE_DIR}/event_filter_dispatcher_policy.cpp
8
  ${CMAKE_CURRENT_SOURCE_DIR}/event_filter_dispatcher_policy.cpp
1427
@@ -18,3 +17,4 @@
1428
18
  PARENT_SCOPE
17
  PARENT_SCOPE
1429
19
)
18
)
1430
20
19
1431
20
add_subdirectory(transport)
1432
21
21
1433
=== modified file 'src/server/input/android/android_input_application_handle.cpp'
1434
--- src/server/input/android/android_input_application_handle.cpp	2013-03-20 22:42:09 +0000
1435
+++ src/server/input/android/android_input_application_handle.cpp	2013-04-03 18:49:21 +0000
1436
@@ -26,7 +26,7 @@
1437
26
namespace mia = mi::android;
26
namespace mia = mi::android;
1438
27
27
1439
28
mia::InputApplicationHandle::InputApplicationHandle(std::shared_ptr<mi::SessionTarget> const& session)
28
mia::InputApplicationHandle::InputApplicationHandle(std::shared_ptr<mi::SessionTarget> const& session)
1441
29
  : session(session)
29
  : weak_session(session)
1442
30
{
30
{
1443
31
    updateInfo();
31
    updateInfo();
1444
32
}
32
}
1445
@@ -35,6 +35,11 @@
1446
35
{
35
{
1447
36
    if (mInfo == NULL)
36
    if (mInfo == NULL)
1448
37
        mInfo = new droidinput::InputApplicationInfo;
37
        mInfo = new droidinput::InputApplicationInfo;
1449
38
    
1450
39
    auto session = weak_session.lock();
1451
40
    if (!session)
1452
41
        return false;
1453
42
1454
38
    mInfo->dispatchingTimeout = INT_MAX;
43
    mInfo->dispatchingTimeout = INT_MAX;
1455
39
    mInfo->name = droidinput::String8(session->name().c_str());
44
    mInfo->name = droidinput::String8(session->name().c_str());
1456
40
45
1457
41
46
1458
=== modified file 'src/server/input/android/android_input_application_handle.h'
1459
--- src/server/input/android/android_input_application_handle.h	2013-03-20 22:42:09 +0000
1460
+++ src/server/input/android/android_input_application_handle.h	2013-04-03 18:49:21 +0000
1461
@@ -48,7 +48,7 @@
1462
48
    InputApplicationHandle& operator=(InputApplicationHandle const&) = delete;
48
    InputApplicationHandle& operator=(InputApplicationHandle const&) = delete;
1463
49
49
1464
50
private:
50
private:
1466
51
    std::shared_ptr<input::SessionTarget> session;
51
    std::weak_ptr<input::SessionTarget> weak_session;
1467
52
};
52
};
1468
53
53
1469
54
}
54
}
1470
55
55
1471
=== modified file 'src/server/input/android/event_filter_dispatcher_policy.cpp'
1472
--- src/server/input/android/event_filter_dispatcher_policy.cpp	2013-03-22 16:41:59 +0000
1473
+++ src/server/input/android/event_filter_dispatcher_policy.cpp	2013-04-03 18:49:21 +0000
1474
@@ -16,10 +16,11 @@
1475
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1476
17
 */
17
 */
1477
18
#include "event_filter_dispatcher_policy.h"
18
#include "event_filter_dispatcher_policy.h"
1479
19
#include "android_input_lexicon.h"
19
#include "mir/input/android/android_input_lexicon.h"
1480
20
20
1481
21
namespace mi = mir::input;
21
namespace mi = mir::input;
1482
22
namespace mia = mi::android;
22
namespace mia = mi::android;
1483
23
namespace miat = mia::transport;
1484
23
24
1485
24
mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter) :
25
mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter) :
1486
25
  event_filter(event_filter)
26
  event_filter(event_filter)
1487
@@ -29,7 +30,7 @@
1488
29
bool mia::EventFilterDispatcherPolicy::filterInputEvent(const droidinput::InputEvent* input_event, uint32_t /*policy_flags*/)
30
bool mia::EventFilterDispatcherPolicy::filterInputEvent(const droidinput::InputEvent* input_event, uint32_t /*policy_flags*/)
1489
30
{
31
{
1490
31
    MirEvent mir_ev;
32
    MirEvent mir_ev;
1492
32
    mia::Lexicon::translate(input_event, mir_ev);
33
    miat::Lexicon::translate(input_event, mir_ev);
1493
33
34
1494
34
    if (event_filter->handles(mir_ev))
35
    if (event_filter->handles(mir_ev))
1495
35
        return false; /* Do not pass the event on */
36
        return false; /* Do not pass the event on */
1496
36
37
1497
=== added directory 'src/server/input/android/transport'
1498
=== added file 'src/server/input/android/transport/CMakeLists.txt'
1499
--- src/server/input/android/transport/CMakeLists.txt	1970-01-01 00:00:00 +0000
1500
+++ src/server/input/android/transport/CMakeLists.txt	2013-04-03 18:49:21 +0000
1501
@@ -0,0 +1,31 @@
1502
1
# Copyright © 2012 Canonical Ltd.
1503
2
#
1504
3
# This program is free software: you can redistribute it and/or modify
1505
4
# it under the terms of the GNU General Public License version 3 as
1506
5
# published by the Free Software Foundation.
1507
6
#
1508
7
# This program is distributed in the hope that it will be useful,
1509
8
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1510
9
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1511
10
# GNU General Public License for more details.
1512
11
#
1513
12
# You should have received a copy of the GNU General Public License
1514
13
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
1515
14
#
1516
15
# Authored by: Thomas Voss <thomas.voss@canonical.com>
1517
16
1518
17
set(
1519
18
  ANDROID_TRANSPORT_SOURCES
1520
19
  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_lexicon.cpp
1521
20
)
1522
21
1523
22
add_library(
1524
23
  mirinputandroidtransport STATIC
1525
24
  ${ANDROID_TRANSPORT_SOURCES}
1526
25
)
1527
26
1528
27
target_link_libraries(
1529
28
  mirinputandroidtransport
1530
29
  
1531
30
  android-input
1532
31
)
1533
0
32
1534
=== renamed file 'src/server/input/android/android_input_lexicon.cpp' => 'src/server/input/android/transport/android_input_lexicon.cpp'
1535
--- src/server/input/android/android_input_lexicon.cpp	2013-03-13 04:54:15 +0000
1536
+++ src/server/input/android/transport/android_input_lexicon.cpp	2013-04-03 18:49:21 +0000
1537
@@ -1,29 +1,29 @@
1538
1
/*
1
/*
1539
2
 * Copyright © 2012 Canonical Ltd.
2
 * Copyright © 2012 Canonical Ltd.
1540
3
 *
3
 *
1544
4
 * This program is free software: you can redistribute it and/or modify it
4
 * This program is free software: you can redistribute it and/or modify
1545
5
 * under the terms of the GNU Lesser General Public License version 3,
5
 * it under the terms of the GNU General Public License version 3 as
1546
6
 * as published by the Free Software Foundation.
6
 * published by the Free Software Foundation.
1547
7
 *
7
 *
1548
8
 * This program is distributed in the hope that it will be useful,
8
 * This program is distributed in the hope that it will be useful,
1549
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1550
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1551
11
 * GNU General Public License for more details.
11
 * GNU General Public License for more details.
1552
12
 *
12
 *
1554
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
1555
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/>.
1556
15
 *
15
 *
1557
16
 * Authored by: Thomas Voss <thomas.voss@canonical.com>
16
 * Authored by: Thomas Voss <thomas.voss@canonical.com>
1558
17
 *              Robert Carr <robert.carr@canonical.com>
17
 *              Robert Carr <robert.carr@canonical.com>
1559
18
 */
18
 */
1560
19
19
1562
20
#include "android_input_lexicon.h"
20
#include "mir/input/android/android_input_lexicon.h"
1563
21
21
1564
22
#include <androidfw/Input.h>
22
#include <androidfw/Input.h>
1565
23
23
1567
24
namespace mia = mir::input::android;
24
namespace miat = mir::input::android::transport;
1568
25
25
1570
26
void mia::Lexicon::translate(const droidinput::InputEvent *android_event, MirEvent &mir_event)
26
void miat::Lexicon::translate(const droidinput::InputEvent *android_event, MirEvent &mir_event)
1571
27
{
27
{
1572
28
    switch(android_event->getType())
28
    switch(android_event->getType())
1573
29
    {
29
    {
1574
30
30
1575
=== removed file 'src/server/input/dummy_input_manager.cpp'
1576
--- src/server/input/dummy_input_manager.cpp	2013-03-29 16:51:35 +0000
1577
+++ src/server/input/dummy_input_manager.cpp	1970-01-01 00:00:00 +0000
1578
@@ -1,42 +0,0 @@
1579
1
/*
1580
2
 * Copyright © 2012 Canonical Ltd.
1581
3
 *
1582
4
 * This program is free software: you can redistribute it and/or modify it
1583
5
 * under the terms of the GNU Lesser General Public License version 3,
1584
6
 * as published by the Free Software Foundation.
1585
7
 *
1586
8
 * This program is distributed in the hope that it will be useful,
1587
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1588
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1589
11
 * GNU General Public License for more details.
1590
12
 *
1591
13
 * You should have received a copy of the GNU Lesser General Public License
1592
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1593
15
 *
1594
16
 * Authored by: Alan Griffiths <alan@octopull.co.uk>
1595
17
 */
1596
18
1597
19
#include "mir/input/input_manager.h"
1598
20
1599
21
namespace mg = mir::graphics;
1600
22
namespace mi = mir::input;
1601
23
1602
24
namespace
1603
25
{
1604
26
class DummyInputManager : public mi::InputManager
1605
27
{
1606
28
    void stop() {}
1607
29
    void start() {}
1608
30
    virtual std::shared_ptr<mi::InputChannel> make_input_channel() { return std::shared_ptr<mi::InputChannel>(); }
1609
31
    void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */, std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
1610
32
    {
1611
33
    }
1612
34
};
1613
35
}
1614
36
1615
37
std::shared_ptr<mi::InputManager> mi::create_input_manager(
1616
38
    const std::initializer_list<std::shared_ptr<mi::EventFilter> const>& ,
1617
39
    std::shared_ptr<mg::ViewableArea> const& )
1618
40
{
1619
41
    return std::make_shared<DummyInputManager>();
1620
42
}
1621
43
0
1622
=== modified file 'tests/acceptance-tests/CMakeLists.txt'
1623
--- tests/acceptance-tests/CMakeLists.txt	2013-03-29 22:30:35 +0000
1624
+++ tests/acceptance-tests/CMakeLists.txt	2013-04-03 18:49:21 +0000
1625
@@ -13,6 +13,9 @@
1626
13
)
13
)
1627
14
14
1628
15
list(APPEND SOURCES
15
list(APPEND SOURCES
1629
16
  test_client_input.cpp)
1630
17
1631
18
list(APPEND SOURCES
1632
16
  test_server_startup.cpp
19
  test_server_startup.cpp
1633
17
)
20
)
1634
18
21
1635
@@ -21,6 +24,7 @@
1636
21
24
1637
22
  ${SOURCES}
25
  ${SOURCES}
1638
23
)
26
)
1639
27
uses_android_input(acceptance-tests)
1640
24
28
1641
25
29
1642
26
target_link_libraries(
30
target_link_libraries(
1643
27
31
1644
=== added file 'tests/acceptance-tests/test_client_input.cpp'
1645
--- tests/acceptance-tests/test_client_input.cpp	1970-01-01 00:00:00 +0000
1646
+++ tests/acceptance-tests/test_client_input.cpp	2013-04-03 18:49:21 +0000
1647
@@ -0,0 +1,268 @@
1648
1
/*
1649
2
 * Copyright © 2013 Canonical Ltd.
1650
3
 *
1651
4
 * This program is free software: you can redistribute it and/or modify
1652
5
 * it under the terms of the GNU General Public License version 3 as
1653
6
 * published by the Free Software Foundation.
1654
7
 *
1655
8
 * This program is distributed in the hope that it will be useful,
1656
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1657
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1658
11
 * GNU General Public License for more details.
1659
12
 *
1660
13
 * You should have received a copy of the GNU General Public License
1661
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1662
15
 *
1663
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1664
17
 */
1665
18
1666
19
#include "mir/graphics/display.h"
1667
20
1668
21
#include "src/server/input/android/android_input_manager.h"
1669
22
1670
23
#include "mir_toolkit/mir_client_library.h"
1671
24
1672
25
#include "mir_test/fake_shared.h"
1673
26
#include "mir_test/fake_event_hub_input_configuration.h"
1674
27
#include "mir_test/fake_event_hub.h"
1675
28
#include "mir_test/event_factory.h"
1676
29
#include "mir_test/wait_condition.h"
1677
30
#include "mir_test_framework/display_server_test_fixture.h"
1678
31
1679
32
#include <gtest/gtest.h>
1680
33
#include <gmock/gmock.h>
1681
34
1682
35
#include <thread>
1683
36
#include <functional>
1684
37
1685
38
namespace mi = mir::input;
1686
39
namespace mia = mi::android;
1687
40
namespace mis = mi::synthesis;
1688
41
namespace mt = mir::test;
1689
42
namespace mtd = mt::doubles;
1690
43
namespace mtf = mir_test_framework;
1691
44
1692
45
namespace
1693
46
{
1694
47
    char const* const mir_test_socket = mtf::test_socket_file().c_str();
1695
48
}
1696
49
1697
50
namespace
1698
51
{
1699
52
1700
53
struct FocusNotifyingInputManager : public mia::InputManager
1701
54
{
1702
55
    FocusNotifyingInputManager(std::shared_ptr<mia::InputConfiguration> const& configuration,
1703
56
                               mt::WaitCondition &wait_condition)
1704
57
      : InputManager(configuration),
1705
58
        on_focus_set(wait_condition)
1706
59
    {
1707
60
1708
61
    }
1709
62
    
1710
63
    void set_input_focus_to(
1711
64
        std::shared_ptr<mi::SessionTarget> const& session, std::shared_ptr<mi::SurfaceTarget> const& surface) override
1712
65
    {
1713
66
        InputManager::set_input_focus_to(session, surface);
1714
67
        
1715
68
        // We need a synchronization primitive inorder to halt test event injection
1716
69
        // until after a surface has taken focus (lest the events be discarded).
1717
70
        if (surface)
1718
71
            on_focus_set.wake_up_everyone();
1719
72
    }
1720
73
1721
74
    mt::WaitCondition &on_focus_set;
1722
75
};
1723
76
1724
77
struct FakeInputServerConfiguration : public mir_test_framework::TestingServerConfiguration
1725
78
{
1726
79
    FakeInputServerConfiguration()
1727
80
      : input_config(the_event_filters(), the_display(), std::shared_ptr<mi::CursorListener>())
1728
81
    {
1729
82
    }
1730
83
1731
84
    virtual void inject_input()
1732
85
    {
1733
86
    }
1734
87
    
1735
88
    void exec(mir::DisplayServer* /* display_server */) override
1736
89
    {
1737
90
        input_injection_thread = std::thread([this]() -> void
1738
91
        {
1739
92
            on_focus_set.wait_for_at_most_seconds(10);
1740
93
            fake_event_hub->synthesize_builtin_keyboard_added();
1741
94
            fake_event_hub->synthesize_device_scan_complete();
1742
95
            inject_input();
1743
96
        });
1744
97
    }
1745
98
    
1746
99
    void on_exit() override
1747
100
    {
1748
101
        input_injection_thread.join();
1749
102
    }
1750
103
1751
104
    std::shared_ptr<mi::InputManager>
1752
105
    the_input_manager() override
1753
106
    {
1754
107
        fake_event_hub = input_config.the_fake_event_hub();
1755
108
1756
109
        return input_manager(
1757
110
        [this]() -> std::shared_ptr<mi::InputManager>
1758
111
        {
1759
112
            return std::make_shared<FocusNotifyingInputManager>(mt::fake_shared(input_config), on_focus_set);
1760
113
        });
1761
114
    }
1762
115
1763
116
    mtd::FakeEventHubInputConfiguration input_config;
1764
117
    mia::FakeEventHub* fake_event_hub;
1765
118
    mt::WaitCondition on_focus_set;
1766
119
    std::thread input_injection_thread;
1767
120
};
1768
121
1769
122
1770
123
struct ClientConfigCommon : TestingClientConfiguration
1771
124
{
1772
125
    ClientConfigCommon() :
1773
126
        connection(0),
1774
127
        surface(0)
1775
128
    {
1776
129
    }
1777
130
1778
131
    static void connection_callback(MirConnection* connection, void* context)
1779
132
    {
1780
133
        ClientConfigCommon* config = reinterpret_cast<ClientConfigCommon *>(context);
1781
134
        config->connection = connection;
1782
135
    }
1783
136
1784
137
    static void create_surface_callback(MirSurface* surface, void* context)
1785
138
    {
1786
139
        ClientConfigCommon* config = reinterpret_cast<ClientConfigCommon *>(context);
1787
140
        config->surface_created(surface);
1788
141
    }
1789
142
1790
143
    static void release_surface_callback(MirSurface* surface, void* context)
1791
144
    {
1792
145
        ClientConfigCommon* config = reinterpret_cast<ClientConfigCommon *>(context);
1793
146
        config->surface_released(surface);
1794
147
    }
1795
148
1796
149
    virtual void connected(MirConnection* new_connection)
1797
150
    {
1798
151
        connection = new_connection;
1799
152
    }
1800
153
1801
154
    virtual void surface_created(MirSurface* new_surface)
1802
155
    {
1803
156
        surface = new_surface;
1804
157
    }
1805
158
1806
159
    virtual void surface_released(MirSurface* /* released_surface */)
1807
160
    {
1808
161
        surface = NULL;
1809
162
    }
1810
163
1811
164
    MirConnection* connection;
1812
165
    MirSurface* surface;
1813
166
};
1814
167
1815
168
struct MockInputHandler
1816
169
{
1817
170
    MOCK_METHOD1(handle_input, void(MirEvent *));
1818
171
};
1819
172
1820
173
struct InputReceivingClient : ClientConfigCommon
1821
174
{
1822
175
    InputReceivingClient()
1823
176
      : events_received(0)
1824
177
    {
1825
178
    }
1826
179
1827
180
    static void handle_input(MirSurface* /* surface */, MirEvent* ev, void* context)
1828
181
    {
1829
182
        auto client = static_cast<InputReceivingClient *>(context);
1830
183
        client->handler->handle_input(ev);
1831
184
        client->event_received[client->events_received].wake_up_everyone();
1832
185
        client->events_received++;
1833
186
    }
1834
187
    virtual void expect_input()
1835
188
    {
1836
189
    }
1837
190
1838
191
    void exec()
1839
192
    {
1840
193
        handler = std::make_shared<MockInputHandler>();
1841
194
1842
195
        expect_input();
1843
196
1844
197
        mir_wait_for(mir_connect(
1845
198
            mir_test_socket,
1846
199
            __PRETTY_FUNCTION__,
1847
200
            connection_callback,
1848
201
            this));
1849
202
         ASSERT_TRUE(connection != NULL);
1850
203
         MirSurfaceParameters const request_params =
1851
204
         {
1852
205
             __PRETTY_FUNCTION__,
1853
206
             640, 480,
1854
207
             mir_pixel_format_abgr_8888,
1855
208
             mir_buffer_usage_hardware
1856
209
         };
1857
210
         MirEventDelegate const event_delegate =
1858
211
         {
1859
212
             handle_input,
1860
213
             this
1861
214
         };
1862
215
         mir_wait_for(mir_surface_create(connection, &request_params, &event_delegate, create_surface_callback, this));
1863
216
1864
217
         event_received[0].wait_for_at_most_seconds(5);
1865
218
         event_received[1].wait_for_at_most_seconds(5);
1866
219
         event_received[2].wait_for_at_most_seconds(5);
1867
220
1868
221
         mir_surface_release_sync(surface);
1869
222
         
1870
223
         mir_connection_release(connection);
1871
224
1872
225
         // ClientConfiguration d'tor is not called on client side so we need this
1873
226
         // in order to not leak the Mock object.
1874
227
         handler.reset(); 
1875
228
    }
1876
229
    
1877
230
    std::shared_ptr<MockInputHandler> handler;
1878
231
    mt::WaitCondition event_received[3];
1879
232
    int events_received;
1880
233
};
1881
234
1882
235
}
1883
236
1884
237
using TestClientInput = BespokeDisplayServerTestFixture;
1885
238
1886
239
TEST_F(TestClientInput, clients_receive_key_input)
1887
240
{
1888
241
    using namespace ::testing;
1889
242
    
1890
243
    int const num_events_produced = 3;
1891
244
1892
245
    struct InputProducingServerConfiguration : FakeInputServerConfiguration
1893
246
    {
1894
247
        void inject_input()
1895
248
        {
1896
249
            // We send multiple events in order to verify the client is handling them
1897
250
            // and server dispatch does not become backed up.
1898
251
            for (int i = 0; i < num_events_produced; i++)
1899
252
                fake_event_hub->synthesize_event(mis::a_key_down_event()
1900
253
                                                 .of_scancode(KEY_ENTER));
1901
254
        }
1902
255
    } server_config;
1903
256
    launch_server_process(server_config);
1904
257
    
1905
258
    struct KeyReceivingClient : InputReceivingClient
1906
259
    {
1907
260
        void expect_input()
1908
261
        {
1909
262
            using namespace ::testing;
1910
263
            EXPECT_CALL(*handler, handle_input(_)).Times(num_events_produced);
1911
264
        }
1912
265
    } client_config;
1913
266
    launch_client_process(client_config);
1914
267
}
1915
268
1916
0
269
1917
=== modified file 'tests/acceptance-tests/test_client_library.cpp'
1918
--- tests/acceptance-tests/test_client_library.cpp	2013-03-22 10:34:16 +0000
1919
+++ tests/acceptance-tests/test_client_library.cpp	2013-04-03 18:49:21 +0000
1920
@@ -164,7 +164,7 @@
1921
164
                mir_buffer_usage_hardware
164
                mir_buffer_usage_hardware
1922
165
            };
165
            };
1923
166
166
1925
167
            mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
167
            mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
1926
168
168
1927
169
            ASSERT_TRUE(surface != NULL);
169
            ASSERT_TRUE(surface != NULL);
1928
170
            EXPECT_TRUE(mir_surface_is_valid(surface));
170
            EXPECT_TRUE(mir_surface_is_valid(surface));
1929
@@ -182,7 +182,7 @@
1930
182
182
1931
183
            ASSERT_TRUE(surface == NULL);
183
            ASSERT_TRUE(surface == NULL);
1932
184
184
1934
185
            surface = mir_surface_create_sync(connection, &request_params);
185
            surface = mir_surface_create_sync(connection, &request_params, NULL);
1935
186
186
1936
187
            ASSERT_TRUE(surface != NULL);
187
            ASSERT_TRUE(surface != NULL);
1937
188
            EXPECT_TRUE(mir_surface_is_valid(surface));
188
            EXPECT_TRUE(mir_surface_is_valid(surface));
1938
@@ -226,7 +226,7 @@
1939
226
                mir_buffer_usage_hardware
226
                mir_buffer_usage_hardware
1940
227
            };
227
            };
1941
228
228
1943
229
            mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
229
            mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
1944
230
230
1945
231
            ASSERT_TRUE(surface != NULL);
231
            ASSERT_TRUE(surface != NULL);
1946
232
            EXPECT_TRUE(mir_surface_is_valid(surface));
232
            EXPECT_TRUE(mir_surface_is_valid(surface));
1947
@@ -329,7 +329,7 @@
1948
329
                    mir_buffer_usage_hardware
329
                    mir_buffer_usage_hardware
1949
330
                };
330
                };
1950
331
331
1952
332
                mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
332
                mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
1953
333
333
1954
334
                ASSERT_EQ(old_surface_count + 1, current_surface_count());
334
                ASSERT_EQ(old_surface_count + 1, current_surface_count());
1955
335
            }
335
            }
1956
@@ -377,7 +377,7 @@
1957
377
                mir_buffer_usage_hardware
377
                mir_buffer_usage_hardware
1958
378
            };
378
            };
1959
379
379
1961
380
            mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
380
            mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
1962
381
            ASSERT_TRUE(surface != NULL);
381
            ASSERT_TRUE(surface != NULL);
1963
382
382
1964
383
            buffers = 0;
383
            buffers = 0;
1965
@@ -416,7 +416,7 @@
1966
416
                mir_buffer_usage_software
416
                mir_buffer_usage_software
1967
417
            };
417
            };
1968
418
418
1970
419
            surface = mir_surface_create_sync(connection, &request_params);
419
            surface = mir_surface_create_sync(connection, &request_params, NULL);
1971
420
            ASSERT_TRUE(surface != NULL);
420
            ASSERT_TRUE(surface != NULL);
1972
421
            EXPECT_TRUE(mir_surface_is_valid(surface));
421
            EXPECT_TRUE(mir_surface_is_valid(surface));
1973
422
            EXPECT_STREQ(mir_surface_get_error_message(surface), "");
422
            EXPECT_STREQ(mir_surface_get_error_message(surface), "");
1974
@@ -524,7 +524,7 @@
1975
524
                mir_buffer_usage_hardware
524
                mir_buffer_usage_hardware
1976
525
            };
525
            };
1977
526
526
1979
527
            mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
527
            mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
1980
528
// TODO surface_create needs to fail safe too. After that is done we should add the following:
528
// TODO surface_create needs to fail safe too. After that is done we should add the following:
1981
529
// TODO    mir_wait_for(mir_surface_next_buffer(surface, next_buffer_callback, this));
529
// TODO    mir_wait_for(mir_surface_next_buffer(surface, next_buffer_callback, this));
1982
530
// TODO    mir_wait_for(mir_surface_release( surface, release_surface_callback, this));
530
// TODO    mir_wait_for(mir_surface_release( surface, release_surface_callback, this));
1983
531
531
1984
=== modified file 'tests/acceptance-tests/test_focus_management_api.cpp'
1985
--- tests/acceptance-tests/test_focus_management_api.cpp	2013-03-22 10:34:16 +0000
1986
+++ tests/acceptance-tests/test_focus_management_api.cpp	2013-04-03 18:49:21 +0000
1987
@@ -226,7 +226,7 @@
1988
226
                mir_buffer_usage_hardware
226
                mir_buffer_usage_hardware
1989
227
            };
227
            };
1990
228
228
1992
229
            mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
229
            mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
1993
230
230
1994
231
            set_flag(focus_ready);
231
            set_flag(focus_ready);
1995
232
232
1996
233
233
1997
=== modified file 'tests/acceptance-tests/test_focus_selection.cpp'
1998
--- tests/acceptance-tests/test_focus_selection.cpp	2013-03-29 16:51:35 +0000
1999
+++ tests/acceptance-tests/test_focus_selection.cpp	2013-04-03 18:49:21 +0000
2000
@@ -108,7 +108,7 @@
2001
108
            mir_pixel_format_abgr_8888,
108
            mir_pixel_format_abgr_8888,
2002
109
            mir_buffer_usage_hardware
109
            mir_buffer_usage_hardware
2003
110
        };
110
        };
2005
111
         mir_wait_for(mir_surface_create(connection, &request_params, create_surface_callback, this));
111
         mir_wait_for(mir_surface_create(connection, &request_params, NULL, create_surface_callback, this));
2006
112
         mir_connection_release(connection);
112
         mir_connection_release(connection);
2007
113
    }
113
    }
2008
114
};
114
};
2009
115
115
2010
=== modified file 'tests/acceptance-tests/test_surfaceloop.cpp'
2011
--- tests/acceptance-tests/test_surfaceloop.cpp	2013-03-22 10:34:16 +0000
2012
+++ tests/acceptance-tests/test_surfaceloop.cpp	2013-04-03 18:49:21 +0000
2013
@@ -172,13 +172,13 @@
2014
172
                mir_buffer_usage_hardware
172
                mir_buffer_usage_hardware
2015
173
            };
173
            };
2016
174
174
2018
175
            mir_surface_create(connection, &request_params, create_surface_callback, ssync);
175
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync);
2019
176
            wait_for_surface_create(ssync);
176
            wait_for_surface_create(ssync);
2020
177
177
2021
178
            request_params.width = 1600;
178
            request_params.width = 1600;
2022
179
            request_params.height = 1200;
179
            request_params.height = 1200;
2023
180
180
2025
181
            mir_surface_create(connection, &request_params, create_surface_callback, ssync+1);
181
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync+1);
2026
182
            wait_for_surface_create(ssync+1);
182
            wait_for_surface_create(ssync+1);
2027
183
183
2028
184
            MirSurfaceParameters response_params;
184
            MirSurfaceParameters response_params;
2029
@@ -225,13 +225,13 @@
2030
225
                mir_buffer_usage_hardware
225
                mir_buffer_usage_hardware
2031
226
            };
226
            };
2032
227
227
2034
228
            mir_surface_create(connection, &request_params, create_surface_callback, ssync);
228
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync);
2035
229
            wait_for_surface_create(ssync);
229
            wait_for_surface_create(ssync);
2036
230
230
2037
231
            request_params.width = 1600;
231
            request_params.width = 1600;
2038
232
            request_params.height = 1200;
232
            request_params.height = 1200;
2039
233
233
2041
234
            mir_surface_create(connection, &request_params, create_surface_callback, ssync+1);
234
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync+1);
2042
235
            wait_for_surface_create(ssync+1);
235
            wait_for_surface_create(ssync+1);
2043
236
236
2044
237
            EXPECT_NE(
237
            EXPECT_NE(
2045
@@ -270,7 +270,7 @@
2046
270
            };
270
            };
2047
271
271
2048
272
            for (int i = 0; i != max_surface_count; ++i)
272
            for (int i = 0; i != max_surface_count; ++i)
2050
273
                mir_surface_create(connection, &request_params, create_surface_callback, ssync+i);
273
                mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync+i);
2051
274
274
2052
275
            for (int i = 0; i != max_surface_count; ++i)
275
            for (int i = 0; i != max_surface_count; ++i)
2053
276
                wait_for_surface_create(ssync+i);
276
                wait_for_surface_create(ssync+i);
2054
277
277
2055
=== modified file 'tests/integration-tests/CMakeLists.txt'
2056
--- tests/integration-tests/CMakeLists.txt	2013-03-29 22:30:35 +0000
2057
+++ tests/integration-tests/CMakeLists.txt	2013-04-03 18:49:21 +0000
2058
@@ -12,9 +12,7 @@
2059
12
add_subdirectory(frontend/)
12
add_subdirectory(frontend/)
2060
13
add_subdirectory(shell/)
13
add_subdirectory(shell/)
2061
14
add_subdirectory(process/)
14
add_subdirectory(process/)
2062
15
if (NOT MIR_DISABLE_INPUT)
2063
16
add_subdirectory(input/)
15
add_subdirectory(input/)
2064
17
endif()
2065
18
16
2066
19
if (MIR_PLATFORM STREQUAL "android")
17
if (MIR_PLATFORM STREQUAL "android")
2067
20
  include_directories(${PROJECT_SOURCE_DIR}/include/accessory)
18
  include_directories(${PROJECT_SOURCE_DIR}/include/accessory)
2068
21
19
2069
=== modified file 'tests/integration-tests/client/test_client_render.cpp'
2070
--- tests/integration-tests/client/test_client_render.cpp	2013-03-29 16:51:35 +0000
2071
+++ tests/integration-tests/client/test_client_render.cpp	2013-04-03 18:49:21 +0000
2072
@@ -102,8 +102,8 @@
2073
102
        surface_parameters.width = test_width;
102
        surface_parameters.width = test_width;
2074
103
        surface_parameters.height = test_height;
103
        surface_parameters.height = test_height;
2075
104
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
104
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
2078
105
        mir_wait_for(mir_surface_create( connection, &surface_parameters,
105
        mir_wait_for(mir_surface_create(connection, &surface_parameters,
2079
106
                                          &create_callback, &surface));
106
                                        NULL, &create_callback, &surface));
2080
107
107
2081
108
        auto graphics_region = std::make_shared<MirGraphicsRegion>();
108
        auto graphics_region = std::make_shared<MirGraphicsRegion>();
2082
109
        /* grab a buffer*/
109
        /* grab a buffer*/
2083
@@ -143,8 +143,8 @@
2084
143
        surface_parameters.height = test_height;
143
        surface_parameters.height = test_height;
2085
144
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
144
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
2086
145
145
2089
146
        mir_wait_for(mir_surface_create( connection, &surface_parameters,
146
        mir_wait_for(mir_surface_create(connection, &surface_parameters,
2090
147
                                          &create_callback, &surface));
147
                                        NULL, &create_callback, &surface));
2091
148
148
2092
149
        auto graphics_region = std::make_shared<MirGraphicsRegion>();
149
        auto graphics_region = std::make_shared<MirGraphicsRegion>();
2093
150
        mir_surface_get_graphics_region( surface, graphics_region.get());
150
        mir_surface_get_graphics_region( surface, graphics_region.get());
2094
@@ -187,8 +187,8 @@
2095
187
        surface_parameters.height = test_height;
187
        surface_parameters.height = test_height;
2096
188
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
188
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
2097
189
189
2100
190
        mir_wait_for(mir_surface_create( connection, &surface_parameters,
190
        mir_wait_for(mir_surface_create(connection, &surface_parameters,
2101
191
                                          &create_callback, &surface));
191
                                        NULL, &create_callback, &surface));
2102
192
192
2103
193
        int major, minor, n;
193
        int major, minor, n;
2104
194
        EGLDisplay disp;
194
        EGLDisplay disp;
2105
@@ -249,8 +249,8 @@
2106
249
        surface_parameters.height = test_height;
249
        surface_parameters.height = test_height;
2107
250
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
250
        surface_parameters.pixel_format = mir_pixel_format_abgr_8888;
2108
251
251
2111
252
        mir_wait_for(mir_surface_create( connection, &surface_parameters,
252
        mir_wait_for(mir_surface_create(connection, &surface_parameters,
2112
253
                                          &create_callback, &surface));
253
                                        NULL, &create_callback, &surface));
2113
254
254
2114
255
        int major, minor, n;
255
        int major, minor, n;
2115
256
        EGLDisplay disp;
256
        EGLDisplay disp;
2116
257
257
2117
=== modified file 'tests/integration-tests/input/android/test_android_cursor_listener.cpp'
2118
--- tests/integration-tests/input/android/test_android_cursor_listener.cpp	2013-03-13 08:09:52 +0000
2119
+++ tests/integration-tests/input/android/test_android_cursor_listener.cpp	2013-04-03 18:49:21 +0000
2120
@@ -44,7 +44,6 @@
2121
44
namespace mtd = mir::test::doubles;
44
namespace mtd = mir::test::doubles;
2122
45
45
2123
46
using mtd::MockEventFilter;
46
using mtd::MockEventFilter;
2124
47
using mir::WaitCondition;
2125
48
47
2126
49
namespace
48
namespace
2127
50
{
49
{
2128
@@ -100,7 +99,7 @@
2129
100
{
99
{
2130
101
    using namespace ::testing;
100
    using namespace ::testing;
2131
102
101
2133
103
    auto wait_condition = std::make_shared<WaitCondition>();
102
    auto wait_condition = std::make_shared<mt::WaitCondition>();
2134
104
103
2135
105
    static const float x = 100.f;
104
    static const float x = 100.f;
2136
106
    static const float y = 100.f;
105
    static const float y = 100.f;
2137
@@ -109,7 +108,7 @@
2138
109
108
2139
110
    // The stack doesn't like shutting down while events are still moving through
109
    // The stack doesn't like shutting down while events are still moving through
2140
111
    EXPECT_CALL(event_filter, handles(_))
110
    EXPECT_CALL(event_filter, handles(_))
2142
112
            .WillOnce(ReturnFalseAndWakeUp(wait_condition));
111
            .WillOnce(mt::ReturnFalseAndWakeUp(wait_condition));
2143
113
112
2144
114
    fake_event_hub->synthesize_builtin_cursor_added();
113
    fake_event_hub->synthesize_builtin_cursor_added();
2145
115
    fake_event_hub->synthesize_device_scan_complete();
114
    fake_event_hub->synthesize_device_scan_complete();
2146
116
115
2147
=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
2148
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-02 16:40:08 +0000
2149
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-03 18:49:21 +0000
2150
@@ -53,7 +53,6 @@
2151
53
namespace mtd = mir::test::doubles;
53
namespace mtd = mir::test::doubles;
2152
54
54
2153
55
using mtd::MockEventFilter;
55
using mtd::MockEventFilter;
2154
56
using mir::WaitCondition;
2155
57
56
2156
58
namespace
57
namespace
2157
59
{
58
{
2158
@@ -100,13 +99,13 @@
2159
100
{
99
{
2160
101
    using namespace ::testing;
100
    using namespace ::testing;
2161
102
101
2163
103
    WaitCondition wait_condition;
102
    mt::WaitCondition wait_condition;
2164
104
103
2165
105
    EXPECT_CALL(
104
    EXPECT_CALL(
2166
106
        event_filter,
105
        event_filter,
2167
107
        handles(mt::KeyDownEvent()))
106
        handles(mt::KeyDownEvent()))
2168
108
            .Times(1)
107
            .Times(1)
2170
109
            .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
108
            .WillOnce(mt::ReturnFalseAndWakeUp(&wait_condition));
2171
110
109
2172
111
    fake_event_hub->synthesize_builtin_keyboard_added();
110
    fake_event_hub->synthesize_builtin_keyboard_added();
2173
112
    fake_event_hub->synthesize_device_scan_complete();
111
    fake_event_hub->synthesize_device_scan_complete();
2174
@@ -121,13 +120,13 @@
2175
121
{
120
{
2176
122
    using namespace ::testing;
121
    using namespace ::testing;
2177
123
122
2179
124
    WaitCondition wait_condition;
123
    mt::WaitCondition wait_condition;
2180
125
124
2181
126
    EXPECT_CALL(
125
    EXPECT_CALL(
2182
127
        event_filter,
126
        event_filter,
2183
128
        handles(mt::ButtonDownEvent()))
127
        handles(mt::ButtonDownEvent()))
2184
129
            .Times(1)
128
            .Times(1)
2186
130
            .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
129
            .WillOnce(mt::ReturnFalseAndWakeUp(&wait_condition));
2187
131
130
2188
132
    fake_event_hub->synthesize_builtin_cursor_added();
131
    fake_event_hub->synthesize_builtin_cursor_added();
2189
133
    fake_event_hub->synthesize_device_scan_complete();
132
    fake_event_hub->synthesize_device_scan_complete();
2190
@@ -141,7 +140,7 @@
2191
141
{
140
{
2192
142
    using namespace ::testing;
141
    using namespace ::testing;
2193
143
142
2195
144
    WaitCondition wait_condition;
143
    mt::WaitCondition wait_condition;
2196
145
144
2197
146
    // We get absolute motion events since we have a pointer controller.
145
    // We get absolute motion events since we have a pointer controller.
2198
147
    {
146
    {
2199
@@ -152,7 +151,7 @@
2200
152
            .WillOnce(Return(false));
151
            .WillOnce(Return(false));
2201
153
        EXPECT_CALL(event_filter,
152
        EXPECT_CALL(event_filter,
2202
154
                    handles(mt::MotionEvent(200, 100)))
153
                    handles(mt::MotionEvent(200, 100)))
2204
155
            .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
154
            .WillOnce(mt::ReturnFalseAndWakeUp(&wait_condition));
2205
156
    }
155
    }
2206
157
156
2207
158
    fake_event_hub->synthesize_builtin_cursor_added();
157
    fake_event_hub->synthesize_builtin_cursor_added();
2208
@@ -253,7 +252,7 @@
2209
253
{
252
{
2210
254
    using namespace ::testing;
253
    using namespace ::testing;
2211
255
254
2213
256
    WaitCondition wait_condition;
255
    mt::WaitCondition wait_condition;
2214
257
256
2215
258
    mtd::StubSessionTarget session;
257
    mtd::StubSessionTarget session;
2216
259
    mtd::StubSurfaceTarget surface(test_input_fd);
258
    mtd::StubSurfaceTarget surface(test_input_fd);
2217
@@ -261,7 +260,7 @@
2218
261
    EXPECT_CALL(event_filter, handles(_)).Times(1).WillOnce(Return(false));
260
    EXPECT_CALL(event_filter, handles(_)).Times(1).WillOnce(Return(false));
2219
262
    // We return -1 here to skip publishing of the event (to an unconnected test socket!).
261
    // We return -1 here to skip publishing of the event (to an unconnected test socket!).
2220
263
    EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(test_input_fd), _, _))
262
    EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(test_input_fd), _, _))
2222
264
        .Times(1).WillOnce(DoAll(WakeUp(&wait_condition), Return(-1)));
263
        .Times(1).WillOnce(DoAll(mt::WakeUp(&wait_condition), Return(-1)));
2223
265
264
2224
266
    input_manager->set_input_focus_to(mt::fake_shared(session), mt::fake_shared(surface));
265
    input_manager->set_input_focus_to(mt::fake_shared(session), mt::fake_shared(surface));
2225
267
266
2226
268
267
2227
=== modified file 'tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp'
2228
--- tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-02 16:40:08 +0000
2229
+++ tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-03 18:49:21 +0000
2230
@@ -95,16 +95,15 @@
2231
95
}
95
}
2232
96
96
2233
97
using mir::FakeEventHubSetup;
97
using mir::FakeEventHubSetup;
2234
98
using mir::WaitCondition;
2235
99
98
2236
100
TEST_F(FakeEventHubSetup, fake_event_hub_dispatches_to_filter)
99
TEST_F(FakeEventHubSetup, fake_event_hub_dispatches_to_filter)
2237
101
{
100
{
2238
102
    using namespace ::testing;
101
    using namespace ::testing;
2239
103
102
2241
104
    mir::WaitCondition wait_condition;
103
    mt::WaitCondition wait_condition;
2242
105
104
2243
106
    EXPECT_CALL(event_filter, handles(mt::KeyDownEvent())).Times(1)
105
    EXPECT_CALL(event_filter, handles(mt::KeyDownEvent())).Times(1)
2245
107
        .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
106
        .WillOnce(mt::ReturnFalseAndWakeUp(&wait_condition));
2246
108
107
2247
109
    event_hub->synthesize_builtin_keyboard_added();
108
    event_hub->synthesize_builtin_keyboard_added();
2248
110
    event_hub->synthesize_device_scan_complete();
109
    event_hub->synthesize_device_scan_complete();
2249
111
110
2250
=== modified file 'tests/integration-tests/test_error_reporting.cpp'
2251
--- tests/integration-tests/test_error_reporting.cpp	2013-03-22 10:34:16 +0000
2252
+++ tests/integration-tests/test_error_reporting.cpp	2013-04-03 18:49:21 +0000
2253
@@ -238,7 +238,7 @@
2254
238
                mir_buffer_usage_hardware
238
                mir_buffer_usage_hardware
2255
239
            };
239
            };
2256
240
240
2258
241
            mir_surface_create(connection, &request_params, create_surface_callback, ssync);
241
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync);
2259
242
242
2260
243
            wait_for_surface_create(ssync);
243
            wait_for_surface_create(ssync);
2261
244
244
2262
245
245
2263
=== modified file 'tests/integration-tests/test_surfaceloop.cpp'
2264
--- tests/integration-tests/test_surfaceloop.cpp	2013-03-25 10:18:17 +0000
2265
+++ tests/integration-tests/test_surfaceloop.cpp	2013-04-03 18:49:21 +0000
2266
@@ -286,7 +286,7 @@
2267
286
                mir_buffer_usage_hardware
286
                mir_buffer_usage_hardware
2268
287
            };
287
            };
2269
288
288
2271
289
            mir_surface_create(connection, &request_params, create_surface_callback, ssync);
289
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync);
2272
290
290
2273
291
            wait_for_surface_create(ssync);
291
            wait_for_surface_create(ssync);
2274
292
292
2275
@@ -388,7 +388,7 @@
2276
388
                mir_pixel_format_abgr_8888,
388
                mir_pixel_format_abgr_8888,
2277
389
                mir_buffer_usage_hardware
389
                mir_buffer_usage_hardware
2278
390
            };
390
            };
2280
391
            mir_surface_create(connection, &request_params, create_surface_callback, ssync);
391
            mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync);
2281
392
392
2282
393
            wait_for_surface_create(ssync);
393
            wait_for_surface_create(ssync);
2283
394
394
2284
@@ -522,7 +522,7 @@
2285
522
            };
522
            };
2286
523
523
2287
524
            for (int i = 0; i != max_surface_count; ++i)
524
            for (int i = 0; i != max_surface_count; ++i)
2289
525
                mir_surface_create(connection, &request_params, create_surface_callback, ssync+i);
525
                mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync+i);
2290
526
526
2291
527
            for (int i = 0; i != max_surface_count; ++i)
527
            for (int i = 0; i != max_surface_count; ++i)
2292
528
                wait_for_surface_create(ssync+i);
528
                wait_for_surface_create(ssync+i);
2293
@@ -571,7 +571,7 @@
2294
571
            };
571
            };
2295
572
572
2296
573
            for (int i = 0; i != max_surface_count; ++i)
573
            for (int i = 0; i != max_surface_count; ++i)
2298
574
                mir_surface_create(connection, &request_params, create_surface_callback, ssync+i);
574
                mir_surface_create(connection, &request_params, NULL, create_surface_callback, ssync+i);
2299
575
575
2300
576
            for (int i = 0; i != max_surface_count; ++i)
576
            for (int i = 0; i != max_surface_count; ++i)
2301
577
                wait_for_surface_create(ssync+i);
577
                wait_for_surface_create(ssync+i);
2302
578
578
2303
=== modified file 'tests/mir_test_doubles/CMakeLists.txt'
2304
--- tests/mir_test_doubles/CMakeLists.txt	2013-03-28 09:50:09 +0000
2305
+++ tests/mir_test_doubles/CMakeLists.txt	2013-04-03 18:49:21 +0000
2306
@@ -10,12 +10,10 @@
2307
10
  event_factory.cpp
10
  event_factory.cpp
2308
11
)
11
)
2309
12
12
2310
13
if (NOT MIR_DISABLE_INPUT)
2311
14
list(APPEND TEST_UTILS_SRCS
13
list(APPEND TEST_UTILS_SRCS
2312
15
  fake_event_hub.cpp
14
  fake_event_hub.cpp
2313
16
  fake_event_hub_input_configuration.cpp
15
  fake_event_hub_input_configuration.cpp
2314
17
)
16
)
2315
18
endif()
2316
19
17
2317
20
list(APPEND TEST_UTILS_SRCS
18
list(APPEND TEST_UTILS_SRCS
2318
21
  test_protobuf_socket_server.cpp
19
  test_protobuf_socket_server.cpp
2319
22
20
2320
=== modified file 'tests/unit-tests/CMakeLists.txt'
2321
--- tests/unit-tests/CMakeLists.txt	2013-03-29 22:30:35 +0000
2322
+++ tests/unit-tests/CMakeLists.txt	2013-04-03 18:49:21 +0000
2323
@@ -11,11 +11,8 @@
2324
11
add_subdirectory(shell/)
11
add_subdirectory(shell/)
2325
12
add_subdirectory(geometry/)
12
add_subdirectory(geometry/)
2326
13
add_subdirectory(graphics/)
13
add_subdirectory(graphics/)
2327
14
#TODO stubbed out to run tests on emulator 
2328
15
if (NOT MIR_DISABLE_INPUT)
2329
16
add_subdirectory(input/)
14
add_subdirectory(input/)
2330
17
add_subdirectory(android_input/)
15
add_subdirectory(android_input/)
2331
18
endif()
2332
19
add_subdirectory(surfaces/)
16
add_subdirectory(surfaces/)
2333
20
add_subdirectory(draw/)
17
add_subdirectory(draw/)
2334
21
18
2335
22
19
2336
=== modified file 'tests/unit-tests/client/CMakeLists.txt'
2337
--- tests/unit-tests/client/CMakeLists.txt	2013-03-24 23:33:49 +0000
2338
+++ tests/unit-tests/client/CMakeLists.txt	2013-04-03 18:49:21 +0000
2339
@@ -16,4 +16,8 @@
2340
16
  add_subdirectory("gbm")
16
  add_subdirectory("gbm")
2341
17
endif()
17
endif()
2342
18
18
2343
19
if (NOT MIR_DISABLE_INPUT)
2344
20
add_subdirectory("input")
2345
21
endif()
2346
22
2347
19
set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)
23
set(UNIT_TEST_SOURCES ${UNIT_TEST_SOURCES} PARENT_SCOPE)
2348
20
24
2349
=== added directory 'tests/unit-tests/client/input'
2350
=== added file 'tests/unit-tests/client/input/CMakeLists.txt'
2351
--- tests/unit-tests/client/input/CMakeLists.txt	1970-01-01 00:00:00 +0000
2352
+++ tests/unit-tests/client/input/CMakeLists.txt	2013-04-03 18:49:21 +0000
2353
@@ -0,0 +1,9 @@
2354
1
list(APPEND UNIT_TEST_SOURCES
2355
2
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_receiver_thread.cpp
2356
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_receiver.cpp
2357
4
)
2358
5
2359
6
set(
2360
7
  UNIT_TEST_SOURCES
2361
8
  ${UNIT_TEST_SOURCES}
2362
9
  PARENT_SCOPE)
2363
0
10
2364
=== added file 'tests/unit-tests/client/input/test_android_input_receiver.cpp'
2365
--- tests/unit-tests/client/input/test_android_input_receiver.cpp	1970-01-01 00:00:00 +0000
2366
+++ tests/unit-tests/client/input/test_android_input_receiver.cpp	2013-04-03 18:49:21 +0000
2367
@@ -0,0 +1,198 @@
2368
1
/*
2369
2
 * Copyright © 2013 Canonical Ltd.
2370
3
 *
2371
4
 * This program is free software: you can redistribute it and/or modify
2372
5
 * it under the terms of the GNU General Public License version 3 as
2373
6
 * published by the Free Software Foundation.
2374
7
 *
2375
8
 * This program is distributed in the hope that it will be useful,
2376
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2377
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2378
11
 * GNU General Public License for more details.
2379
12
 *
2380
13
 * You should have received a copy of the GNU General Public License
2381
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2382
15
 *
2383
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
2384
17
 */
2385
18
2386
19
#include "src/client/input/android_input_receiver.h"
2387
20
#include "mir_toolkit/input/event.h"
2388
21
2389
22
#include <androidfw/InputTransport.h>
2390
23
2391
24
#include <gmock/gmock.h>
2392
25
#include <gtest/gtest.h>
2393
26
2394
27
#include <unistd.h>
2395
28
#include <memory>
2396
29
2397
30
namespace mclia = mir::client::input::android;
2398
31
2399
32
namespace droidinput = android;
2400
33
2401
34
namespace
2402
35
{
2403
36
2404
37
class TestingInputProducer
2405
38
{
2406
39
public:
2407
40
    TestingInputProducer(droidinput::sp<droidinput::InputChannel> input_channel) :
2408
41
        input_publisher(std::make_shared<droidinput::InputPublisher>(input_channel)),
2409
42
        incrementing_seq_id(1), // Sequence id must be > 0 or publisher will reject
2410
43
        testing_key_event_key_code(13)
2411
44
    {
2412
45
    }
2413
46
2414
47
    // The input publisher does not care about event semantics so we only highlight
2415
48
    // a few fields for transport verification
2416
49
    void produce_a_key_event()
2417
50
    {
2418
51
        input_publisher->publishKeyEvent(
2419
52
            incrementing_seq_id,
2420
53
            filler_device_id,
2421
54
            0 /* source */,
2422
55
            0 /* action */,
2423
56
            0 /* flags */,
2424
57
            testing_key_event_key_code,
2425
58
            0 /* scan_code */,
2426
59
            0 /* meta_state */,
2427
60
            0 /* repeat_count */,
2428
61
            0 /* down_time */,
2429
62
            0 /* event_time */);
2430
63
    }
2431
64
    void produce_a_motion_event()
2432
65
    {
2433
66
        droidinput::PointerProperties filler_pointer_properties;
2434
67
        droidinput::PointerCoords filler_pointer_coordinates;
2435
68
2436
69
        memset(&filler_pointer_properties, 0, sizeof(droidinput::PointerProperties));
2437
70
        memset(&filler_pointer_coordinates, 0, sizeof(droidinput::PointerCoords));
2438
71
2439
72
        input_publisher->publishMotionEvent(
2440
73
            incrementing_seq_id,
2441
74
            filler_device_id,
2442
75
            0 /* source */,
2443
76
            motion_event_action_flags,
2444
77
            0 /* flags */,
2445
78
            0 /* edge_flags */,
2446
79
            0 /* meta_state */,
2447
80
            0 /* button_state */,
2448
81
            0 /* x_offset */, 0 /* y_offset */,
2449
82
            0 /* x_precision */, 0 /* y_precision */,
2450
83
            0 /* down_time */,
2451
84
            0 /* event_time */,
2452
85
            default_pointer_count,
2453
86
            &filler_pointer_properties,
2454
87
            &filler_pointer_coordinates);
2455
88
    }
2456
89
    
2457
90
    bool must_receive_handled_signal()
2458
91
    {
2459
92
        uint32_t seq;
2460
93
        bool handled;
2461
94
        
2462
95
        auto status = input_publisher->receiveFinishedSignal(&seq, &handled);
2463
96
        return (status == droidinput::OK) && handled;
2464
97
    }
2465
98
2466
99
    std::shared_ptr<droidinput::InputPublisher> input_publisher;
2467
100
2468
101
    int incrementing_seq_id;
2469
102
    int32_t testing_key_event_key_code;
2470
103
    
2471
104
    // Some default values
2472
105
    // device_id must be > 0 or input publisher will reject
2473
106
    static const int32_t filler_device_id = 1;
2474
107
    // AMOTION_EVENT_ACTION_MOVE is necessary to engage batching behavior
2475
108
    static const int32_t motion_event_action_flags = AMOTION_EVENT_ACTION_MOVE;
2476
109
    // We have to have at least 1 pointer or the publisher will fail to marshal a motion event
2477
110
    static const int32_t default_pointer_count = 1;
2478
111
};
2479
112
2480
113
class AndroidInputReceiverSetup : public testing::Test
2481
114
{
2482
115
public:
2483
116
    AndroidInputReceiverSetup()
2484
117
    {
2485
118
        droidinput::String8 const testing_channel_name = droidinput::String8("Terrapin");
2486
119
        auto status = droidinput::InputChannel::openInputChannelPair(testing_channel_name, 
2487
120
                                                                     android_client_channel,
2488
121
                                                                     android_server_channel);
2489
122
        
2490
123
        EXPECT_EQ(droidinput::OK, status);
2491
124
    }
2492
125
    
2493
126
    void flush_channels()
2494
127
    {
2495
128
        fsync(android_server_channel->getFd());
2496
129
        fsync(android_client_channel->getFd());
2497
130
    }
2498
131
2499
132
    droidinput::sp<droidinput::InputChannel> android_client_channel;
2500
133
    droidinput::sp<droidinput::InputChannel> android_server_channel;
2501
134
    
2502
135
    static std::chrono::milliseconds const next_event_timeout;
2503
136
};
2504
137
2505
138
std::chrono::milliseconds const AndroidInputReceiverSetup::next_event_timeout(1000);
2506
139
2507
140
}
2508
141
2509
142
TEST_F(AndroidInputReceiverSetup, receiever_takes_channel_fd)
2510
143
{
2511
144
    mclia::InputReceiver receiver(android_client_channel);
2512
145
    
2513
146
    EXPECT_EQ(android_client_channel->getFd(), receiver.fd());
2514
147
}
2515
148
2516
149
TEST_F(AndroidInputReceiverSetup, receiver_receives_key_events)
2517
150
{
2518
151
    mclia::InputReceiver receiver(android_client_channel);
2519
152
    TestingInputProducer producer(android_server_channel);
2520
153
    
2521
154
    producer.produce_a_key_event();
2522
155
    
2523
156
    flush_channels();
2524
157
    
2525
158
    MirEvent ev;
2526
159
    EXPECT_EQ(true, receiver.next_event(next_event_timeout, ev));
2527
160
    EXPECT_EQ(MIR_INPUT_EVENT_TYPE_KEY, ev.type);
2528
161
    EXPECT_EQ(producer.testing_key_event_key_code, ev.details.key.key_code);
2529
162
}
2530
163
2531
164
TEST_F(AndroidInputReceiverSetup, receiver_handles_events)
2532
165
{
2533
166
    mclia::InputReceiver receiver(android_client_channel);
2534
167
    TestingInputProducer producer(android_server_channel);
2535
168
    
2536
169
    producer.produce_a_key_event();
2537
170
    flush_channels();
2538
171
    
2539
172
    MirEvent ev;
2540
173
    EXPECT_EQ(true, receiver.next_event(next_event_timeout, ev));
2541
174
    
2542
175
    flush_channels();
2543
176
    
2544
177
    EXPECT_TRUE (producer.must_receive_handled_signal());
2545
178
}
2546
179
2547
180
TEST_F(AndroidInputReceiverSetup, receiver_consumes_batched_motion_events)
2548
181
{
2549
182
    mclia::InputReceiver receiver(android_client_channel);
2550
183
    TestingInputProducer producer(android_server_channel);
2551
184
    
2552
185
    // Produce 3 motion events before client handles any.
2553
186
    producer.produce_a_motion_event();
2554
187
    producer.produce_a_motion_event();
2555
188
    producer.produce_a_motion_event();
2556
189
2557
190
    flush_channels();
2558
191
    
2559
192
    MirEvent ev;
2560
193
    // Handle all three events as a batched event
2561
194
    EXPECT_TRUE(receiver.next_event(next_event_timeout, ev));
2562
195
    // Now there should be no events
2563
196
    EXPECT_FALSE(receiver.next_event(std::chrono::milliseconds(1), ev)); // Minimal timeout needed for valgrind
2564
197
}
2565
198
2566
0
199
2567
=== added file 'tests/unit-tests/client/input/test_android_input_receiver_thread.cpp'
2568
--- tests/unit-tests/client/input/test_android_input_receiver_thread.cpp	1970-01-01 00:00:00 +0000
2569
+++ tests/unit-tests/client/input/test_android_input_receiver_thread.cpp	2013-04-03 18:49:21 +0000
2570
@@ -0,0 +1,152 @@
2571
1
/*
2572
2
 * Copyright © 2013 Canonical Ltd.
2573
3
 *
2574
4
 * This program is free software: you can redistribute it and/or modify it
2575
5
 * under the terms of the GNU Lesser General Public License version 3,
2576
6
 * as published by the Free Software Foundation.
2577
7
 *
2578
8
 * This program is distributed in the hope that it will be useful,
2579
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2580
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2581
11
 * GNU General Public License for more details.
2582
12
 *
2583
13
 * You should have received a copy of the GNU Lesser General Public License
2584
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2585
15
 *
2586
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
2587
17
 */
2588
18
2589
19
#include "src/client/input/android_input_receiver_thread.h"
2590
20
#include "src/client/input/android_input_receiver.h"
2591
21
2592
22
#include "mir_toolkit/mir_client_library.h"
2593
23
2594
24
#include <gtest/gtest.h>
2595
25
#include <gmock/gmock.h>
2596
26
2597
27
#include <androidfw/InputTransport.h>
2598
28
2599
29
#include <atomic>
2600
30
2601
31
#include <fcntl.h>
2602
32
2603
33
namespace mclia = mir::client::input::android;
2604
34
2605
35
namespace
2606
36
{
2607
37
2608
38
struct MockEventHandler 
2609
39
{
2610
40
    MOCK_METHOD1(handle_event, void(MirEvent*));
2611
41
};
2612
42
2613
43
struct MockInputReceiver : public mclia::InputReceiver
2614
44
{
2615
45
    MockInputReceiver(int fd)
2616
46
      : InputReceiver(fd)
2617
47
    {
2618
48
    }
2619
49
    MOCK_METHOD1(next_event, bool(MirEvent &));
2620
50
};
2621
51
2622
52
struct AndroidInputReceiverThreadSetup : public testing::Test
2623
53
{
2624
54
    AndroidInputReceiverThreadSetup()
2625
55
    {
2626
56
        test_receiver_fd = open("/dev/null", O_APPEND);
2627
57
        input_receiver = std::make_shared<MockInputReceiver>(test_receiver_fd);
2628
58
    }
2629
59
    virtual ~AndroidInputReceiverThreadSetup()
2630
60
    {
2631
61
        close(test_receiver_fd);
2632
62
    }
2633
63
2634
64
    int test_receiver_fd;
2635
65
    std::shared_ptr<MockInputReceiver> input_receiver;
2636
66
};
2637
67
2638
68
ACTION_P(StopThread, thread)
2639
69
{
2640
70
    thread->stop();
2641
71
//    thread->join();
2642
72
}
2643
73
2644
74
}
2645
75
2646
76
TEST_F(AndroidInputReceiverThreadSetup, reads_events_until_stopped)
2647
77
{
2648
78
    using namespace ::testing;
2649
79
2650
80
    mclia::InputReceiverThread input_thread(input_receiver, 
2651
81
        std::function<void(MirEvent*)>());    
2652
82
    {
2653
83
        InSequence seq;
2654
84
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(Return(false));
2655
85
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(Return(false));
2656
86
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(DoAll(StopThread(&input_thread), Return(false)));
2657
87
    }
2658
88
    input_thread.start();
2659
89
    input_thread.join();
2660
90
}
2661
91
2662
92
TEST_F(AndroidInputReceiverThreadSetup, receives_and_dispatches_available_events_when_ready)
2663
93
{
2664
94
    using namespace ::testing;
2665
95
    MockEventHandler mock_handler;
2666
96
2667
97
    struct InputDelegate
2668
98
    {
2669
99
        InputDelegate(MockEventHandler& handler)
2670
100
          : handler(handler) {}
2671
101
        void operator()(MirEvent* ev)
2672
102
        {
2673
103
            handler.handle_event(ev);
2674
104
        }
2675
105
        MockEventHandler &handler;
2676
106
    } input_delegate(mock_handler);
2677
107
2678
108
    mclia::InputReceiverThread input_thread(input_receiver, input_delegate);
2679
109
    {
2680
110
        InSequence seq;
2681
111
2682
112
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(Return(true));
2683
113
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(Return(false));
2684
114
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(DoAll(StopThread(&input_thread), Return(true)));
2685
115
    }
2686
116
    EXPECT_CALL(mock_handler, handle_event(_)).Times(2);
2687
117
2688
118
    input_thread.start();
2689
119
    input_thread.join();
2690
120
}
2691
121
2692
122
TEST_F(AndroidInputReceiverThreadSetup, input_callback_invoked_from_thread)
2693
123
{
2694
124
    using namespace ::testing;
2695
125
    MockEventHandler mock_handler;
2696
126
    std::atomic<bool> handled;
2697
127
    
2698
128
    handled = false;
2699
129
2700
130
    struct InputDelegate
2701
131
    {
2702
132
        InputDelegate(std::atomic<bool> &handled)
2703
133
          : handled(handled) {}
2704
134
        void operator()(MirEvent* /*ev*/)
2705
135
        {
2706
136
            handled = true;
2707
137
        }
2708
138
        std::atomic<bool> &handled;
2709
139
    } input_delegate(handled);
2710
140
2711
141
    mclia::InputReceiverThread input_thread(input_receiver, input_delegate);
2712
142
    {
2713
143
        InSequence seq;
2714
144
2715
145
        EXPECT_CALL(*input_receiver, next_event(_)).Times(1).WillOnce(DoAll(StopThread(&input_thread), Return(true)));
2716
146
    }
2717
147
2718
148
    input_thread.start();
2719
149
    while (handled == false) { } // We would block forever here were delivery not threaded
2720
150
    input_thread.join();
2721
151
}
2722
152
2723
0
153
2724
=== modified file 'tests/unit-tests/client/test_client_mir_surface.cpp'
2725
--- tests/unit-tests/client/test_client_mir_surface.cpp	2013-03-26 09:37:47 +0000
2726
+++ tests/unit-tests/client/test_client_mir_surface.cpp	2013-04-03 18:49:21 +0000
2727
@@ -20,25 +20,30 @@
2728
20
#include "mir_toolkit/mir_client_library.h"
20
#include "mir_toolkit/mir_client_library.h"
2729
21
#include "src/client/mir_logger.h"
21
#include "src/client/mir_logger.h"
2730
22
#include "src/client/client_buffer.h"
22
#include "src/client/client_buffer.h"
2731
23
#include "src/client/client_buffer_depository.h"
2732
24
#include "src/client/client_buffer_factory.h"
23
#include "src/client/client_buffer_factory.h"
2733
25
#include "src/client/client_platform.h"
24
#include "src/client/client_platform.h"
2734
26
#include "src/client/client_platform_factory.h"
25
#include "src/client/client_platform_factory.h"
2735
27
#include "src/client/mir_surface.h"
26
#include "src/client/mir_surface.h"
2736
28
#include "src/client/mir_connection.h"
27
#include "src/client/mir_connection.h"
2737
28
#include "src/client/input/input_platform.h"
2738
29
#include "src/client/input/input_receiver_thread.h"
2739
29
#include "mir/frontend/resource_cache.h"
30
#include "mir/frontend/resource_cache.h"
2740
30
31
2741
31
#include "mir_test/test_protobuf_server.h"
32
#include "mir_test/test_protobuf_server.h"
2742
32
#include "mir_test/stub_server_tool.h"
33
#include "mir_test/stub_server_tool.h"
2743
33
#include "mir_test/test_protobuf_client.h"
34
#include "mir_test/test_protobuf_client.h"
2744
34
#include "mir_test/gmock_fixes.h"
35
#include "mir_test/gmock_fixes.h"
2745
36
#include "mir_test/fake_shared.h"
2746
35
37
2747
36
#include <cstring>
38
#include <cstring>
2748
37
39
2749
38
#include <gtest/gtest.h>
40
#include <gtest/gtest.h>
2750
39
#include <gmock/gmock.h>
41
#include <gmock/gmock.h>
2751
40
42
2752
43
#include <fcntl.h>
2753
44
2754
41
namespace mcl = mir::client;
45
namespace mcl = mir::client;
2755
46
namespace mcli = mcl::input;
2756
42
namespace mp = mir::protobuf;
47
namespace mp = mir::protobuf;
2757
43
namespace geom = mir::geometry;
48
namespace geom = mir::geometry;
2758
44
49
2759
@@ -52,10 +57,17 @@
2760
52
    MockServerPackageGenerator()
57
    MockServerPackageGenerator()
2761
53
     : global_buffer_id(0)
58
     : global_buffer_id(0)
2762
54
    {
59
    {
2763
55
        generate_unique_buffer();
2764
56
        width_sent  = 891;
60
        width_sent  = 891;
2765
57
        height_sent = 458;
61
        height_sent = 458;
2766
58
        pf_sent = mir_pixel_format_abgr_8888;
62
        pf_sent = mir_pixel_format_abgr_8888;
2767
63
2768
64
        input_fd = open("/dev/null", O_APPEND);
2769
65
    }
2770
66
    ~MockServerPackageGenerator()
2771
67
    {
2772
68
        close(input_fd);
2773
69
        for (int i = 0; i < server_package.fd_items; i++)
2774
70
            close(server_package.fd[0]);
2775
59
    }
71
    }
2776
60
72
2777
61
    void create_surface(google::protobuf::RpcController*,
73
    void create_surface(google::protobuf::RpcController*,
2778
@@ -86,8 +98,12 @@
2779
86
        int num_fd = 2, num_data = 8;
98
        int num_fd = 2, num_data = 8;
2780
87
        for (auto i=0; i<num_fd; i++)
99
        for (auto i=0; i<num_fd; i++)
2781
88
        {
100
        {
2783
89
            server_package.fd[i] = global_buffer_id * i;
101
            if (server_package.fd[i])
2784
102
                close(server_package.fd[i]);
2785
103
            server_package.fd[i] = open("/dev/null", O_APPEND);
2786
90
        }
104
        }
2787
105
        server_package.fd_items = num_fd;
2788
106
        server_package.data_items = num_data;
2789
91
        for (auto i=0; i<num_data; i++)
107
        for (auto i=0; i<num_data; i++)
2790
92
        {
108
        {
2791
93
            server_package.data[i] = (global_buffer_id + i) * 2;
109
            server_package.data[i] = (global_buffer_id + i) * 2;
2792
@@ -100,16 +116,20 @@
2793
100
    int width_sent;
116
    int width_sent;
2794
101
    int height_sent;
117
    int height_sent;
2795
102
    int pf_sent;
118
    int pf_sent;
2796
119
    
2797
120
    int input_fd;
2798
103
121
2799
104
    private:
122
    private:
2800
105
    int global_buffer_id;
123
    int global_buffer_id;
2801
106
124
2802
107
    void create_buffer_response(mir::protobuf::Buffer* response)
125
    void create_buffer_response(mir::protobuf::Buffer* response)
2803
108
    {
126
    {
2804
127
        generate_unique_buffer();
2805
128
2806
109
        response->set_buffer_id(global_buffer_id);
129
        response->set_buffer_id(global_buffer_id);
2807
110
130
2808
111
        /* assemble buffers */
131
        /* assemble buffers */
2810
112
        response->set_fds_on_side_channel(1);
132
        response->set_fds_on_side_channel(server_package.fd_items);
2811
113
        for (int i=0; i< server_package.data_items; i++)
133
        for (int i=0; i< server_package.data_items; i++)
2812
114
        {
134
        {
2813
115
            response->add_data(server_package.data[i]);
135
            response->add_data(server_package.data[i]);
2814
@@ -120,16 +140,18 @@
2815
120
        }
140
        }
2816
121
141
2817
122
        response->set_stride(server_package.stride);
142
        response->set_stride(server_package.stride);
2818
123
2819
124
        generate_unique_buffer();
2820
125
    }
143
    }
2821
126
144
2822
127
    void create_surface_response(mir::protobuf::Surface* response)
145
    void create_surface_response(mir::protobuf::Surface* response)
2823
128
    {
146
    {
2824
147
        response->set_fds_on_side_channel(1);
2825
148
2826
129
        response->mutable_id()->set_value(2);
149
        response->mutable_id()->set_value(2);
2827
130
        response->set_width(width_sent);
150
        response->set_width(width_sent);
2828
131
        response->set_height(height_sent);
151
        response->set_height(height_sent);
2829
132
        response->set_pixel_format(pf_sent);
152
        response->set_pixel_format(pf_sent);
2830
153
        response->add_fd(input_fd);
2831
154
2832
133
        create_buffer_response(response->mutable_buffer());
155
        create_buffer_response(response->mutable_buffer());
2833
134
    }
156
    }
2834
135
};
157
};
2835
@@ -207,6 +229,26 @@
2836
207
    }
229
    }
2837
208
};
230
};
2838
209
231
2839
232
struct StubClientInputPlatform : public mcli::InputPlatform
2840
233
{
2841
234
    std::shared_ptr<mcli::InputReceiverThread> create_input_thread(int /* fd */, std::function<void(MirEvent*)> const& /* callback */)
2842
235
    {
2843
236
        return std::shared_ptr<mcli::InputReceiverThread>();
2844
237
    }
2845
238
};
2846
239
2847
240
struct MockClientInputPlatform : public mcli::InputPlatform
2848
241
{
2849
242
    MOCK_METHOD2(create_input_thread, std::shared_ptr<mcli::InputReceiverThread>(int, std::function<void(MirEvent*)> const&));
2850
243
};
2851
244
2852
245
struct MockInputReceiverThread : public mcli::InputReceiverThread
2853
246
{
2854
247
    MOCK_METHOD0(start, void());
2855
248
    MOCK_METHOD0(stop, void());
2856
249
    MOCK_METHOD0(join, void());
2857
250
};
2858
251
2859
210
}
252
}
2860
211
}
253
}
2861
212
254
2862
@@ -232,6 +274,8 @@
2863
232
274
2864
233
        mock_buffer_factory = std::make_shared<mt::MockClientBufferFactory>();
275
        mock_buffer_factory = std::make_shared<mt::MockClientBufferFactory>();
2865
234
276
2866
277
        input_platform = std::make_shared<mt::StubClientInputPlatform>();
2867
278
2868
235
        params = MirSurfaceParameters{"test", 33, 45, mir_pixel_format_abgr_8888,
279
        params = MirSurfaceParameters{"test", 33, 45, mir_pixel_format_abgr_8888,
2869
236
                                      mir_buffer_usage_hardware};
280
                                      mir_buffer_usage_hardware};
2870
237
281
2871
@@ -261,6 +305,7 @@
2872
261
305
2873
262
    MirSurfaceParameters params;
306
    MirSurfaceParameters params;
2874
263
    std::shared_ptr<mt::MockClientBufferFactory> mock_buffer_factory;
307
    std::shared_ptr<mt::MockClientBufferFactory> mock_buffer_factory;
2875
308
    std::shared_ptr<mt::StubClientInputPlatform> input_platform;
2876
264
309
2877
265
    mir::protobuf::Connection response;
310
    mir::protobuf::Connection response;
2878
266
    mir::protobuf::ConnectParameters connect_parameters;
311
    mir::protobuf::ConnectParameters connect_parameters;
2879
@@ -282,13 +327,7 @@
2880
282
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_))
327
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_))
2881
283
        .Times(1);
328
        .Times(1);
2882
284
329
2890
285
    auto surface = std::make_shared<MirSurface> (connection.get(),
330
    auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger, mock_buffer_factory, input_platform, params, nullptr, &empty_callback, nullptr);
2884
286
                                                 *client_comm_channel,
2885
287
                                                 logger,
2886
288
                                                 mock_buffer_factory,
2887
289
                                                 params,
2888
290
                                                 &empty_callback,
2889
291
                                                 nullptr);
2891
292
331
2892
293
    auto wait_handle = surface->get_create_wait_handle();
332
    auto wait_handle = surface->get_create_wait_handle();
2893
294
    wait_handle->wait_for_result();
333
    wait_handle->wait_for_result();
2894
@@ -306,20 +345,14 @@
2895
306
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_))
345
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_))
2896
307
        .Times(1);
346
        .Times(1);
2897
308
347
2905
309
    auto surface = std::make_shared<MirSurface> (connection.get(),
348
    auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger, mock_buffer_factory, input_platform, params, nullptr, &empty_callback, nullptr);
2899
310
                                                 *client_comm_channel,
2900
311
                                                 logger,
2901
312
                                                 mock_buffer_factory,
2902
313
                                                 params,
2903
314
                                                 &empty_callback,
2904
315
                                                 nullptr);
2906
316
349
2907
317
    auto wait_handle = surface->get_create_wait_handle();
350
    auto wait_handle = surface->get_create_wait_handle();
2908
318
    wait_handle->wait_for_result();
351
    wait_handle->wait_for_result();
2909
319
352
2910
320
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_))
353
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_))
2911
321
        .Times(1);
354
        .Times(1);
2913
322
    auto buffer_wait_handle = surface->next_buffer(&empty_surface_callback, (void*) NULL);
355
    auto buffer_wait_handle = surface->next_buffer(&empty_surface_callback, nullptr);
2914
323
    buffer_wait_handle->wait_for_result();
356
    buffer_wait_handle->wait_for_result();
2915
324
}
357
}
2916
325
358
2917
@@ -328,12 +361,11 @@
2918
328
    // Can't simply use memcmp() on the whole struct because age is not sent over the wire
361
    // Can't simply use memcmp() on the whole struct because age is not sent over the wire
2919
329
    if (package.data_items != arg.data_items)
362
    if (package.data_items != arg.data_items)
2920
330
        return false;
363
        return false;
2921
364
    // Note we can not compare the fd's directly as they may change when being sent over the wire.
2922
331
    if (package.fd_items != arg.fd_items)
365
    if (package.fd_items != arg.fd_items)
2923
332
        return false;
366
        return false;
2924
333
    if (memcmp(package.data, arg.data, sizeof(package.data[0]) * package.data_items))
367
    if (memcmp(package.data, arg.data, sizeof(package.data[0]) * package.data_items))
2925
334
        return false;
368
        return false;
2926
335
    if (memcmp(package.fd, arg.fd, sizeof(package.fd[0]) * package.fd_items))
2927
336
        return false;
2928
337
    if (package.stride != arg.stride)
369
    if (package.stride != arg.stride)
2929
338
        return false;
370
        return false;
2930
339
    return true;
371
    return true;
2931
@@ -349,13 +381,8 @@
2932
349
        .WillOnce(DoAll(SaveArg<0>(&submitted_package),
381
        .WillOnce(DoAll(SaveArg<0>(&submitted_package),
2933
350
                        Return(mock_buffer_factory->emptybuffer)));
382
                        Return(mock_buffer_factory->emptybuffer)));
2934
351
383
2942
352
    auto surface = std::make_shared<MirSurface> (connection.get(),
384
    auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger, mock_buffer_factory, input_platform, params, nullptr, &empty_callback, nullptr);
2943
353
                                                 *client_comm_channel,
385
2937
354
                                                 logger,
2938
355
                                                 mock_buffer_factory,
2939
356
                                                 params,
2940
357
                                                 &empty_callback,
2941
358
                                                 nullptr);
2944
359
    auto wait_handle = surface->get_create_wait_handle();
386
    auto wait_handle = surface->get_create_wait_handle();
2945
360
    wait_handle->wait_for_result();
387
    wait_handle->wait_for_result();
2946
361
388
2947
@@ -375,13 +402,8 @@
2948
375
        .WillOnce(DoAll(SaveArg<1>(&sz),
402
        .WillOnce(DoAll(SaveArg<1>(&sz),
2949
376
                        Return(mock_buffer_factory->emptybuffer)));
403
                        Return(mock_buffer_factory->emptybuffer)));
2950
377
404
2958
378
    auto surface = std::make_shared<MirSurface> (connection.get(),
405
    auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger, mock_buffer_factory, input_platform, params, nullptr, &empty_callback, nullptr);
2959
379
                                                 *client_comm_channel,
406
2953
380
                                                 logger,
2954
381
                                                 mock_buffer_factory,
2955
382
                                                 params,
2956
383
                                                 &empty_callback,
2957
384
                                                 nullptr);
2960
385
    auto wait_handle = surface->get_create_wait_handle();
407
    auto wait_handle = surface->get_create_wait_handle();
2961
386
    wait_handle->wait_for_result();
408
    wait_handle->wait_for_result();
2962
387
409
2963
@@ -400,13 +422,8 @@
2964
400
        .WillOnce(DoAll(SaveArg<1>(&sz),
422
        .WillOnce(DoAll(SaveArg<1>(&sz),
2965
401
                        Return(mock_buffer_factory->emptybuffer)));
423
                        Return(mock_buffer_factory->emptybuffer)));
2966
402
424
2974
403
    auto surface = std::make_shared<MirSurface> (connection.get(),
425
    auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger, mock_buffer_factory, input_platform, params, nullptr, &empty_callback, nullptr);
2975
404
                                                 *client_comm_channel,
426
2969
405
                                                 logger,
2970
406
                                                 mock_buffer_factory,
2971
407
                                                 params,
2972
408
                                                 &empty_callback,
2973
409
                                                 nullptr);
2976
410
    auto wait_handle = surface->get_create_wait_handle();
427
    auto wait_handle = surface->get_create_wait_handle();
2977
411
    wait_handle->wait_for_result();
428
    wait_handle->wait_for_result();
2978
412
429
2979
@@ -425,13 +442,7 @@
2980
425
        .WillOnce(DoAll(SaveArg<2>(&pf),
442
        .WillOnce(DoAll(SaveArg<2>(&pf),
2981
426
                        Return(mock_buffer_factory->emptybuffer)));
443
                        Return(mock_buffer_factory->emptybuffer)));
2982
427
444
2990
428
    auto surface = std::make_shared<MirSurface> (connection.get(),
445
    auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger, mock_buffer_factory, input_platform, params, nullptr, &empty_callback, nullptr);
2984
429
                                                 *client_comm_channel,
2985
430
                                                 logger,
2986
431
                                                 mock_buffer_factory,
2987
432
                                                 params,
2988
433
                                                 &empty_callback,
2989
434
                                                 nullptr);
2991
435
446
2992
436
    auto wait_handle = surface->get_create_wait_handle();
447
    auto wait_handle = surface->get_create_wait_handle();
2993
437
    wait_handle->wait_for_result();
448
    wait_handle->wait_for_result();
2994
@@ -439,6 +450,46 @@
2995
439
    EXPECT_EQ(pf, geom::PixelFormat::abgr_8888);
450
    EXPECT_EQ(pf, geom::PixelFormat::abgr_8888);
2996
440
}
451
}
2997
441
452
2998
453
2999
454
3000
455
namespace
3001
456
{
3002
457
static void null_event_callback(MirSurface*, MirEvent*, void*)
3003
458
{
3004
459
}
3005
460
}
3006
461
3007
462
TEST_F(MirClientSurfaceTest, input_fd_used_to_create_input_thread_when_delegate_specified)
3008
463
{
3009
464
    using namespace ::testing;
3010
465
    
3011
466
    auto mock_input_platform = std::make_shared<mt::MockClientInputPlatform>();
3012
467
    auto mock_input_thread = std::make_shared<mt::MockInputReceiverThread>();
3013
468
    MirEventDelegate delegate = {null_event_callback, nullptr};
3014
469
3015
470
    EXPECT_CALL(*mock_buffer_factory, create_buffer(_,_,_)).Times(2);
3016
471
3017
472
    EXPECT_CALL(*mock_input_platform, create_input_thread(_, _)).Times(1)
3018
473
        .WillOnce(Return(mock_input_thread));
3019
474
    EXPECT_CALL(*mock_input_thread, start()).Times(1);
3020
475
    EXPECT_CALL(*mock_input_thread, stop()).Times(1);
3021
476
3022
477
    {
3023
478
        auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger,
3024
479
            mock_buffer_factory, mock_input_platform, params, &delegate, &empty_callback, nullptr);
3025
480
        auto wait_handle = surface->get_create_wait_handle();
3026
481
        wait_handle->wait_for_result();
3027
482
    }
3028
483
3029
484
    {
3030
485
        // This surface should not trigger a call to the input platform as no input delegate is specified.
3031
486
        auto surface = std::make_shared<MirSurface> (connection.get(), *client_comm_channel, logger,
3032
487
            mock_buffer_factory, mock_input_platform, params, nullptr, &empty_callback, nullptr);
3033
488
        auto wait_handle = surface->get_create_wait_handle();
3034
489
        wait_handle->wait_for_result();
3035
490
    }
3036
491
}
3037
492
3038
442
TEST_F(MirClientSurfaceTest, get_buffer_returns_last_received_buffer_package)
493
TEST_F(MirClientSurfaceTest, get_buffer_returns_last_received_buffer_package)
3039
443
{
494
{
3040
444
    using namespace testing;
495
    using namespace testing;
3041
@@ -450,7 +501,9 @@
3042
450
                                                 *client_comm_channel,
501
                                                 *client_comm_channel,
3043
451
                                                 logger,
502
                                                 logger,
3044
452
                                                 mock_buffer_factory,
503
                                                 mock_buffer_factory,
3045
504
                                                 input_platform,
3046
453
                                                 params,
505
                                                 params,
3047
506
                                                 nullptr,
3048
454
                                                 &empty_callback,
507
                                                 &empty_callback,
3049
455
                                                 nullptr);
508
                                                 nullptr);
3050
456
    auto wait_handle = surface->get_create_wait_handle();
509
    auto wait_handle = surface->get_create_wait_handle();
3051
@@ -478,7 +531,9 @@
3052
478
                                                 *client_comm_channel,
531
                                                 *client_comm_channel,
3053
479
                                                 logger,
532
                                                 logger,
3054
480
                                                 mock_buffer_factory,
533
                                                 mock_buffer_factory,
3055
534
                                                 input_platform,
3056
481
                                                 params,
535
                                                 params,
3057
536
                                                 nullptr,
3058
482
                                                 &empty_callback,
537
                                                 &empty_callback,
3059
483
                                                 nullptr);
538
                                                 nullptr);
3060
484
    surface->get_create_wait_handle()->wait_for_result();
539
    surface->get_create_wait_handle()->wait_for_result();
3061
485
540
3062
=== modified file 'tests/unit-tests/input/android/test_android_input_application_handle.cpp'
3063
--- tests/unit-tests/input/android/test_android_input_application_handle.cpp	2013-03-29 16:51:35 +0000
3064
+++ tests/unit-tests/input/android/test_android_input_application_handle.cpp	2013-04-03 18:49:21 +0000
3065
@@ -20,8 +20,6 @@
3066
20
20
3067
21
#include "mir/input/session_target.h"
21
#include "mir/input/session_target.h"
3068
22
22
3069
23
#include "mir_test/fake_shared.h"
3070
24
3071
25
#include <gtest/gtest.h>
23
#include <gtest/gtest.h>
3072
26
#include <gmock/gmock.h>
24
#include <gmock/gmock.h>
3073
27
25
3074
@@ -29,7 +27,6 @@
3075
29
27
3076
30
namespace mi = mir::input;
28
namespace mi = mir::input;
3077
31
namespace mia = mi::android;
29
namespace mia = mi::android;
3078
32
namespace mt = mir::test;
3079
33
30
3080
34
namespace
31
namespace
3081
35
{
32
{
3082
@@ -44,15 +41,30 @@
3083
44
{
41
{
3084
45
    using namespace ::testing;
42
    using namespace ::testing;
3085
46
    std::string const testing_session_name = "Cats";
43
    std::string const testing_session_name = "Cats";
3087
47
    MockSessionHandle session;
44
    auto session = std::make_shared<MockSessionHandle>();
3088
48
45
3090
49
    EXPECT_CALL(session, name()).Times(AtLeast(1))
46
    EXPECT_CALL(*session, name()).Times(AtLeast(1))
3091
50
        .WillRepeatedly(Return(testing_session_name));
47
        .WillRepeatedly(Return(testing_session_name));
3093
51
    mia::InputApplicationHandle application_handle(mt::fake_shared(session));
48
    mia::InputApplicationHandle application_handle(session);
3094
52
    EXPECT_TRUE(application_handle.updateInfo());
49
    EXPECT_TRUE(application_handle.updateInfo());
3095
53
    auto info = application_handle.getInfo();
50
    auto info = application_handle.getInfo();
3096
54
    EXPECT_EQ(INT_MAX, info->dispatchingTimeout);
51
    EXPECT_EQ(INT_MAX, info->dispatchingTimeout);
3097
55
    EXPECT_EQ(droidinput::String8(testing_session_name.c_str()), info->name);
52
    EXPECT_EQ(droidinput::String8(testing_session_name.c_str()), info->name);
3098
56
}
53
}
3099
57
54
3100
55
TEST(AndroidInputApplicationHandle, does_not_own_session)
3101
56
{
3102
57
    using namespace ::testing;
3103
58
    std::string const testing_session_name = "Let it Grow";
3104
59
    
3105
60
    auto session = std::make_shared<MockSessionHandle>();
3106
61
    EXPECT_CALL(*session, name()).Times(AtLeast(1))
3107
62
        .WillRepeatedly(Return(testing_session_name));
3108
63
    
3109
64
    mia::InputApplicationHandle application_handle(session);
3110
65
    EXPECT_TRUE(application_handle.updateInfo());
3111
66
    session.reset();
3112
67
    EXPECT_FALSE(application_handle.updateInfo());
3113
68
3114
69
}
3115
58
70
3116
59
71
3117
=== modified file 'tests/unit-tests/input/android/test_android_input_lexicon.cpp'
3118
--- tests/unit-tests/input/android/test_android_input_lexicon.cpp	2013-03-13 08:09:52 +0000
3119
+++ tests/unit-tests/input/android/test_android_input_lexicon.cpp	2013-04-03 18:49:21 +0000
3120
@@ -15,8 +15,8 @@
3121
15
 *
15
 *
3122
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
3123
17
 */
17
 */
3126
18
#include "src/server/input/android/android_input_lexicon.h"
18
3127
19
// Is this the right place for this header? Will eventually be included by clients.
19
#include "mir/input/android/android_input_lexicon.h"
3128
20
#include "mir_toolkit/input/event.h"
20
#include "mir_toolkit/input/event.h"
3129
21
21
3130
22
#include <androidfw/Input.h>
22
#include <androidfw/Input.h>
3131
@@ -25,7 +25,7 @@
3132
25
#include <gmock/gmock.h>
25
#include <gmock/gmock.h>
3133
26
26
3134
27
namespace mi = mir::input;
27
namespace mi = mir::input;
3136
28
namespace mia = mir::input::android;
28
namespace miat = mir::input::android::transport;
3137
29
29
3138
30
TEST(AndroidInputLexicon, translates_key_events)
30
TEST(AndroidInputLexicon, translates_key_events)
3139
31
{
31
{
3140
@@ -48,7 +48,7 @@
3141
48
                               down_time, event_time);
48
                               down_time, event_time);
3142
49
49
3143
50
    MirEvent mir_ev;
50
    MirEvent mir_ev;
3145
51
    mia::Lexicon::translate(android_key_ev, mir_ev);
51
    miat::Lexicon::translate(android_key_ev, mir_ev);
3146
52
52
3147
53
    // Common event properties
53
    // Common event properties
3148
54
    EXPECT_EQ(device_id, mir_ev.device_id);
54
    EXPECT_EQ(device_id, mir_ev.device_id);
3149
@@ -121,7 +121,7 @@
3150
121
                                  event_time, pointer_count, &pointer_properties, &pointer_coords);
121
                                  event_time, pointer_count, &pointer_properties, &pointer_coords);
3151
122
122
3152
123
    MirEvent mir_ev;
123
    MirEvent mir_ev;
3154
124
    mia::Lexicon::translate(android_motion_ev, mir_ev);
124
    miat::Lexicon::translate(android_motion_ev, mir_ev);
3155
125
125
3156
126
    // Common event properties
126
    // Common event properties
3157
127
    EXPECT_EQ(device_id, mir_ev.device_id);
127
    EXPECT_EQ(device_id, mir_ev.device_id);
3158
128
128
3159
=== modified file 'tests/unit-tests/input/android/test_android_input_window_handle.cpp'
3160
--- tests/unit-tests/input/android/test_android_input_window_handle.cpp	2013-03-29 16:51:35 +0000
3161
+++ tests/unit-tests/input/android/test_android_input_window_handle.cpp	2013-04-03 18:49:21 +0000
3162
@@ -80,7 +80,7 @@
3163
80
80
3164
81
    auto info = handle.getInfo();
81
    auto info = handle.getInfo();
3165
82
82
3167
83
    EXPECT_EQ(testing_surface_name, info->name);
83
    EXPECT_EQ(droidinput::String8(testing_surface_name.c_str()), info->name);
3168
84
84
3169
85
    EXPECT_EQ(testing_server_fd, info->inputChannel->getFd());
85
    EXPECT_EQ(testing_server_fd, info->inputChannel->getFd());
3170
86
86
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Approve on 2013-04-04
Alan Griffiths			Approve on 2013-04-04
Chris Halse Rogers		2013-03-25	Approve on 2013-04-04
Review via email: mp+155368@code.launchpad.net