1
=== modified file 'CMakeLists.txt'
2
--- CMakeLists.txt	2016-04-28 14:56:46 +0000
3
+++ CMakeLists.txt	2016-04-28 14:56:46 +0000
4
@@ -48,7 +48,10 @@
5
48
                   libnotify>=0.7.6
48
                   libnotify>=0.7.6
6
49
                   url-dispatcher-1>=1
49
                   url-dispatcher-1>=1
7
50
                   properties-cpp>=0.0.1
50
                   properties-cpp>=0.0.1
9
51
                   libaccounts-glib>=1.18)
51
                   libaccounts-glib>=1.18
10
52
                   messaging-menu>=12.10
11
53
                   uuid>=2.25
12
54
                   ubuntu-app-launch-2)
13
52
include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
55
include_directories (SYSTEM ${SERVICE_DEPS_INCLUDE_DIRS})
14
53
56
15
54
##
57
##
16
55
58
17
=== modified file 'data/CMakeLists.txt'
18
--- data/CMakeLists.txt	2015-10-13 15:06:25 +0000
19
+++ data/CMakeLists.txt	2016-04-28 14:56:46 +0000
20
@@ -52,7 +52,7 @@
21
52
set (pkglibexecdir "${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}")
52
set (pkglibexecdir "${CMAKE_INSTALL_FULL_PKGLIBEXECDIR}")
22
53
configure_file ("${XDG_AUTOSTART_FILE_IN}" "${XDG_AUTOSTART_FILE}")
53
configure_file ("${XDG_AUTOSTART_FILE_IN}" "${XDG_AUTOSTART_FILE}")
23
54
54
25
55
# install it
55
# install XDG autostart
26
56
install (FILES "${XDG_AUTOSTART_FILE}"
56
install (FILES "${XDG_AUTOSTART_FILE}"
27
57
         DESTINATION "${XDG_AUTOSTART_DIR}")
57
         DESTINATION "${XDG_AUTOSTART_DIR}")
28
58
58
29
59
59
30
=== modified file 'data/indicator-datetime.desktop.in'
31
--- data/indicator-datetime.desktop.in	2014-04-04 13:05:59 +0000
32
+++ data/indicator-datetime.desktop.in	2016-04-28 14:56:46 +0000
33
@@ -7,3 +7,4 @@
34
7
StartupNotify=false
7
StartupNotify=false
35
8
Terminal=false
8
Terminal=false
36
9
AutostartCondition=GNOME3 unless-session gnome
9
AutostartCondition=GNOME3 unless-session gnome
37
10
Icon=@messaging_menu_icon@
38
10
11
39
=== modified file 'debian/control'
40
--- debian/control	2016-04-28 14:56:46 +0000
41
+++ debian/control	2016-04-28 14:56:46 +0000
42
@@ -31,6 +31,10 @@
43
31
               ubuntu-touch-sounds,
31
               ubuntu-touch-sounds,
44
32
# for query user e-mails based on accounts
32
# for query user e-mails based on accounts
45
33
               libaccounts-glib-dev,
33
               libaccounts-glib-dev,
46
34
# messaging menu integration
47
35
               libmessaging-menu-dev,
48
36
               uuid-dev,
49
37
               libubuntu-app-launch2-dev (>= 0.9),
50
34
Standards-Version: 3.9.3
38
Standards-Version: 3.9.3
51
35
Homepage: https://launchpad.net/indicator-datetime
39
Homepage: https://launchpad.net/indicator-datetime
52
36
# If you aren't a member of ~indicator-applet-developers but need to upload
40
# If you aren't a member of ~indicator-applet-developers but need to upload
53
37
41
54
=== modified file 'include/datetime/actions-live.h'
55
--- include/datetime/actions-live.h	2016-04-05 21:00:09 +0000
56
+++ include/datetime/actions-live.h	2016-04-28 14:56:46 +0000
57
@@ -36,26 +36,29 @@
58
36
class LiveActions: public Actions
36
class LiveActions: public Actions
59
37
{
37
{
60
38
public:
38
public:
61
39
    enum Desktop {
62
40
        OTHER = 0,
63
41
        UNITY7,
64
42
        UNITY8,
65
43
    };
66
44
67
39
    explicit LiveActions(const std::shared_ptr<State>& state_in);
45
    explicit LiveActions(const std::shared_ptr<State>& state_in);
68
40
    virtual ~LiveActions() =default;
46
    virtual ~LiveActions() =default;
69
41
47
70
42
    bool desktop_has_calendar_app() const override;
48
    bool desktop_has_calendar_app() const override;
80
43
    void desktop_open_alarm_app() override;
49
    void open_alarm_app() override;
81
44
    void desktop_open_appointment(const Appointment&, const DateTime&) override;
50
    void open_appointment(const Appointment&, const DateTime&) override;
82
45
    void desktop_open_calendar_app(const DateTime&) override;
51
    void open_calendar_app(const DateTime&) override;
83
46
    void desktop_open_settings_app() override;
52
    void open_settings_app() override;
75
47
76
48
    void phone_open_alarm_app() override;
77
49
    void phone_open_appointment(const Appointment&, const DateTime &) override;
78
50
    void phone_open_calendar_app(const DateTime&) override;
79
51
    void phone_open_settings_app() override;
84
52
53
85
53
    void set_location(const std::string& zone, const std::string& name) override;
54
    void set_location(const std::string& zone, const std::string& name) override;
86
54
55
87
55
protected:
56
protected:
89
56
    static bool is_unity();
57
    virtual Desktop get_desktop();
90
57
    virtual void execute_command(const std::string& command);
58
    virtual void execute_command(const std::string& command);
91
58
    virtual void dispatch_url(const std::string& url);
59
    virtual void dispatch_url(const std::string& url);
92
60
93
61
    void unity8_open_appointment(const Appointment& appt, const DateTime& date);
94
59
};
62
};
95
60
63
96
61
} // namespace datetime
64
} // namespace datetime
97
62
65
98
=== modified file 'include/datetime/actions.h'
99
--- include/datetime/actions.h	2016-03-21 17:32:39 +0000
100
+++ include/datetime/actions.h	2016-04-28 14:56:46 +0000
101
@@ -44,15 +44,11 @@
102
44
public:
44
public:
103
45
45
104
46
    virtual bool desktop_has_calendar_app() const =0;
46
    virtual bool desktop_has_calendar_app() const =0;
105
47
    virtual void desktop_open_alarm_app() =0;
106
48
    virtual void desktop_open_appointment(const Appointment&, const DateTime&) =0;
107
49
    virtual void desktop_open_calendar_app(const DateTime&) =0;
108
50
    virtual void desktop_open_settings_app() =0;
109
51
47
114
52
    virtual void phone_open_alarm_app() =0;
48
    virtual void open_alarm_app() =0;
115
53
    virtual void phone_open_appointment(const Appointment&, const DateTime&) =0;
49
    virtual void open_appointment(const Appointment&, const DateTime&) =0;
116
54
    virtual void phone_open_calendar_app(const DateTime&) =0;
50
    virtual void open_calendar_app(const DateTime&) =0;
117
55
    virtual void phone_open_settings_app() =0;
51
    virtual void open_settings_app() =0;
118
56
52
119
57
    virtual void set_location(const std::string& zone, const std::string& name)=0;
53
    virtual void set_location(const std::string& zone, const std::string& name)=0;
120
58
54
121
59
55
122
=== modified file 'include/notifications/haptic.h'
123
--- include/notifications/haptic.h	2014-09-17 16:51:51 +0000
124
+++ include/notifications/haptic.h	2016-04-28 14:56:46 +0000
125
@@ -41,7 +41,7 @@
126
41
      MODE_PULSE
41
      MODE_PULSE
127
42
    };
42
    };
128
43
43
130
44
    explicit Haptic(const Mode& mode = MODE_PULSE);
44
    explicit Haptic(const Mode& mode = MODE_PULSE, bool repeat = false);
131
45
    ~Haptic();
45
    ~Haptic();
132
46
46
133
47
private:
47
private:
134
48
48
135
=== modified file 'include/notifications/notifications.h'
136
--- include/notifications/notifications.h	2014-09-19 14:35:07 +0000
137
+++ include/notifications/notifications.h	2016-04-28 14:56:46 +0000
138
@@ -50,6 +50,8 @@
139
50
50
140
51
    void set_icon_name (const std::string& icon_name);
51
    void set_icon_name (const std::string& icon_name);
141
52
52
142
53
    void set_start_time(uint64_t time);
143
54
144
53
    /* Set an interval, after which the notification will automatically
55
    /* Set an interval, after which the notification will automatically
145
54
       be closed. If not set, the notification server's default timeout
56
       be closed. If not set, the notification server's default timeout
146
55
       is used. */
57
       is used. */
147
@@ -62,15 +64,20 @@
148
62
    static constexpr char const * HINT_NONSHAPED_ICON {"x-canonical-non-shaped-icon"};
64
    static constexpr char const * HINT_NONSHAPED_ICON {"x-canonical-non-shaped-icon"};
149
63
    static constexpr char const * HINT_AFFIRMATIVE_HINT {"x-canonical-private-affirmative-tint"};
65
    static constexpr char const * HINT_AFFIRMATIVE_HINT {"x-canonical-private-affirmative-tint"};
150
64
    static constexpr char const * HINT_REJECTION_TINT {"x-canonical-private-rejection-tint"};
66
    static constexpr char const * HINT_REJECTION_TINT {"x-canonical-private-rejection-tint"};
151
67
    static constexpr char const * HINT_INTERACTIVE {"x-canonical-switch-to-application"};
152
65
68
153
66
    /* Add an action button.
69
    /* Add an action button.
154
67
       This may fail if the Engine doesn't support actions.
70
       This may fail if the Engine doesn't support actions.
155
68
       @see Engine::supports_actions() */
71
       @see Engine::supports_actions() */
156
69
    void add_action (const std::string& action, const std::string& label);
72
    void add_action (const std::string& action, const std::string& label);
157
70
73
159
71
    /** Sets the closed callback. This will be called exactly once. */
74
    /** Sets the closed callback. This will be called exactly once. After notification dissapear */
160
72
    void set_closed_callback (std::function<void(const std::string& action)>);
75
    void set_closed_callback (std::function<void(const std::string& action)>);
161
73
76
162
77
    /** Sets the time-out callback. This will be called exactly once. */
163
78
    void set_timeout_callback (std::function<void()>);
164
79
165
80
166
74
private:
81
private:
167
75
    friend class Engine;
82
    friend class Engine;
168
76
    class Impl;
83
    class Impl;
169
77
84
170
=== modified file 'src/actions-live.cpp'
171
--- src/actions-live.cpp	2016-04-10 00:03:57 +0000
172
+++ src/actions-live.cpp	2016-04-28 14:56:46 +0000
173
@@ -62,48 +62,94 @@
174
62
****
62
****
175
63
***/
63
***/
176
64
64
178
65
bool LiveActions::is_unity()
65
LiveActions::Desktop LiveActions::get_desktop()
179
66
{
66
{
180
67
    static bool cached = false;
67
    static bool cached = false;
182
68
    static bool result;
68
    static LiveActions::Desktop result = LiveActions::OTHER;
183
69
69
184
70
    if (cached) {
70
    if (cached) {
185
71
        return result;
71
        return result;
186
72
    }
72
    }
187
73
73
197
74
    result = false;
74
    // check for unity8
198
75
    const gchar *xdg_current_desktop = g_getenv ("XDG_CURRENT_DESKTOP");
75
    if (g_getenv ("MIR_SOCKET") != nullptr) {
199
76
76
        result = LiveActions::UNITY8;
200
77
    if (xdg_current_desktop != NULL) {
77
     } else {
201
78
        gchar **desktop_names = g_strsplit (xdg_current_desktop, ":", 0);
78
        const gchar *xdg_current_desktop = g_getenv ("XDG_CURRENT_DESKTOP");
202
79
        for (size_t i = 0; desktop_names[i]; ++i) {
79
        if (xdg_current_desktop != NULL) {
203
80
            if (!g_strcmp0 (desktop_names[i], "Unity")) {
80
            gchar **desktop_names = g_strsplit (xdg_current_desktop, ":", 0);
204
81
                result = true;
81
            for (size_t i = 0; desktop_names[i]; ++i) {
205
82
                break;
82
                if (!g_strcmp0 (desktop_names[i], "Unity")) {
206
83
                    result = LiveActions::UNITY7;
207
84
                    break;
208
85
                }
209
83
            }
86
            }
210
87
            g_strfreev (desktop_names);
211
84
        }
88
        }
212
85
        g_strfreev (desktop_names);
213
86
    }
89
    }
214
87
    cached = true;
90
    cached = true;
215
88
    return result;
91
    return result;
216
89
}
92
}
217
90
93
222
91
void LiveActions::desktop_open_settings_app()
94
void LiveActions::open_alarm_app()
223
92
{
95
{
224
93
    if (g_getenv ("MIR_SOCKET") != nullptr)
96
    switch(get_desktop()) {
225
94
    {
97
        case LiveActions::UNITY8:
226
98
            dispatch_url("appid://com.ubuntu.clock/clock/current-user-version");
227
99
            break;
228
100
        case LiveActions::UNITY7:
229
101
        default:
230
102
            execute_command("evolution -c calendar");
231
103
    }
232
104
}
233
105
234
106
void LiveActions::open_appointment(const Appointment& appt, const DateTime& date)
235
107
{
236
108
    switch(get_desktop()) {
237
109
        case LiveActions::UNITY8:
238
110
            unity8_open_appointment(appt, date);
239
111
            break;
240
112
        case LiveActions::UNITY7:
241
113
        default:
242
114
            open_calendar_app(date);
243
115
    }
244
116
}
245
117
246
118
void LiveActions::open_calendar_app(const DateTime& dt)
247
119
{
248
120
    switch(get_desktop()) {
249
121
        case LiveActions::UNITY8:
250
122
        {
251
123
            const auto utc = dt.to_timezone("UTC");
252
124
            auto cmd = utc.format("calendar://startdate=%Y-%m-%dT%H:%M:%S+00:00");
253
125
            dispatch_url(cmd);
254
126
            break;
255
127
        }
256
128
        case LiveActions::UNITY7:
257
129
        default:
258
130
        {
259
131
            const auto utc = dt.start_of_day().to_timezone("UTC");
260
132
            auto cmd = utc.format("evolution \"calendar:///?startdate=%Y%m%dT%H%M%SZ\"");
261
133
            execute_command(cmd.c_str());
262
134
        }
263
135
    }
264
136
}
265
137
266
138
void LiveActions::open_settings_app()
267
139
{
268
140
    switch(get_desktop()) {
269
141
    case LiveActions::UNITY8:
270
95
        dispatch_url("settings:///system/time-date");
142
        dispatch_url("settings:///system/time-date");
274
96
    }
143
        break;
275
97
    else if (is_unity())
144
    case LiveActions::UNITY7:
273
98
    {
276
99
        execute_command("unity-control-center datetime");
145
        execute_command("unity-control-center datetime");
280
100
    }
146
        break;
281
101
    else
147
    default:
279
102
    {
282
103
        execute_command("gnome-control-center datetime");
148
        execute_command("gnome-control-center datetime");
283
104
    }
149
    }
284
105
}
150
}
285
106
151
286
152
287
107
bool LiveActions::desktop_has_calendar_app() const
153
bool LiveActions::desktop_has_calendar_app() const
288
108
{
154
{
289
109
    static bool inited = false;
155
    static bool inited = false;
290
@@ -136,33 +182,7 @@
291
136
    return have_calendar;
182
    return have_calendar;
292
137
}
183
}
293
138
184
321
139
void LiveActions::desktop_open_alarm_app()
185
void LiveActions::unity8_open_appointment(const Appointment& appt, const DateTime& date)
295
140
{
296
141
    execute_command("evolution -c calendar");
297
142
}
298
143
299
144
void LiveActions::desktop_open_appointment(const Appointment&, const DateTime& date)
300
145
{
301
146
    desktop_open_calendar_app(date);
302
147
}
303
148
304
149
void LiveActions::desktop_open_calendar_app(const DateTime& dt)
305
150
{
306
151
    const auto utc = dt.start_of_day().to_timezone("UTC");
307
152
    auto cmd = utc.format("evolution \"calendar:///?startdate=%Y%m%dT%H%M%SZ\"");
308
153
    execute_command(cmd.c_str());
309
154
}
310
155
311
156
/***
312
157
****
313
158
***/
314
159
315
160
void LiveActions::phone_open_alarm_app()
316
161
{
317
162
    dispatch_url("appid://com.ubuntu.clock/clock/current-user-version");
318
163
}
319
164
320
165
void LiveActions::phone_open_appointment(const Appointment& appt, const DateTime& date)
322
166
{
186
{
323
167
    if (!appt.activation_url.empty())
187
    if (!appt.activation_url.empty())
324
168
    {
188
    {
325
@@ -171,28 +191,16 @@
326
171
    else switch (appt.type)
191
    else switch (appt.type)
327
172
    {
192
    {
328
173
        case Appointment::UBUNTU_ALARM:
193
        case Appointment::UBUNTU_ALARM:
330
174
            phone_open_alarm_app();
194
            open_alarm_app();
331
175
            break;
195
            break;
332
176
196
333
177
        case Appointment::EVENT:
197
        case Appointment::EVENT:
334
178
        default:
198
        default:
336
179
            phone_open_calendar_app(date);
199
            open_calendar_app(date);
337
180
            break;
200
            break;
338
181
    }
201
    }
339
182
}
202
}
340
183
203
341
184
void LiveActions::phone_open_calendar_app(const DateTime& dt)
342
185
{
343
186
    const auto utc = dt.to_timezone("UTC");
344
187
    auto cmd = utc.format("calendar://startdate=%Y-%m-%dT%H:%M:%S+00:00");
345
188
    dispatch_url(cmd);
346
189
}
347
190
348
191
void LiveActions::phone_open_settings_app()
349
192
{
350
193
    dispatch_url("settings:///system/time-date");
351
194
}
352
195
353
196
/***
204
/***
354
197
****
205
****
355
198
***/
206
***/
356
199
207
357
=== modified file 'src/actions.cpp'
358
--- src/actions.cpp	2016-03-21 17:32:39 +0000
359
+++ src/actions.cpp	2016-04-28 14:56:46 +0000
360
@@ -62,52 +62,28 @@
361
62
    return false;
62
    return false;
362
63
}
63
}
363
64
64
410
65
void on_desktop_appointment_activated (GSimpleAction*, GVariant *vdata, gpointer gself)
65
void on_appointment_activated (GSimpleAction*, GVariant *vdata, gpointer gself)
411
66
{
66
{
412
67
    auto self = static_cast<Actions*>(gself);
67
    auto self = static_cast<Actions*>(gself);
413
68
    Appointment appt;
68
    Appointment appt;
414
69
    const gchar* uid = nullptr;
69
    const gchar* uid = nullptr;
415
70
    gint64 time = 0;
70
    gint64 time = 0;
416
71
    g_variant_get(vdata, "(&sx)", &uid, &time);
71
    g_variant_get(vdata, "(&sx)", &uid, &time);
417
72
    if (lookup_appointment_by_uid(self->state(), uid, appt))
72
    if (lookup_appointment_by_uid(self->state(), uid, appt))
418
73
        self->desktop_open_appointment(appt, DateTime::Local(time));
73
        self->open_appointment(appt, DateTime::Local(time));
419
74
}
74
}
420
75
void on_desktop_alarm_activated (GSimpleAction*, GVariant*, gpointer gself)
75
void on_alarm_activated (GSimpleAction*, GVariant*, gpointer gself)
421
76
{
76
{
422
77
    static_cast<Actions*>(gself)->desktop_open_alarm_app();
77
    static_cast<Actions*>(gself)->open_alarm_app();
423
78
}
78
}
424
79
void on_desktop_calendar_activated (GSimpleAction*, GVariant* vt, gpointer gself)
79
void on_calendar_activated (GSimpleAction*, GVariant* vt, gpointer gself)
425
80
{
80
{
426
81
    const auto dt = datetime_from_timet_variant(vt);
81
    const auto dt = datetime_from_timet_variant(vt);
427
82
    static_cast<Actions*>(gself)->desktop_open_calendar_app(dt);
82
    static_cast<Actions*>(gself)->open_calendar_app(dt);
428
83
}
83
}
429
84
void on_desktop_settings_activated (GSimpleAction*, GVariant*, gpointer gself)
84
void on_settings_activated (GSimpleAction*, GVariant*, gpointer gself)
430
85
{
85
{
431
86
    static_cast<Actions*>(gself)->desktop_open_settings_app();
86
    static_cast<Actions*>(gself)->open_settings_app();
386
87
}
387
88
388
89
void on_phone_appointment_activated (GSimpleAction*, GVariant *vdata, gpointer gself)
389
90
{
390
91
    auto self = static_cast<Actions*>(gself);
391
92
    Appointment appt;
392
93
    const gchar* uid = nullptr;
393
94
    gint64 time = 0;
394
95
    g_variant_get(vdata, "(&sx)", &uid, &time);
395
96
    if (lookup_appointment_by_uid(self->state(), uid, appt))
396
97
        self->phone_open_appointment(appt, DateTime::Local(time));
397
98
}
398
99
void on_phone_alarm_activated (GSimpleAction*, GVariant*, gpointer gself)
399
100
{
400
101
    static_cast<Actions*>(gself)->phone_open_alarm_app();
401
102
}
402
103
void on_phone_calendar_activated (GSimpleAction*, GVariant* vt, gpointer gself)
403
104
{
404
105
    const auto dt = datetime_from_timet_variant(vt);
405
106
    static_cast<Actions*>(gself)->phone_open_calendar_app(dt);
406
107
}
407
108
void on_phone_settings_activated (GSimpleAction*, GVariant*, gpointer gself)
408
109
{
409
110
    static_cast<Actions*>(gself)->phone_open_settings_app();
432
111
}
87
}
433
112
88
434
113
89
435
@@ -136,9 +112,9 @@
436
136
    }
112
    }
437
137
}
113
}
438
138
114
442
139
void on_calendar_activated(GSimpleAction * /*action*/,
115
void on_calendar_date_activated(GSimpleAction * /*action*/,
443
140
                           GVariant      * state,
116
                                GVariant      * state,
444
141
                           gpointer        gself)
117
                                gpointer        gself)
445
142
{
118
{
446
143
    const time_t t = g_variant_get_int64(state);
119
    const time_t t = g_variant_get_int64(state);
447
144
120
448
@@ -200,15 +176,15 @@
449
200
{
176
{
450
201
    GActionEntry entries[] = {
177
    GActionEntry entries[] = {
451
202
178
456
203
        { "desktop.open-appointment",  on_desktop_appointment_activated, "(sx)", nullptr },
179
        { "desktop.open-appointment",  on_appointment_activated, "(sx)", nullptr },
457
204
        { "desktop.open-alarm-app",    on_desktop_alarm_activated },
180
        { "desktop.open-alarm-app",    on_alarm_activated },
458
205
        { "desktop.open-calendar-app", on_desktop_calendar_activated, "x", nullptr },
181
        { "desktop.open-calendar-app", on_calendar_activated, "x", nullptr },
459
206
        { "desktop.open-settings-app", on_desktop_settings_activated },
182
        { "desktop.open-settings-app", on_settings_activated },
460
207
183
465
208
        { "phone.open-appointment",    on_phone_appointment_activated, "(sx)", nullptr },
184
        { "phone.open-appointment",    on_appointment_activated, "(sx)", nullptr },
466
209
        { "phone.open-alarm-app",      on_phone_alarm_activated },
185
        { "phone.open-alarm-app",      on_alarm_activated },
467
210
        { "phone.open-calendar-app",   on_phone_calendar_activated, "x", nullptr },
186
        { "phone.open-calendar-app",   on_calendar_activated, "x", nullptr },
468
211
        { "phone.open-settings-app",   on_phone_settings_activated },
187
        { "phone.open-settings-app",   on_settings_activated },
469
212
188
470
213
        { "calendar-active", nullptr, nullptr, "false", on_calendar_active_changed },
189
        { "calendar-active", nullptr, nullptr, "false", on_calendar_active_changed },
471
214
        { "set-location", on_set_location, "s" }
190
        { "set-location", on_set_location, "s" }
472
@@ -242,7 +218,7 @@
473
242
    v = create_calendar_state(state);
218
    v = create_calendar_state(state);
474
243
    a = g_simple_action_new_stateful("calendar", G_VARIANT_TYPE_INT64, v);
219
    a = g_simple_action_new_stateful("calendar", G_VARIANT_TYPE_INT64, v);
475
244
    g_action_map_add_action(gam, G_ACTION(a));
220
    g_action_map_add_action(gam, G_ACTION(a));
477
245
    g_signal_connect(a, "activate", G_CALLBACK(on_calendar_activated), this);
221
    g_signal_connect(a, "activate", G_CALLBACK(on_calendar_date_activated), this);
478
246
    g_object_unref(a);
222
    g_object_unref(a);
479
247
223
480
248
    ///
224
    ///
481
249
225
482
=== modified file 'src/haptic.cpp'
483
--- src/haptic.cpp	2014-08-01 00:52:42 +0000
484
+++ src/haptic.cpp	2016-04-28 14:56:46 +0000
485
@@ -37,9 +37,10 @@
486
37
{
37
{
487
38
public:
38
public:
488
39
39
490
40
    Impl(const Mode& mode):
40
    Impl(const Mode& mode, bool repeat):
491
41
        m_mode(mode),
41
        m_mode(mode),
493
42
        m_cancellable(g_cancellable_new())
42
        m_cancellable(g_cancellable_new()),
494
43
        m_repeat(repeat)
495
43
    {
44
    {
496
44
        g_bus_get (G_BUS_TYPE_SESSION, m_cancellable, on_bus_ready, this);
45
        g_bus_get (G_BUS_TYPE_SESSION, m_cancellable, on_bus_ready, this);
497
45
    }
46
    }
498
@@ -93,11 +94,15 @@
499
93
                // one second on, one second off.
94
                // one second on, one second off.
500
94
                m_pattern = std::vector<uint32_t>({1000u, 1000u});
95
                m_pattern = std::vector<uint32_t>({1000u, 1000u});
501
95
                break;
96
                break;
507
96
        }
97
508
97
98
        }
509
98
        // Set up a loop to keep repeating the pattern
99
510
99
        auto msec = std::accumulate(m_pattern.begin(), m_pattern.end(), 0u);
100
        if (m_repeat)
511
100
        m_tag = g_timeout_add(msec, call_vibrate_pattern_static, this);
101
        {
512
102
            // Set up a loop to keep repeating the pattern
513
103
            auto msec = std::accumulate(m_pattern.begin(), m_pattern.end(), 0u);
514
104
            m_tag = g_timeout_add(msec, call_vibrate_pattern_static, this);
515
105
        }
516
101
        call_vibrate_pattern();
106
        call_vibrate_pattern();
517
102
    }
107
    }
518
103
108
519
@@ -146,14 +151,15 @@
520
146
    GDBusConnection * m_bus = nullptr;
151
    GDBusConnection * m_bus = nullptr;
521
147
    std::vector<uint32_t> m_pattern;
152
    std::vector<uint32_t> m_pattern;
522
148
    guint m_tag = 0;
153
    guint m_tag = 0;
523
154
    bool m_repeat = false;
524
149
};
155
};
525
150
156
526
151
/***
157
/***
527
152
****
158
****
528
153
***/
159
***/
529
154
160
532
155
Haptic::Haptic(const Mode& mode):
161
Haptic::Haptic(const Mode& mode, bool repeat):
533
156
    impl(new Impl (mode))
162
    impl(new Impl (mode, repeat))
534
157
{
163
{
535
158
}
164
}
536
159
165
537
160
166
538
=== modified file 'src/main.cpp'
539
--- src/main.cpp	2016-04-28 14:56:46 +0000
540
+++ src/main.cpp	2016-04-28 14:56:46 +0000
541
@@ -152,7 +152,9 @@
542
152
    auto on_snooze = [snooze_planner](const Appointment& appointment, const Alarm& alarm) {
152
    auto on_snooze = [snooze_planner](const Appointment& appointment, const Alarm& alarm) {
543
153
        snooze_planner->add(appointment, alarm);
153
        snooze_planner->add(appointment, alarm);
544
154
    };
154
    };
546
155
    auto on_ok = [](const Appointment&, const Alarm&){};
155
    auto on_ok = [actions](const Appointment& app, const Alarm&){
547
156
        actions->open_appointment(app, app.begin);
548
157
    };
549
156
    auto on_alarm_reached = [&engine, &snap, &on_snooze, &on_ok](const Appointment& appointment, const Alarm& alarm) {
158
    auto on_alarm_reached = [&engine, &snap, &on_snooze, &on_ok](const Appointment& appointment, const Alarm& alarm) {
550
157
        (*snap)(appointment, alarm, on_snooze, on_ok);
159
        (*snap)(appointment, alarm, on_snooze, on_ok);
551
158
        engine->disable_ubuntu_alarm(appointment);
160
        engine->disable_ubuntu_alarm(appointment);
552
159
161
553
=== modified file 'src/notifications.cpp'
554
--- src/notifications.cpp	2014-09-17 17:08:01 +0000
555
+++ src/notifications.cpp	2016-04-28 14:56:46 +0000
556
@@ -21,10 +21,21 @@
557
21
21
558
22
#include <libnotify/notify.h>
22
#include <libnotify/notify.h>
559
23
23
560
24
#include <messaging-menu/messaging-menu-app.h>
561
25
#include <messaging-menu/messaging-menu-message.h>
562
26
563
27
#include <libubuntu-app-launch-2/ubuntu-app-launch/appid.h>
564
28
565
29
#include <uuid/uuid.h>
566
30
567
31
#include <gio/gdesktopappinfo.h>
568
32
569
24
#include <map>
33
#include <map>
570
25
#include <set>
34
#include <set>
571
26
#include <string>
35
#include <string>
572
27
#include <vector>
36
#include <vector>
573
37
#include <memory>
574
38
575
28
39
576
29
namespace unity {
40
namespace unity {
577
30
namespace indicator {
41
namespace indicator {
578
@@ -45,9 +56,11 @@
579
45
    std::string m_body;
56
    std::string m_body;
580
46
    std::string m_icon_name;
57
    std::string m_icon_name;
581
47
    std::chrono::seconds m_duration;
58
    std::chrono::seconds m_duration;
582
59
    gint64 m_start_time  {};
583
48
    std::set<std::string> m_string_hints;
60
    std::set<std::string> m_string_hints;
584
49
    std::vector<std::pair<std::string,std::string>> m_actions;
61
    std::vector<std::pair<std::string,std::string>> m_actions;
585
50
    std::function<void(const std::string&)> m_closed_callback;
62
    std::function<void(const std::string&)> m_closed_callback;
586
63
    std::function<void()> m_timeout_callback;
587
51
};
64
};
588
52
65
589
53
Builder::Builder():
66
Builder::Builder():
590
@@ -101,6 +114,18 @@
591
101
  impl->m_closed_callback.swap (cb);
114
  impl->m_closed_callback.swap (cb);
592
102
}
115
}
593
103
116
594
117
void
595
118
Builder::set_timeout_callback (std::function<void()> cb)
596
119
{
597
120
  impl->m_timeout_callback.swap (cb);
598
121
}
599
122
600
123
void
601
124
Builder::set_start_time (uint64_t time)
602
125
{
603
126
  impl->m_start_time = time;
604
127
}
605
128
606
104
/***
129
/***
607
105
****
130
****
608
106
***/
131
***/
609
@@ -110,7 +135,14 @@
610
110
    struct notification_data
135
    struct notification_data
611
111
    {
136
    {
612
112
        std::shared_ptr<NotifyNotification> nn;
137
        std::shared_ptr<NotifyNotification> nn;
614
113
        std::function<void(const std::string&)> closed_callback;
138
        Builder::Impl data;
615
139
    };
616
140
617
141
    struct messaging_menu_data
618
142
    {
619
143
        std::string msg_id;
620
144
        std::function<void()> callback;
621
145
        Engine::Impl *self;
622
114
    };
146
    };
623
115
147
624
116
public:
148
public:
625
@@ -120,13 +152,23 @@
626
120
    {
152
    {
627
121
        if (!notify_init(app_name.c_str()))
153
        if (!notify_init(app_name.c_str()))
628
122
            g_critical("Unable to initialize libnotify!");
154
            g_critical("Unable to initialize libnotify!");
629
155
630
156
        // messaging menu
631
157
        auto app_id = calendar_app_id();
632
158
        if (!app_id.empty()) {
633
159
            m_messaging_app.reset(messaging_menu_app_new(app_id.c_str()), g_object_unref);
634
160
            messaging_menu_app_register(m_messaging_app.get());
635
161
        }
636
123
    }
162
    }
637
124
163
638
125
    ~Impl()
164
    ~Impl()
639
126
    {
165
    {
640
127
        close_all ();
166
        close_all ();
641
167
        remove_all ();
642
128
168
643
129
        notify_uninit ();
169
        notify_uninit ();
644
170
        if (m_messaging_app)
645
171
            messaging_menu_app_unregister (m_messaging_app.get());
646
130
    }
172
    }
647
131
173
648
132
    const std::string& app_name() const
174
    const std::string& app_name() const
649
@@ -217,7 +259,7 @@
650
217
                            notification_key_quark(),
259
                            notification_key_quark(),
651
218
                            GINT_TO_POINTER(key));
260
                            GINT_TO_POINTER(key));
652
219
261
654
220
        m_notifications[key] = { nn, info.m_closed_callback };
262
        m_notifications[key] = { nn, info };
655
221
        g_signal_connect (nn.get(), "closed",
263
        g_signal_connect (nn.get(), "closed",
656
222
                          G_CALLBACK(on_notification_closed), this);
264
                          G_CALLBACK(on_notification_closed), this);
657
223
     
265
     
658
@@ -238,6 +280,72 @@
659
238
        return ret;
280
        return ret;
660
239
    }
281
    }
661
240
282
662
283
    std::string post(const Builder::Impl& data)
663
284
    {
664
285
        if (!m_messaging_app) {
665
286
            return std::string();
666
287
        }
667
288
        uuid_t message_uuid;
668
289
        uuid_generate(message_uuid);
669
290
670
291
        char uuid_buf[37];
671
292
        uuid_unparse(message_uuid, uuid_buf);
672
293
        const std::string message_id(uuid_buf);
673
294
674
295
        // use full icon path name, "calendar-app" does not work with themed icons
675
296
        auto icon_file = g_file_new_for_path(calendar_app_icon().c_str());
676
297
        // messaging_menu_message_new: will take control of icon object
677
298
        GIcon *icon = g_file_icon_new(icon_file);
678
299
        g_object_unref(icon_file);
679
300
680
301
        // check if source exists
681
302
        if (!messaging_menu_app_has_source(m_messaging_app.get(), m_app_name.c_str()))
682
303
            messaging_menu_app_append_source(m_messaging_app.get(), m_app_name.c_str(), nullptr, "Calendar");
683
304
684
305
        auto msg = messaging_menu_message_new(message_id.c_str(),
685
306
                                              icon,
686
307
                                              data.m_title.c_str(),
687
308
                                              nullptr,
688
309
                                              data.m_body.c_str(),
689
310
                                              data.m_start_time * G_USEC_PER_SEC); // secs -> microsecs
690
311
        if (msg)
691
312
        {
692
313
            std::shared_ptr<messaging_menu_data> msg_data(new messaging_menu_data{message_id, data.m_timeout_callback, this});
693
314
            m_messaging_messages[message_id] = msg_data;
694
315
            g_signal_connect(G_OBJECT(msg), "activate",
695
316
                             G_CALLBACK(on_message_activated), msg_data.get());
696
317
            messaging_menu_app_append_message(m_messaging_app.get(), msg, m_app_name.c_str(), false);
697
318
698
319
            // we use that to keep track of messaging, in case of message get cleared from menu
699
320
            g_object_set_data_full(G_OBJECT(msg), "destroy-notify", msg_data.get(), on_message_destroyed);
700
321
            // keep the message control with message_menu
701
322
            g_object_unref(msg);
702
323
703
324
            return message_id;
704
325
        } else {
705
326
            g_warning("Fail to create messaging menu message");
706
327
        }
707
328
        return "";
708
329
    }
709
330
710
331
    void remove (const std::string &key)
711
332
    {
712
333
        auto it = m_messaging_messages.find(key);
713
334
        if (it != m_messaging_messages.end())
714
335
        {
715
336
            // tell the server to remove message
716
337
            messaging_menu_app_remove_message_by_id(m_messaging_app.get(), it->second->msg_id.c_str());
717
338
            // message will be remove by on_message_destroyed cb.
718
339
        }
719
340
    }
720
341
721
342
    void remove_all ()
722
343
    {
723
344
        // call remove() on all our keys
724
345
        while (!m_messaging_messages.empty())
725
346
            remove(m_messaging_messages.begin()->first);
726
347
    }
727
348
728
241
private:
349
private:
729
242
350
730
243
    const std::set<std::string>& server_caps() const
351
    const std::set<std::string>& server_caps() const
731
@@ -279,6 +387,28 @@
732
279
        static_cast<Impl*>(gself)->remove_closed_notification(GPOINTER_TO_INT(gkey));
387
        static_cast<Impl*>(gself)->remove_closed_notification(GPOINTER_TO_INT(gkey));
733
280
    }
388
    }
734
281
389
735
390
    static void on_message_activated (MessagingMenuMessage *,
736
391
                                      const char *,
737
392
                                      GVariant *,
738
393
                                      gpointer data)
739
394
    {
740
395
        auto msg_data =  static_cast<messaging_menu_data*>(data);
741
396
        auto it = msg_data->self->m_messaging_messages.find(msg_data->msg_id);
742
397
        g_return_if_fail (it != msg_data->self->m_messaging_messages.end());
743
398
        const auto& ndata = it->second;
744
399
745
400
        if (ndata->callback)
746
401
            ndata->callback();
747
402
    }
748
403
749
404
    static void on_message_destroyed(gpointer data)
750
405
    {
751
406
        auto msg_data = static_cast<messaging_menu_data*>(data);
752
407
        auto it = msg_data->self->m_messaging_messages.find(msg_data->msg_id);
753
408
        if (it != msg_data->self->m_messaging_messages.end())
754
409
            msg_data->self->m_messaging_messages.erase(it);
755
410
    }
756
411
757
282
    void remove_closed_notification (int key)
412
    void remove_closed_notification (int key)
758
283
    {
413
    {
759
284
        auto it = m_notifications.find(key);
414
        auto it = m_notifications.find(key);
760
@@ -286,25 +416,59 @@
761
286
416
762
287
        const auto& ndata = it->second;
417
        const auto& ndata = it->second;
763
288
        auto nn = ndata.nn.get();
418
        auto nn = ndata.nn.get();
765
289
        if (ndata.closed_callback)
419
766
420
        if (ndata.data.m_closed_callback)
767
290
        {
421
        {
768
291
            std::string action;
422
            std::string action;
769
292
770
293
            const GQuark q = notification_action_quark();
423
            const GQuark q = notification_action_quark();
771
294
            const gpointer p = g_object_get_qdata(G_OBJECT(nn), q);
424
            const gpointer p = g_object_get_qdata(G_OBJECT(nn), q);
772
295
            if (p != nullptr)
425
            if (p != nullptr)
773
296
                action = static_cast<const char*>(p);
426
                action = static_cast<const char*>(p);
774
297
427
776
298
            ndata.closed_callback (action);
428
            ndata.data.m_closed_callback (action);
777
429
            // empty action means that the notification got timeout
778
430
            // post a message on messaging menu
779
431
            if (action.empty())
780
432
                post(ndata.data);
781
299
        }
433
        }
782
300
434
783
301
        m_notifications.erase(it);
435
        m_notifications.erase(it);
784
302
    }
436
    }
785
303
437
786
438
    static std::string calendar_app_id()
787
439
    {
788
440
        auto app_id = ubuntu::app_launch::AppID::discover("com.ubuntu.calendar");
789
441
        if (!app_id.empty())
790
442
            // Due the use of old API by messaging_menu we need append a extra ".desktop" to the app_id.
791
443
            return std::string(app_id) + ".desktop";
792
444
        else
793
445
            return std::string();
794
446
    }
795
447
796
448
    static std::string calendar_app_icon()
797
449
    {
798
450
        auto app_desktop = g_desktop_app_info_new(calendar_app_id().c_str());
799
451
        if (app_desktop != nullptr) {
800
452
            auto icon_name = g_desktop_app_info_get_string(app_desktop, "Icon");
801
453
            g_object_unref(app_desktop);
802
454
            if (icon_name) {
803
455
                std::string result(icon_name);
804
456
                g_free(icon_name);
805
457
                return result;
806
458
            }
807
459
        }
808
460
        g_warning("Fail to get calendar icon");
809
461
        return std::string();
810
462
    }
811
463
812
304
    /***
464
    /***
813
305
    ****
465
    ****
814
306
    ***/
466
    ***/
815
307
467
816
468
    // messaging menu
817
469
    std::shared_ptr<MessagingMenuApp> m_messaging_app;
818
470
    std::map<std::string, std::shared_ptr<messaging_menu_data> > m_messaging_messages;
819
471
820
308
    const std::string m_app_name;
472
    const std::string m_app_name;
821
309
473
822
310
    // key-to-data
474
    // key-to-data
823
311
475
824
=== modified file 'src/snap.cpp'
825
--- src/snap.cpp	2016-04-28 14:56:46 +0000
826
+++ src/snap.cpp	2016-04-28 14:56:46 +0000
827
@@ -116,15 +116,16 @@
828
116
        if (should_vibrate()) {
116
        if (should_vibrate()) {
829
117
            const auto haptic_mode = m_settings->alarm_haptic.get();
117
            const auto haptic_mode = m_settings->alarm_haptic.get();
830
118
            if (haptic_mode == "pulse")
118
            if (haptic_mode == "pulse")
832
119
                haptic = std::make_shared<uin::Haptic>(uin::Haptic::MODE_PULSE);
119
                haptic = std::make_shared<uin::Haptic>(uin::Haptic::MODE_PULSE, appointment.is_ubuntu_alarm());
833
120
        }
120
        }
834
121
121
835
122
        // show a notification...
122
        // show a notification...
836
123
        const auto minutes = std::chrono::minutes(m_settings->alarm_duration.get());
123
        const auto minutes = std::chrono::minutes(m_settings->alarm_duration.get());
837
124
        uin::Builder b;
124
        uin::Builder b;
838
125
        b.set_body (appointment.summary);
125
        b.set_body (appointment.summary);
840
126
        b.set_icon_name (appointment.is_ubuntu_alarm() ? "alarm-clock" : "reminder");
126
        b.set_icon_name (appointment.is_ubuntu_alarm() ? "alarm-clock" : "calendar-app");
841
127
        b.add_hint (uin::Builder::HINT_NONSHAPED_ICON);
127
        b.add_hint (uin::Builder::HINT_NONSHAPED_ICON);
842
128
        b.set_start_time (appointment.begin.to_unix());
843
128
129
844
129
        const char * timefmt;
130
        const char * timefmt;
845
130
        if (is_locale_12h()) {
131
        if (is_locale_12h()) {
846
@@ -150,6 +151,9 @@
847
150
            b.add_hint (uin::Builder::HINT_AFFIRMATIVE_HINT);
151
            b.add_hint (uin::Builder::HINT_AFFIRMATIVE_HINT);
848
151
            b.add_action ("ok", _("OK"));
152
            b.add_action ("ok", _("OK"));
849
152
            b.add_action ("snooze", _("Snooze"));
153
            b.add_action ("snooze", _("Snooze"));
850
154
        } else {
851
155
            b.add_hint (uin::Builder::HINT_INTERACTIVE);
852
156
            b.add_action ("ok", _("OK"));
853
153
        }
157
        }
854
154
158
855
155
        // add 'sound', 'haptic', and 'awake' objects to the capture so
159
        // add 'sound', 'haptic', and 'awake' objects to the capture so
856
@@ -159,10 +163,17 @@
857
159
                              (const std::string& action){
163
                              (const std::string& action){
858
160
            if (action == "snooze")
164
            if (action == "snooze")
859
161
                snooze(appointment, alarm);
165
                snooze(appointment, alarm);
861
162
            else
166
            else if (action == "ok")
862
163
                ok(appointment, alarm);
167
                ok(appointment, alarm);
863
164
        });
168
        });
864
165
169
865
170
        //TODO: we need to extend it to support alarms appoitments
866
171
        if (!appointment.is_ubuntu_alarm()) {
867
172
            b.set_timeout_callback([appointment, alarm, ok](){
868
173
                ok(appointment, alarm);
869
174
            });
870
175
        }
871
176
872
166
        const auto key = m_engine->show(b);
177
        const auto key = m_engine->show(b);
873
167
        if (key)
178
        if (key)
874
168
            m_notifications.insert (key);
179
            m_notifications.insert (key);
875
169
180
876
=== modified file 'tests/actions-mock.h'
877
--- tests/actions-mock.h	2016-03-21 17:32:39 +0000
878
+++ tests/actions-mock.h	2016-04-28 14:56:46 +0000
879
@@ -34,14 +34,10 @@
880
34
    explicit MockActions(const std::shared_ptr<State>& state_in): Actions(state_in) {}
34
    explicit MockActions(const std::shared_ptr<State>& state_in): Actions(state_in) {}
881
35
    ~MockActions() =default;
35
    ~MockActions() =default;
882
36
36
891
37
    enum Action { DesktopOpenAlarmApp,
37
    enum Action { OpenAlarmApp,
892
38
                  DesktopOpenAppt,
38
                  OpenAppt,
893
39
                  DesktopOpenCalendarApp,
39
                  OpenCalendarApp,
894
40
                  DesktopOpenSettingsApp,
40
                  OpenSettingsApp,
887
41
                  PhoneOpenAlarmApp,
888
42
                  PhoneOpenAppt,
889
43
                  PhoneOpenCalendarApp,
890
44
                  PhoneOpenSettingsApp,
895
45
                  SetLocation };
41
                  SetLocation };
896
46
42
897
47
    const std::vector<Action>& history() const { return m_history; }
43
    const std::vector<Action>& history() const { return m_history; }
898
@@ -54,36 +50,20 @@
899
54
    bool desktop_has_calendar_app() const {
50
    bool desktop_has_calendar_app() const {
900
55
        return m_desktop_has_calendar_app;
51
        return m_desktop_has_calendar_app;
901
56
    }
52
    }
932
57
    void desktop_open_alarm_app() {
53
    void open_alarm_app() {
933
58
        m_history.push_back(DesktopOpenAlarmApp);
54
        m_history.push_back(OpenAlarmApp);
934
59
    }
55
    }
935
60
    void desktop_open_appointment(const Appointment& appt, const DateTime& dt) {
56
    void open_appointment(const Appointment& appt, const DateTime& dt) {
936
61
        m_appt = appt;
57
        m_appt = appt;
937
62
        m_date_time = dt;
58
        m_date_time = dt;
938
63
        m_history.push_back(DesktopOpenAppt);
59
        m_history.push_back(OpenAppt);
939
64
    }
60
    }
940
65
    void desktop_open_calendar_app(const DateTime& dt) {
61
    void open_calendar_app(const DateTime& dt) {
941
66
        m_date_time = dt;
62
        m_date_time = dt;
942
67
        m_history.push_back(DesktopOpenCalendarApp);
63
        m_history.push_back(OpenCalendarApp);
943
68
    }
64
    }
944
69
    void desktop_open_settings_app() {
65
    void open_settings_app() {
945
70
        m_history.push_back(DesktopOpenSettingsApp);
66
        m_history.push_back(OpenSettingsApp);
916
71
    }
917
72
918
73
    void phone_open_alarm_app() {
919
74
        m_history.push_back(PhoneOpenAlarmApp);
920
75
    }
921
76
    void phone_open_appointment(const Appointment& appt, const DateTime& dt) {
922
77
        m_appt = appt;
923
78
        m_date_time = dt;
924
79
        m_history.push_back(PhoneOpenAppt);
925
80
    }
926
81
    void phone_open_calendar_app(const DateTime& dt) {
927
82
        m_date_time = dt;
928
83
        m_history.push_back(PhoneOpenCalendarApp);
929
84
    }
930
85
    void phone_open_settings_app() {
931
86
        m_history.push_back(PhoneOpenSettingsApp);
946
87
    }
67
    }
947
88
68
948
89
    void set_location(const std::string& zone_, const std::string& name_) {
69
    void set_location(const std::string& zone_, const std::string& name_) {
949
90
70
950
=== modified file 'tests/test-actions.cpp'
951
--- tests/test-actions.cpp	2016-03-21 17:32:39 +0000
952
+++ tests/test-actions.cpp	2016-04-28 14:56:46 +0000
953
@@ -175,25 +175,25 @@
954
175
TEST_F(ActionsFixture, DesktopOpenAlarmApp)
175
TEST_F(ActionsFixture, DesktopOpenAlarmApp)
955
176
{
176
{
956
177
    test_action_with_no_args("desktop.open-alarm-app",
177
    test_action_with_no_args("desktop.open-alarm-app",
958
178
                             MockActions::DesktopOpenAlarmApp);
178
                             MockActions::OpenAlarmApp);
959
179
}
179
}
960
180
180
961
181
TEST_F(ActionsFixture, DesktopOpenAppointment)
181
TEST_F(ActionsFixture, DesktopOpenAppointment)
962
182
{
182
{
963
183
    test_action_with_appt_arg("desktop.open-appointment",
183
    test_action_with_appt_arg("desktop.open-appointment",
965
184
                              MockActions::DesktopOpenAppt);
184
                              MockActions::OpenAppt);
966
185
}
185
}
967
186
186
968
187
TEST_F(ActionsFixture, DesktopOpenCalendarApp)
187
TEST_F(ActionsFixture, DesktopOpenCalendarApp)
969
188
{
188
{
970
189
    test_action_with_time_arg("desktop.open-calendar-app",
189
    test_action_with_time_arg("desktop.open-calendar-app",
972
190
                              MockActions::DesktopOpenCalendarApp);
190
                              MockActions::OpenCalendarApp);
973
191
}
191
}
974
192
192
975
193
TEST_F(ActionsFixture, DesktopOpenSettingsApp)
193
TEST_F(ActionsFixture, DesktopOpenSettingsApp)
976
194
{
194
{
977
195
    test_action_with_no_args("desktop.open-settings-app",
195
    test_action_with_no_args("desktop.open-settings-app",
979
196
                             MockActions::DesktopOpenSettingsApp);
196
                             MockActions::OpenSettingsApp);
980
197
}
197
}
981
198
198
982
199
/***
199
/***
983
@@ -203,25 +203,25 @@
984
203
TEST_F(ActionsFixture, PhoneOpenAlarmApp)
203
TEST_F(ActionsFixture, PhoneOpenAlarmApp)
985
204
{
204
{
986
205
    test_action_with_no_args("phone.open-alarm-app",
205
    test_action_with_no_args("phone.open-alarm-app",
988
206
                             MockActions::PhoneOpenAlarmApp);
206
                             MockActions::OpenAlarmApp);
989
207
}
207
}
990
208
208
991
209
TEST_F(ActionsFixture, PhoneOpenAppointment)
209
TEST_F(ActionsFixture, PhoneOpenAppointment)
992
210
{
210
{
993
211
    test_action_with_appt_arg("phone.open-appointment",
211
    test_action_with_appt_arg("phone.open-appointment",
995
212
                              MockActions::PhoneOpenAppt);
212
                              MockActions::OpenAppt);
996
213
}
213
}
997
214
214
998
215
TEST_F(ActionsFixture, PhoneOpenCalendarApp)
215
TEST_F(ActionsFixture, PhoneOpenCalendarApp)
999
216
{
216
{
1000
217
    test_action_with_time_arg("phone.open-calendar-app",
217
    test_action_with_time_arg("phone.open-calendar-app",
1002
218
                              MockActions::PhoneOpenCalendarApp);
218
                              MockActions::OpenCalendarApp);
1003
219
}
219
}
1004
220
220
1005
221
TEST_F(ActionsFixture, PhoneOpenSettingsApp)
221
TEST_F(ActionsFixture, PhoneOpenSettingsApp)
1006
222
{
222
{
1007
223
    test_action_with_no_args("phone.open-settings-app",
223
    test_action_with_no_args("phone.open-settings-app",
1009
224
                             MockActions::PhoneOpenSettingsApp);
224
                             MockActions::OpenSettingsApp);
1010
225
}
225
}
1011
226
226
1012
227
/***
227
/***
1013
228
228
1014
=== modified file 'tests/test-live-actions.cpp'
1015
--- tests/test-live-actions.cpp	2016-04-10 00:07:04 +0000
1016
+++ tests/test-live-actions.cpp	2016-04-28 14:56:46 +0000
1017
@@ -29,10 +29,16 @@
1018
29
public:
29
public:
1019
30
    std::string last_cmd;
30
    std::string last_cmd;
1020
31
    std::string last_url;
31
    std::string last_url;
1021
32
1022
33
1023
32
    explicit MockLiveActions(const std::shared_ptr<State>& state_in): LiveActions(state_in) {}
34
    explicit MockLiveActions(const std::shared_ptr<State>& state_in): LiveActions(state_in) {}
1024
33
    ~MockLiveActions() {}
35
    ~MockLiveActions() {}
1025
36
    void set_desktop(LiveActions::Desktop desktop) { m_desktop = desktop; }
1026
34
37
1027
35
protected:
38
protected:
1028
39
    LiveActions::Desktop m_desktop;
1029
40
1030
41
    LiveActions::Desktop get_desktop() override { return m_desktop; }
1031
36
    void dispatch_url(const std::string& url) override { last_url = url; }
42
    void dispatch_url(const std::string& url) override { last_url = url; }
1032
37
    void execute_command(const std::string& cmd) override { last_cmd = cmd; }
43
    void execute_command(const std::string& cmd) override { last_cmd = cmd; }
1033
38
};
44
};
1034
@@ -112,31 +118,39 @@
1035
112
118
1036
113
TEST_F(TestLiveActionsFixture, DesktopOpenAlarmApp)
119
TEST_F(TestLiveActionsFixture, DesktopOpenAlarmApp)
1037
114
{
120
{
1039
115
    m_actions->desktop_open_alarm_app();
121
    m_live_actions->set_desktop(LiveActions::UNITY7);
1040
122
1041
123
    m_actions->open_alarm_app();
1042
116
    const std::string expected = "evolution -c calendar";
124
    const std::string expected = "evolution -c calendar";
1043
117
    EXPECT_EQ(expected, m_live_actions->last_cmd);
125
    EXPECT_EQ(expected, m_live_actions->last_cmd);
1044
118
}
126
}
1045
119
127
1046
120
TEST_F(TestLiveActionsFixture, DesktopOpenAppointment)
128
TEST_F(TestLiveActionsFixture, DesktopOpenAppointment)
1047
121
{
129
{
1048
130
    m_live_actions->set_desktop(LiveActions::UNITY7);
1049
131
1050
122
    Appointment a;
132
    Appointment a;
1051
123
    a.uid = "some-uid";
133
    a.uid = "some-uid";
1052
124
    a.begin = DateTime::NowLocal();
134
    a.begin = DateTime::NowLocal();
1054
125
    m_actions->desktop_open_appointment(a, a.begin);
135
    m_actions->open_appointment(a, a.begin);
1055
126
    const std::string expected_substr = "evolution \"calendar:///?startdate=";
136
    const std::string expected_substr = "evolution \"calendar:///?startdate=";
1056
127
    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
137
    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
1057
128
}
138
}
1058
129
139
1059
130
TEST_F(TestLiveActionsFixture, DesktopOpenCalendarApp)
140
TEST_F(TestLiveActionsFixture, DesktopOpenCalendarApp)
1060
131
{
141
{
1062
132
    m_actions->desktop_open_calendar_app(DateTime::NowLocal());
142
    m_live_actions->set_desktop(LiveActions::UNITY7);
1063
143
1064
144
    m_actions->open_calendar_app(DateTime::NowLocal());
1065
133
    const std::string expected_substr = "evolution \"calendar:///?startdate=";
145
    const std::string expected_substr = "evolution \"calendar:///?startdate=";
1066
134
    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
146
    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
1067
135
}
147
}
1068
136
148
1069
137
TEST_F(TestLiveActionsFixture, DesktopOpenSettingsApp)
149
TEST_F(TestLiveActionsFixture, DesktopOpenSettingsApp)
1070
138
{
150
{
1072
139
    m_actions->desktop_open_settings_app();
151
    m_live_actions->set_desktop(LiveActions::UNITY7);
1073
152
1074
153
    m_actions->open_settings_app();
1075
140
    const std::string expected_substr = "control-center";
154
    const std::string expected_substr = "control-center";
1076
141
    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
155
    EXPECT_NE(m_live_actions->last_cmd.find(expected_substr), std::string::npos);
1077
142
}
156
}
1078
@@ -152,12 +166,16 @@
1079
152
166
1080
153
TEST_F(TestLiveActionsFixture, PhoneOpenAlarmApp)
167
TEST_F(TestLiveActionsFixture, PhoneOpenAlarmApp)
1081
154
{
168
{
1083
155
    m_actions->phone_open_alarm_app();
169
    m_live_actions->set_desktop(LiveActions::UNITY8);
1084
170
1085
171
    m_actions->open_alarm_app();
1086
156
    EXPECT_EQ(clock_app_url, m_live_actions->last_url);
172
    EXPECT_EQ(clock_app_url, m_live_actions->last_url);
1087
157
}
173
}
1088
158
174
1089
159
TEST_F(TestLiveActionsFixture, PhoneOpenAppointment)
175
TEST_F(TestLiveActionsFixture, PhoneOpenAppointment)
1090
160
{
176
{
1091
177
    m_live_actions->set_desktop(LiveActions::UNITY8);
1092
178
1093
161
    Appointment a;
179
    Appointment a;
1094
162
180
1095
163
    a.uid = "event-uid";
181
    a.uid = "event-uid";
1096
@@ -165,19 +183,21 @@
1097
165
    a.begin = DateTime::NowLocal();
183
    a.begin = DateTime::NowLocal();
1098
166
    a.type = Appointment::EVENT;
184
    a.type = Appointment::EVENT;
1099
167
    auto ocurrenceDate = DateTime::Local(2014, 1, 1, 0, 0, 0);
185
    auto ocurrenceDate = DateTime::Local(2014, 1, 1, 0, 0, 0);
1101
168
    m_actions->phone_open_appointment(a, ocurrenceDate);
186
    m_actions->open_appointment(a, ocurrenceDate);
1102
169
    const std::string appointment_app_url =  ocurrenceDate.to_timezone("UTC").format("calendar://startdate=%Y-%m-%dT%H:%M:%S+00:00");
187
    const std::string appointment_app_url =  ocurrenceDate.to_timezone("UTC").format("calendar://startdate=%Y-%m-%dT%H:%M:%S+00:00");
1103
170
    EXPECT_EQ(appointment_app_url, m_live_actions->last_url);
188
    EXPECT_EQ(appointment_app_url, m_live_actions->last_url);
1104
171
189
1105
172
    a.type = Appointment::UBUNTU_ALARM;
190
    a.type = Appointment::UBUNTU_ALARM;
1107
173
    m_actions->phone_open_appointment(a, a.begin);
191
    m_actions->open_appointment(a, a.begin);
1108
174
    EXPECT_EQ(clock_app_url, m_live_actions->last_url);
192
    EXPECT_EQ(clock_app_url, m_live_actions->last_url);
1109
175
}
193
}
1110
176
194
1111
177
TEST_F(TestLiveActionsFixture, PhoneOpenCalendarApp)
195
TEST_F(TestLiveActionsFixture, PhoneOpenCalendarApp)
1112
178
{
196
{
1113
197
    m_live_actions->set_desktop(LiveActions::UNITY8);
1114
198
1115
179
    auto now = DateTime::NowLocal();
199
    auto now = DateTime::NowLocal();
1117
180
    m_actions->phone_open_calendar_app(now);
200
    m_actions->open_calendar_app(now);
1118
181
    const std::string expected =  now.to_timezone("UTC").format("calendar://startdate=%Y-%m-%dT%H:%M:%S+00:00");
201
    const std::string expected =  now.to_timezone("UTC").format("calendar://startdate=%Y-%m-%dT%H:%M:%S+00:00");
1119
182
    EXPECT_EQ(expected, m_live_actions->last_url);
202
    EXPECT_EQ(expected, m_live_actions->last_url);
1120
183
}
203
}
1121
@@ -185,7 +205,9 @@
1122
185
205
1123
186
TEST_F(TestLiveActionsFixture, PhoneOpenSettingsApp)
206
TEST_F(TestLiveActionsFixture, PhoneOpenSettingsApp)
1124
187
{
207
{
1126
188
    m_actions->phone_open_settings_app();
208
    m_live_actions->set_desktop(LiveActions::UNITY8);
1127
209
1128
210
    m_actions->open_settings_app();
1129
189
    const std::string expected = "settings:///system/time-date";
211
    const std::string expected = "settings:///system/time-date";
1130
190
    EXPECT_EQ(expected, m_live_actions->last_url);
212
    EXPECT_EQ(expected, m_live_actions->last_url);
1131
191
}
213
}
1132
192
214
1133
=== modified file 'tests/test-notification.cpp'
1134
--- tests/test-notification.cpp	2016-02-11 04:30:46 +0000
1135
+++ tests/test-notification.cpp	2016-04-28 14:56:46 +0000
1136
@@ -63,7 +63,7 @@
1137
63
    bool expected_notify_called;
63
    bool expected_notify_called;
1138
64
    bool expected_vibrate_called;
64
    bool expected_vibrate_called;
1139
65
  } test_appts[] = {
65
  } test_appts[] = {
1141
66
    { appt, "reminder", "Event", true, true },
66
    { appt, "calendar-app", "Event", true, true },
1142
67
    { ualarm, "alarm-clock", "Alarm", true, true }
67
    { ualarm, "alarm-clock", "Alarm", true, true }
1143
68
  };
68
  };
1144
69
69
1145
70
70
1146
=== modified file 'tests/test-sound.cpp'
1147
--- tests/test-sound.cpp	2016-02-10 20:49:01 +0000
1148
+++ tests/test-sound.cpp	2016-04-28 14:56:46 +0000
1149
@@ -85,7 +85,7 @@
1150
85
85
1151
86
  // confirm that the icon passed to Notify was "alarm-clock"
86
  // confirm that the icon passed to Notify was "alarm-clock"
1152
87
  g_variant_get_child (params, 2, "&s", &str);
87
  g_variant_get_child (params, 2, "&s", &str);
1154
88
  ASSERT_STREQ("reminder", str);
88
  ASSERT_STREQ("calendar-app", str);
1155
89
89
1156
90
  // confirm that the hints passed to Notify included a timeout matching duration_minutes
90
  // confirm that the hints passed to Notify included a timeout matching duration_minutes
1157
91
  int32_t i32;
91
  int32_t i32;
Reviewer	Review Type	Date Requested	Status
PS Jenkins bot (community)	continuous-integration		Needs Fixing on 2016-05-02
Charles Kerr (community)		2016-04-19	Approve on 2016-04-29
Review via email: mp+292270@code.launchpad.net