1
=== modified file 'data/CMakeLists.txt'
2
--- data/CMakeLists.txt	2013-06-13 12:04:14 +0000
3
+++ data/CMakeLists.txt	2014-05-21 07:20:43 +0000
4
@@ -2,7 +2,11 @@
5
2
  ubuntu-platform-api.pc.in ubuntu-platform-api.pc @ONLY
2
  ubuntu-platform-api.pc.in ubuntu-platform-api.pc @ONLY
6
3
)
3
)
7
4
4
8
5
configure_file(
9
6
  ubuntu-platform-hardware-api.pc.in ubuntu-platform-hardware-api.pc @ONLY
10
7
)
11
8
12
5
install(
9
install(
14
6
  FILES ${CMAKE_CURRENT_BINARY_DIR}/ubuntu-platform-api.pc
10
  FILES ${CMAKE_CURRENT_BINARY_DIR}/ubuntu-platform-api.pc ${CMAKE_CURRENT_BINARY_DIR}/ubuntu-platform-hardware-api.pc
15
7
  DESTINATION lib/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig
11
  DESTINATION lib/${CMAKE_LIBRARY_ARCHITECTURE}/pkgconfig
16
8
)
17
9
\ No newline at end of file
12
\ No newline at end of file
18
13
)
19
10
14
20
=== added file 'data/ubuntu-platform-hardware-api.pc.in'
21
--- data/ubuntu-platform-hardware-api.pc.in	1970-01-01 00:00:00 +0000
22
+++ data/ubuntu-platform-hardware-api.pc.in	2014-05-21 07:20:43 +0000
23
@@ -0,0 +1,10 @@
24
1
prefix=@CMAKE_INSTALL_PREFIX@
25
2
exec_prefix=${prefix}
26
3
libdir=${prefix}/@LIB_INSTALL_DIR@
27
4
includedir=${exec_prefix}/include
28
5
 
29
6
Name: ubuntu_platform_hardware_api
30
7
Description: Ubuntu's platform hardware abstraction layer.
31
8
Version: @UBUNTU_PLATFORM_API_VERSION_MAJOR@.@UBUNTU_PLATFORM_API_VERSION_MINOR@.@UBUNTU_PLATFORM_API_VERSION_PATCH@
32
9
Libs: -L${libdir} -lubuntu_platform_hardware_api
33
10
Cflags: -I${includedir}/ubuntu
34
0
11
35
=== modified file 'debian/control'
36
--- debian/control	2014-05-07 07:39:57 +0000
37
+++ debian/control	2014-05-21 07:20:43 +0000
38
@@ -2,7 +2,8 @@
39
2
Priority: optional
2
Priority: optional
40
3
Section: devel
3
Section: devel
41
4
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
4
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
43
5
Build-Depends: cmake,
5
Build-Depends: android-headers,
44
6
               cmake,
45
6
               debhelper (>= 9),
7
               debhelper (>= 9),
46
7
               doxygen,
8
               doxygen,
47
8
               graphviz,
9
               graphviz,
48
9
10
49
=== modified file 'debian/libplatform-api1-hybris-tests.install'
50
--- debian/libplatform-api1-hybris-tests.install	2013-08-17 05:22:31 +0000
51
+++ debian/libplatform-api1-hybris-tests.install	2014-05-21 07:20:43 +0000
52
@@ -3,4 +3,5 @@
53
3
usr/bin/test_android_ubuntu_app_api
3
usr/bin/test_android_ubuntu_app_api
54
4
usr/bin/test_android_ubuntu_app_api_multiple_surfaces
4
usr/bin/test_android_ubuntu_app_api_multiple_surfaces
55
5
usr/bin/test_android_ubuntu_session_api
5
usr/bin/test_android_ubuntu_session_api
56
6
usr/bin/test_ubuntu_app_api_location_service
57
7
\ No newline at end of file
6
\ No newline at end of file
58
7
usr/bin/test_ubuntu_app_api_location_service
59
8
usr/bin/test_hardware_alarms_api
60
8
9
61
=== modified file 'debian/libplatform-hardware-api1-dev.install'
62
--- debian/libplatform-hardware-api1-dev.install	2013-07-08 10:39:36 +0000
63
+++ debian/libplatform-hardware-api1-dev.install	2014-05-21 07:20:43 +0000
64
@@ -1,2 +1,2 @@
65
1
usr/lib/*/libubuntu_platform_hardware_api.so
1
usr/lib/*/libubuntu_platform_hardware_api.so
67
2
2
usr/lib/*/pkgconfig/ubuntu-platform-hardware-api.pc
68
3
3
69
=== modified file 'debian/libubuntu-platform-hardware-api1.symbols'
70
--- debian/libubuntu-platform-hardware-api1.symbols	2013-07-17 14:29:04 +0000
71
+++ debian/libubuntu-platform-hardware-api1.symbols	2014-05-21 07:20:43 +0000
72
@@ -1,4 +1,11 @@
73
1
libubuntu_platform_hardware_api.so.1 libubuntu-platform-hardware-api1 #MINVER#
1
libubuntu_platform_hardware_api.so.1 libubuntu-platform-hardware-api1 #MINVER#
74
2
 u_hardware_alarm_create@Base 0replaceme
75
3
 u_hardware_alarm_get_elapsed_real_time@Base 0replaceme
76
4
 u_hardware_alarm_ref@Base 0replaceme
77
5
 u_hardware_alarm_set_relative_to_with_behavior@Base 0replaceme
78
6
 u_hardware_alarm_set_timezone@Base 0replaceme
79
7
 u_hardware_alarm_unref@Base 0replaceme
80
8
 u_hardware_alarm_wait_for_next_alarm@Base 0replaceme
81
2
 u_hardware_gps_delete@Base 0.18.2+13.10.20130709
9
 u_hardware_gps_delete@Base 0.18.2+13.10.20130709
82
3
 u_hardware_gps_delete_aiding_data@Base 0.18.2+13.10.20130709
10
 u_hardware_gps_delete_aiding_data@Base 0.18.2+13.10.20130709
83
4
 u_hardware_gps_inject_location@Base 0.18.2+13.10.20130709
11
 u_hardware_gps_inject_location@Base 0.18.2+13.10.20130709
84
5
12
85
=== modified file 'include/ubuntu/hardware/CMakeLists.txt'
86
--- include/ubuntu/hardware/CMakeLists.txt	2013-07-18 09:08:17 +0000
87
+++ include/ubuntu/hardware/CMakeLists.txt	2014-05-21 07:20:43 +0000
88
@@ -1,9 +1,10 @@
89
1
set(
1
set(
90
2
  UBUNTU_HARDWARE_HEADERS
2
  UBUNTU_HARDWARE_HEADERS
91
3
  alarm.h
92
3
  gps.h
4
  gps.h
93
4
)
5
)
94
5
6
95
6
install(
7
install(
96
7
  FILES ${UBUNTU_HARDWARE_HEADERS}
8
  FILES ${UBUNTU_HARDWARE_HEADERS}
97
8
  DESTINATION include/ubuntu/hardware
9
  DESTINATION include/ubuntu/hardware
98
9
)
99
10
\ No newline at end of file
10
\ No newline at end of file
100
11
)
101
11
12
102
=== added file 'include/ubuntu/hardware/alarm.h'
103
--- include/ubuntu/hardware/alarm.h	1970-01-01 00:00:00 +0000
104
+++ include/ubuntu/hardware/alarm.h	2014-05-21 07:20:43 +0000
105
@@ -0,0 +1,104 @@
106
1
/*
107
2
 * Copyright © 2014 Canonical Ltd.
108
3
 *
109
4
 * This program is free software: you can redistribute it and/or modify
110
5
 * it under the terms of the GNU Lesser General Public License version 3 as
111
6
 * published by the Free Software Foundation.
112
7
 *
113
8
 * This program is distributed in the hope that it will be useful,
114
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
115
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
116
11
 * GNU Lesser General Public License for more details.
117
12
 *
118
13
 * You should have received a copy of the GNU Lesser General Public License
119
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
120
15
 *
121
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
122
17
 */
123
18
#ifndef UBUNTU_HARDWARE_ALARM_H_
124
19
#define UBUNTU_HARDWARE_ALARM_H_
125
20
126
21
#include <ubuntu/status.h>
127
22
#include <ubuntu/visibility.h>
128
23
129
24
#ifdef __cplusplus
130
25
extern "C" {
131
26
#endif
132
27
133
28
/** The time reference that alarms are setup to. */
134
29
typedef enum
135
30
{
136
31
    U_HARDWARE_ALARM_TIME_REFERENCE_BOOT, /**< Relative to the device's boot time, including sleep. */
137
32
    U_HARDWARE_ALARM_TIME_REFERENCE_RTC /**< Wall clock time in UTC. */
138
33
} UbuntuHardwareAlarmTimeReference;
139
34
140
35
typedef UbuntuHardwareAlarmTimeReference UHardwareAlarmTimeReference;
141
36
142
37
/** Describes if an alarm is able to wakup the device from sleep. */
143
38
typedef enum
144
39
{
145
40
    /** Alarm will wakeup the device from sleep. */
146
41
    U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE,
147
42
    /** Alarm will not wakeup the device and will be delivered on the next wakeup of the device */
148
43
    U_HARDWARE_ALARM_SLEEP_BEHAVIOR_KEEP_DEVICE_ASLEEP
149
44
} UbuntuHardwareAlarmSleepBehavior;
150
45
151
46
typedef UbuntuHardwareAlarmSleepBehavior UHardwareAlarmSleepBehavior;
152
47
153
48
/** Bundles the time reference and sleep/wakeup behavior when waiting for an alarm to happen. */
154
49
typedef struct
155
50
{
156
51
  UHardwareAlarmTimeReference reference;
157
52
  UHardwareAlarmSleepBehavior sleep_behavior;
158
53
} UbuntuHardwareAlarmWaitResult;
159
54
160
55
typedef UbuntuHardwareAlarmWaitResult UHardwareAlarmWaitResult;
161
56
162
57
/** Opaque type modelling access to the kernel/hw-level alarm capabilities. */
163
58
typedef struct UbuntuHardwareAlarm* UHardwareAlarm;
164
59
165
60
/** Creates an instance and/or increments its refcount. */
166
61
UBUNTU_DLL_PUBLIC UHardwareAlarm
167
62
u_hardware_alarm_create();
168
63
169
64
/** Increments the instance's ref count. */
170
65
UBUNTU_DLL_PUBLIC void
171
66
u_hardware_alarm_ref(
172
67
    UHardwareAlarm alarm);
173
68
174
69
/** Decrements the instance's ref count. */
175
70
UBUNTU_DLL_PUBLIC void
176
71
u_hardware_alarm_unref(
177
72
    UHardwareAlarm alarm);
178
73
179
74
/** Query the time that elapsed since boot, including deep sleeps. */
180
75
UBUNTU_DLL_PUBLIC UStatus
181
76
u_hardware_alarm_get_elapsed_real_time(
182
77
    UHardwareAlarm alarm,
183
78
    struct timespec *tz);
184
79
185
80
/** Reports a timezone change to kernel and HW. */
186
81
UBUNTU_DLL_PUBLIC UStatus
187
82
u_hardware_alarm_set_timezone(
188
83
    UHardwareAlarm alarm,
189
84
    const struct timezone *tz);
190
85
191
86
/** Sets and arms a timer. */
192
87
UBUNTU_DLL_PUBLIC UStatus
193
88
u_hardware_alarm_set_relative_to_with_behavior(
194
89
    UHardwareAlarm alarm,
195
90
    UHardwareAlarmTimeReference time_reference,
196
91
    UHardwareAlarmSleepBehavior behavior,
197
92
    const struct timespec *ts);
198
93
199
94
/** Blocks until the next alarm occurs. */
200
95
UBUNTU_DLL_PUBLIC UStatus
201
96
u_hardware_alarm_wait_for_next_alarm(
202
97
    UHardwareAlarm alarm,
203
98
    UHardwareAlarmWaitResult *result);
204
99
205
100
#ifdef __cplusplus
206
101
}
207
102
#endif
208
103
209
104
#endif
210
0
105
211
=== modified file 'src/ubuntu/CMakeLists.txt'
212
--- src/ubuntu/CMakeLists.txt	2013-12-02 17:03:45 +0000
213
+++ src/ubuntu/CMakeLists.txt	2014-05-21 07:20:43 +0000
214
@@ -3,6 +3,7 @@
215
3
)
3
)
216
4
4
217
5
add_subdirectory(application)
5
add_subdirectory(application)
218
6
add_subdirectory(hardware)
219
6
add_subdirectory(testbackend)
7
add_subdirectory(testbackend)
220
7
8
221
8
set(
9
set(
222
@@ -12,6 +13,12 @@
223
12
  ubuntu_application_url_dispatcher
13
  ubuntu_application_url_dispatcher
224
13
)
14
)
225
14
15
226
16
set(
227
17
  UBUNTU_HARDWARE_API_LINK_LIBRARIES
228
18
  
229
19
  ubuntu_hardware_alarm
230
20
)
231
21
232
15
if(ENABLE_HYBRIS_IMPLEMENTATION)
22
if(ENABLE_HYBRIS_IMPLEMENTATION)
233
16
  add_subdirectory(hybris/)
23
  add_subdirectory(hybris/)
234
17
endif()
24
endif()
235
18
25
236
=== added directory 'src/ubuntu/hardware'
237
=== added file 'src/ubuntu/hardware/CMakeLists.txt'
238
--- src/ubuntu/hardware/CMakeLists.txt	1970-01-01 00:00:00 +0000
239
+++ src/ubuntu/hardware/CMakeLists.txt	2014-05-21 07:20:43 +0000
240
@@ -0,0 +1,9 @@
241
1
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --std=c++11 -fPIC")
242
2
243
3
include_directories(/usr/include/android)
244
4
245
5
add_library(
246
6
  ubuntu_hardware_alarm
247
7
248
8
  alarm.cpp
249
9
)
250
0
\ No newline at end of file
10
\ No newline at end of file
251
1
11
252
=== added file 'src/ubuntu/hardware/alarm.cpp'
253
--- src/ubuntu/hardware/alarm.cpp	1970-01-01 00:00:00 +0000
254
+++ src/ubuntu/hardware/alarm.cpp	2014-05-21 07:20:43 +0000
255
@@ -0,0 +1,304 @@
256
1
/*
257
2
 * Copyright © 2013 Canonical Ltd.
258
3
 *
259
4
 * This program is free software: you can redistribute it and/or modify
260
5
 * it under the terms of the GNU Lesser General Public License version 3 as
261
6
 * published by the Free Software Foundation.
262
7
 *
263
8
 * This program is distributed in the hope that it will be useful,
264
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
265
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
266
11
 * GNU Lesser General Public License for more details.
267
12
 *
268
13
 * You should have received a copy of the GNU Lesser General Public License
269
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
270
15
 *
271
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
272
17
 */
273
18
274
19
#include <android/linux/android_alarm.h>
275
20
276
21
#include <ubuntu/hardware/alarm.h>
277
22
278
23
#include <cstdio>
279
24
#include <cstring>
280
25
281
26
#include <stdexcept>
282
27
#include <string>
283
28
284
29
#include <unistd.h>
285
30
286
31
#include <errno.h>
287
32
#include <fcntl.h>
288
33
289
34
#include <sys/ioctl.h>
290
35
#include <sys/time.h>
291
36
#include <sys/types.h>
292
37
293
38
namespace
294
39
{
295
40
struct HardwareAlarm
296
41
{
297
42
    HardwareAlarm() = default;
298
43
    virtual ~HardwareAlarm() = default;
299
44
300
45
    // Blocks the calling thread until an alarm fires or
301
46
    // an error occurs. Returns an int with bool semantics.
302
47
    virtual int wait_for() = 0;
303
48
304
49
    // Arms the alarm with the given properties.
305
50
    // Returns true if the alarm has been armed successfully, false otherwise.
306
51
    virtual bool set(
307
52
        UHardwareAlarmTimeReference time_reference,
308
53
        UHardwareAlarmSleepBehavior behavior,
309
54
        const struct timespec *ts) = 0;
310
55
311
56
    // Queries the time since last boot including deep sleep periods.
312
57
    virtual bool get_elapsed_realtime(struct timespec* ts) = 0;
313
58
};
314
59
315
60
// An implementation of HardwareAlarm based on Android's /dev/alarm.
316
61
struct DevAlarmHardwareAlarm : public HardwareAlarm
317
62
{
318
63
    int fd; // file descriptor referring to /dev/alarm
319
64
320
65
    DevAlarmHardwareAlarm() : fd(open("/dev/alarm", O_RDWR))
321
66
    {
322
67
        if (fd == -1)
323
68
        {
324
69
            auto error = errno;
325
70
326
71
            std::string what
327
72
            {
328
73
                "Could not open /dev/alarm: "
329
74
            };
330
75
            throw std::runtime_error
331
76
            {
332
77
                (what + strerror(error)).c_str()
333
78
            };
334
79
        }
335
80
    }
336
81
337
82
    ~DevAlarmHardwareAlarm()
338
83
    {
339
84
        // No need to check if fd is valid here.
340
85
        // Ctor would have thrown if fd was invalid.
341
86
        ::close(fd);
342
87
    }
343
88
344
89
    int wait_for()
345
90
    {
346
91
        int result{-1};
347
92
348
93
        do
349
94
        {
350
95
            result = ::ioctl(fd, ANDROID_ALARM_WAIT);
351
96
        } while (result < 0 && errno == EINTR);
352
97
353
98
        if (result < 0)
354
99
            fprintf(stderr, "Waiting for hw alarm failed with: %s\n", strerror(errno));
355
100
356
101
        return result;
357
102
    }
358
103
359
104
    bool set(UHardwareAlarmTimeReference time_reference,
360
105
             UHardwareAlarmSleepBehavior behavior,
361
106
             const struct timespec *ts)
362
107
    {
363
108
        if (not ts)
364
109
            return false;
365
110
366
111
        int type = 0;
367
112
368
113
        if (time_reference == U_HARDWARE_ALARM_TIME_REFERENCE_BOOT)
369
114
            switch(behavior)
370
115
            {
371
116
                case U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE:
372
117
                    type = ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK;
373
118
                    break;
374
119
                case U_HARDWARE_ALARM_SLEEP_BEHAVIOR_KEEP_DEVICE_ASLEEP:
375
120
                    type = ANDROID_ALARM_ELAPSED_REALTIME_MASK;
376
121
                    break;
377
122
            }
378
123
        else if (time_reference == U_HARDWARE_ALARM_TIME_REFERENCE_RTC)
379
124
            switch(behavior)
380
125
            {
381
126
                case U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE:
382
127
                    type = ANDROID_ALARM_RTC_WAKEUP_MASK;
383
128
                    break;
384
129
                case U_HARDWARE_ALARM_SLEEP_BEHAVIOR_KEEP_DEVICE_ASLEEP:
385
130
                    type = ANDROID_ALARM_RTC_MASK;
386
131
                    break;
387
132
            }
388
133
389
134
        int result = ::ioctl(fd, ANDROID_ALARM_SET(type), ts);
390
135
391
136
        if (result < 0)
392
137
            fprintf(stderr, "Unable to set alarm: %s\n", strerror(errno));
393
138
394
139
        return not (result < 0);
395
140
    }
396
141
397
142
    bool get_elapsed_realtime(struct timespec* ts)
398
143
    {
399
144
        if (not ts)
400
145
            return false;
401
146
402
147
        int result = ::ioctl(
403
148
            fd,
404
149
            ANDROID_ALARM_GET_TIME(ANDROID_ALARM_ELAPSED_REALTIME),
405
150
            ts);
406
151
407
152
        return result == 0;
408
153
    }
409
154
};
410
155
}
411
156
412
157
class UbuntuHardwareAlarm
413
158
{
414
159
  public:
415
160
    static UbuntuHardwareAlarm& instance()
416
161
    {
417
162
        static UbuntuHardwareAlarm ha;
418
163
        return ha;
419
164
    }
420
165
421
166
    int wait_for()
422
167
    {
423
168
        return impl->wait_for();
424
169
    }
425
170
426
171
    bool set(UHardwareAlarmTimeReference time_reference,
427
172
             UHardwareAlarmSleepBehavior behavior,
428
173
             const struct timespec *ts)
429
174
    {
430
175
        return impl->set(time_reference, behavior, ts);
431
176
    }
432
177
433
178
    bool get_elapsed_realtime(struct timespec* ts)
434
179
    {
435
180
        return impl->get_elapsed_realtime(ts);
436
181
    }
437
182
438
183
    bool is_valid() const
439
184
    {
440
185
        return impl != nullptr;
441
186
    }
442
187
443
188
  private:
444
189
    UbuntuHardwareAlarm()
445
190
    {
446
191
        try
447
192
        {
448
193
            impl = new DevAlarmHardwareAlarm();
449
194
        } catch(const std::runtime_error& e)
450
195
        {
451
196
            fprintf(
452
197
                stderr, "%s: Error creating /dev/alarm-based implementation with: %s\n",
453
198
                __PRETTY_FUNCTION__,
454
199
                e.what());
455
200
456
201
            // TODO: Should we fallback to a timer-fd implementation here? I'm not
457
202
            // convinced that we should do so as a timer-fd wouldn't wakeup the device
458
203
            // from any sort of sleep mode.
459
204
        }
460
205
    }
461
206
462
207
    ~UbuntuHardwareAlarm()
463
208
    {
464
209
        delete impl;
465
210
    }
466
211
467
212
    HardwareAlarm* impl
468
213
    {
469
214
        nullptr
470
215
    };
471
216
};
472
217
473
218
UHardwareAlarm
474
219
u_hardware_alarm_create()
475
220
{
476
221
    auto result = &UbuntuHardwareAlarm::instance();
477
222
478
223
    if (result)
479
224
        if (result->is_valid())
480
225
            return result;
481
226
482
227
    return NULL;
483
228
}
484
229
485
230
void
486
231
u_hardware_alarm_ref(
487
232
    UHardwareAlarm alarm)
488
233
{
489
234
    // Considering a singleton pattern here, just voiding the argument.
490
235
    (void) alarm;
491
236
}
492
237
493
238
void
494
239
u_hardware_alarm_unref(
495
240
    UHardwareAlarm alarm)
496
241
{
497
242
    // Considering a singleton pattern here, just voiding the argument.
498
243
    (void) alarm;
499
244
}
500
245
501
246
UStatus
502
247
u_hardware_alarm_get_elapsed_real_time(
503
248
    UHardwareAlarm alarm,
504
249
    struct timespec* ts)
505
250
{
506
251
    return alarm->get_elapsed_realtime(ts) ? U_STATUS_SUCCESS : U_STATUS_ERROR;
507
252
}
508
253
509
254
UStatus
510
255
u_hardware_alarm_set_timezone(
511
256
    UHardwareAlarm alarm,
512
257
    const struct timezone *tz)
513
258
{
514
259
    int result = settimeofday(NULL, tz);
515
260
516
261
    if (result < 0)
517
262
        return U_STATUS_ERROR;
518
263
519
264
    return U_STATUS_SUCCESS;
520
265
}
521
266
522
267
UStatus
523
268
u_hardware_alarm_set_relative_to_with_behavior(
524
269
    UHardwareAlarm alarm,
525
270
    UHardwareAlarmTimeReference time_reference,
526
271
    UHardwareAlarmSleepBehavior behavior,
527
272
    const struct timespec *ts)
528
273
{
529
274
    return alarm->set(time_reference, behavior, ts) ?
530
275
            U_STATUS_SUCCESS :
531
276
            U_STATUS_ERROR;
532
277
533
278
}
534
279
535
280
UStatus
536
281
u_hardware_alarm_wait_for_next_alarm(
537
282
    UHardwareAlarm alarm,
538
283
    UHardwareAlarmWaitResult *result)
539
284
{
540
285
    int rc = alarm->wait_for();
541
286
542
287
    if (rc < 0)
543
288
        return U_STATUS_ERROR;
544
289
545
290
    if ((rc & ANDROID_ALARM_RTC_MASK) ||
546
291
        (rc & ANDROID_ALARM_RTC_WAKEUP_MASK))
547
292
        result->reference = U_HARDWARE_ALARM_TIME_REFERENCE_BOOT;
548
293
    else if ((rc & ANDROID_ALARM_ELAPSED_REALTIME_MASK) ||
549
294
             (rc & ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK))
550
295
        result->reference = U_HARDWARE_ALARM_TIME_REFERENCE_RTC;
551
296
552
297
    if ((rc & ANDROID_ALARM_RTC_WAKEUP_MASK) ||
553
298
        (rc & ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP_MASK))
554
299
        result->sleep_behavior = U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE;
555
300
    else
556
301
        result->sleep_behavior = U_HARDWARE_ALARM_SLEEP_BEHAVIOR_KEEP_DEVICE_ASLEEP;
557
302
558
303
    return U_STATUS_SUCCESS;
559
304
}
560
0
305
561
=== modified file 'src/ubuntu/hybris/CMakeLists.txt'
562
--- src/ubuntu/hybris/CMakeLists.txt	2014-02-12 07:35:37 +0000
563
+++ src/ubuntu/hybris/CMakeLists.txt	2014-05-21 07:20:43 +0000
564
@@ -20,13 +20,18 @@
565
20
  ubuntu_application_api
20
  ubuntu_application_api
566
21
21
567
22
  "-Wl,--whole-archive"
22
  "-Wl,--whole-archive"
569
23
  ${UBUNTU_APPLICATION_API_LINK_LIBRARIES}  
23
  ${UBUNTU_APPLICATION_API_LINK_LIBRARIES}
570
24
  "-Wl,--no-whole-archive"
24
  "-Wl,--no-whole-archive"
571
25
  ${Hybris}
25
  ${Hybris}
572
26
)
26
)
573
27
27
574
28
target_link_libraries(
28
target_link_libraries(
575
29
  ubuntu_platform_hardware_api
29
  ubuntu_platform_hardware_api
576
30
577
31
  "-Wl,--whole-archive"
578
32
  ${UBUNTU_HARDWARE_API_LINK_LIBRARIES}
579
33
  "-Wl,--no-whole-archive"
580
34
581
30
  dl
35
  dl
582
31
  ${Hybris}
36
  ${Hybris}
583
32
)
37
)
584
@@ -46,7 +51,7 @@
585
46
)
51
)
586
47
52
587
48
install(
53
install(
589
49
  TARGETS ubuntu_application_api  
54
  TARGETS ubuntu_application_api
590
50
  ${INSTALL_TARGETS_DEFAULT_ARGS}
55
  ${INSTALL_TARGETS_DEFAULT_ARGS}
591
51
)
56
)
592
52
57
593
53
58
594
=== modified file 'src/ubuntu/hybris/tests/CMakeLists.txt'
595
--- src/ubuntu/hybris/tests/CMakeLists.txt	2013-08-17 05:22:31 +0000
596
+++ src/ubuntu/hybris/tests/CMakeLists.txt	2014-05-21 07:20:43 +0000
597
@@ -18,6 +18,9 @@
598
18
add_executable(test_ubuntu_app_api_location_service test_location_api.cpp)
18
add_executable(test_ubuntu_app_api_location_service test_location_api.cpp)
599
19
target_link_libraries(test_ubuntu_app_api_location_service ubuntu_application_api)
19
target_link_libraries(test_ubuntu_app_api_location_service ubuntu_application_api)
600
20
20
601
21
add_executable(test_hardware_alarms_api test_alarms_api.cpp)
602
22
target_link_libraries(test_hardware_alarms_api ubuntu_platform_hardware_api)
603
23
604
21
install(TARGETS
24
install(TARGETS
605
22
	test_android_ubuntu_app_api
25
	test_android_ubuntu_app_api
606
23
	test_android_gps_api
26
	test_android_gps_api
607
@@ -25,5 +28,6 @@
608
25
	test_android_sensors_api
28
	test_android_sensors_api
609
26
	test_android_ubuntu_session_api
29
	test_android_ubuntu_session_api
610
27
	test_ubuntu_app_api_location_service
30
	test_ubuntu_app_api_location_service
611
31
	test_hardware_alarms_api
612
28
	DESTINATION bin
32
	DESTINATION bin
613
29
)
33
)
614
30
34
615
=== added file 'src/ubuntu/hybris/tests/test_alarms_api.cpp'
616
--- src/ubuntu/hybris/tests/test_alarms_api.cpp	1970-01-01 00:00:00 +0000
617
+++ src/ubuntu/hybris/tests/test_alarms_api.cpp	2014-05-21 07:20:43 +0000
618
@@ -0,0 +1,74 @@
619
1
/*
620
2
 * Copyright © 2013 Canonical Ltd.
621
3
 *
622
4
 * This program is free software: you can redistribute it and/or modify
623
5
 * it under the terms of the GNU General Public License version 3 as
624
6
 * published by the Free Software Foundation.
625
7
 *
626
8
 * This program is distributed in the hope that it will be useful,
627
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
628
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
629
11
 * GNU General Public License for more details.
630
12
 *
631
13
 * You should have received a copy of the GNU General Public License
632
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
633
15
 *
634
16
 * Authored by: Thomas Voß <thomas.voss@canonicalcom>
635
17
 */
636
18
637
19
#include <ubuntu/hardware/alarm.h>
638
20
639
21
#include <cstdio>
640
22
#include <cstdlib>
641
23
#include <ctime>
642
24
643
25
int main(int argc, char** argv)
644
26
{
645
27
    UHardwareAlarm alarm = u_hardware_alarm_create();
646
28
647
29
    if (!alarm)
648
30
    {
649
31
        printf("Error creating handle to hardware alarms.\n");
650
32
        return 1;
651
33
    }
652
34
653
35
    // Alarm in two seconds.
654
36
    timespec ts { 0, 0 };
655
37
    clock_gettime(CLOCK_REALTIME, &ts);
656
38
657
39
    int timeout_in_seconds = 5;
658
40
659
41
    // Let's see if a timeout has been specified on the command line
660
42
    if (argc > 1)
661
43
    {
662
44
        timeout_in_seconds = atoi(argv[1]);
663
45
    }
664
46
665
47
    // Alarm in two seconds.
666
48
    ts.tv_sec += timeout_in_seconds;
667
49
668
50
    UStatus rc = u_hardware_alarm_set_relative_to_with_behavior(
669
51
        alarm,
670
52
        U_HARDWARE_ALARM_TIME_REFERENCE_RTC,
671
53
        U_HARDWARE_ALARM_SLEEP_BEHAVIOR_WAKEUP_DEVICE,
672
54
        &ts);
673
55
674
56
    if (rc != U_STATUS_SUCCESS)
675
57
    {
676
58
        printf("Problem setting hardware alarm.\n");
677
59
        return 1;
678
60
    }
679
61
680
62
    UHardwareAlarmWaitResult wait_result;
681
63
    rc = u_hardware_alarm_wait_for_next_alarm(alarm, &wait_result);
682
64
683
65
    if (rc != U_STATUS_SUCCESS)
684
66
    {
685
67
        printf("Problem waiting for hardware alarm to go off.\n");
686
68
        return 1;
687
69
    }
688
70
689
71
    printf("Successfully created and waited for a hw alarm.\n");
690
72
691
73
    return 0;
692
74
}
693
0
75
694
=== modified file 'src/ubuntu/hybris/ubuntu_platform_hardware_api.cpp'
695
--- src/ubuntu/hybris/ubuntu_platform_hardware_api.cpp	2013-06-13 08:37:52 +0000
696
+++ src/ubuntu/hybris/ubuntu_platform_hardware_api.cpp	2014-05-21 07:20:43 +0000
697
@@ -18,6 +18,7 @@
698
18
 */
18
 */
699
19
19
700
20
// C APIs
20
// C APIs
701
21
#include <ubuntu/hardware/alarm.h>
702
21
#include <ubuntu/hardware/gps.h>
22
#include <ubuntu/hardware/gps.h>
703
22
23
704
23
#include "bridge.h"
24
#include "bridge.h"
Reviewer	Review Type	Date Requested	Status
Ricardo Salveti (community)		2014-03-12	Approve on 2014-05-22
PS Jenkins bot	continuous-integration		Approve on 2014-05-21
Charles Kerr (community)			Approve on 2014-04-23
Review via email: mp+210592@code.launchpad.net