← Back to branch summary

~ubuntu-branches/ubuntu/saucy/ubuntu-ui-toolkit/saucy

« back to all changes in this revision

Viewing changes to modules/Ubuntu/Components/plugin/adapters/alarmsadapter_organizer.cpp

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release, Timo Jyrinki, Christian Dywan, Zsombor Egri, Leo Arias, Nick Dedekind, Alberto Mardegan, Dennis O'Flaherty, tpeeters, Ubuntu daily release
  • Date: 2013-09-25 07:08:56 UTC
  • mfrom: (1.1.56)
  • Revision ID: package-import@ubuntu.com-20130925070856-2xfkzyjou81vb7m9
Tags: 0.1.46+13.10.20130925.1-0ubuntu1
https://launchpad.net/bugs/1229541
https://launchpad.net/bugs/1229541
https://launchpad.net/bugs/1226516
https://launchpad.net/bugs/1227355
https://launchpad.net/bugs/1226104
https://launchpad.net/bugs/1221707
[ Timo Jyrinki ]
* Temporarily disable the jokes example in order to not have
  qtmultimedia dependency from examples that is not used otherwise.
  This lessens the dependency chains of packages. It can be added back
  after Ubuntu 13.10.
* Fix regression in qmlscene usage (LP: #1229541). (LP: #1229541)

[ Christian Dywan ]
* Set QCoreApplication::applicationName based on MainView. (LP:
  #1197056, #1197051, #1224126)
* Include subfolders of Components in api check.

[ Zsombor Egri ]
* Organizer EDS (Evolution Data Server) integration.
* StateSaver attached component.
* Fix alarm status reporting, updating documentation on asynchronous
  behavior of save and cancel operations. Alarm status notification
  reports the operation the status refers to. (LP: #1226516)
* Dialer + DialerHand components required for TimePicker. .

[ Leo Arias ]
* Added UbuntuUIToolkitAppTestCase as a base test case for the
  autopilot tests. (LP: #1227355)
* Added the autopilot emulator for toggles.

[ Nick Dedekind ]
* Added clipping to tab bar. (LP: #1226104)

[ Alberto Mardegan ]
* Support re-attaching to a different QQuickView Make the plugin
  correctly handle the case when the QQuickView is destroyed and a new
  one is created: this is done by avoiding using static variables, and
  instead binding the data to the QQmlEngine, QQmlContext or QWindow
  as appropriate. . (LP: #1221707)

[ Dennis O'Flaherty ]
* Reword the description for easier reading.

[ tpeeters ]
* Fix warnings when running gallery-app autopilot tests. (LP:
  #1223329, #1223326)
* Smarter automatic updating of Panel's opened property. Panel.open()
  and Panel.close() should be used to open/close a Panel, or when
  using a toolbar with ToolbarItems from a Page, set Page.tools.opened
  to open/close the toolbar. No API or behavior changes since the
  panel-open-close branch. Toolbar behavior changes will be done in a
  following MR.

[ Ubuntu daily release ]
* Automatic snapshot from revision 765

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/Ubuntu/Components/plugin/adapters/alarmsadapter_organizer.cpp
19
19
#include "ucalarm.h"
20
20
#include "ucalarm_p.h"
21
21
#include "alarmmanager_p.h"
22
 
#include "alarmmanager_p_p.h"
23
22
#include "alarmrequest_p.h"
24
 
#include "alarmrequest_p_p.h"
25
 
 
26
 
#include <qorganizer.h>
27
 
#include <qorganizermanager.h>
28
 
 
29
 
// FIXME: remove once we have the Organizer backend ready
 
23
#include "alarmsadapter_p.h"
 
24
 
30
25
#include <QtCore/QFile>
31
26
#include <QtCore/QDir>
32
27
#include <QtCore/QStandardPaths>
33
28
 
34
 
#define ALARM_DATABASE      "%1/alarms.database"
 
29
#define ALARM_DATABASE          "%1/alarms.database"
 
30
/*
 
31
 * The main alarm manager engine used from Saucy onwards is EDS (Evolution Data
 
32
 * Server) based. Any previous release uses the generic "memory" manager engine
 
33
 * which does not store alarm data, does not schedule organizer events and does
 
34
 * not give visual or audible reminding.
 
35
 */
 
36
#define ALARM_MANAGER           "eds"
 
37
#define ALARM_MANAGER_FALLBACK  "memory"
 
38
#define ALARM_COLLECTION        "Alarms"
35
39
 
36
40
QTORGANIZER_USE_NAMESPACE
37
41
 
38
42
/*-----------------------------------------------------------------------------
39
 
 * Adaptation layer for Alarms. QOrganizer implementation may not require this,
40
 
 * however in case we decide to go with some other approach, this layer is welcome.
41
 
 */
42
 
 
43
 
class AlarmRequestAdapter : public AlarmRequestPrivate
44
 
{
45
 
public:
46
 
    AlarmRequestAdapter(AlarmRequest *parent, bool autoDelete);
47
 
 
48
 
    // adaptation methods
49
 
    bool save(AlarmData &alarm);
50
 
    bool remove(AlarmData &alarm);
51
 
    bool fetch();
52
 
 
53
 
    bool start(QOrganizerAbstractRequest *operation);
54
 
 
55
 
    void _q_updateProgress();
56
 
 
57
 
private:
58
 
    QOrganizerAbstractRequest *m_request;
59
 
 
60
 
    void completeUpdate();
61
 
    void completeRemove();
62
 
    void completeFetch();
63
 
};
64
 
 
65
 
class AlarmsAdapter : public AlarmManagerPrivate
66
 
{
67
 
public:
68
 
    enum Error {
69
 
        DifferentTypeExpected = UCAlarm::AdaptationError + 1,
70
 
        FetchedEventEmpty,  // 102
71
 
        UnhandledEventType, // 103
72
 
        UnhandledRequest,   // 104
73
 
        OrganizerError      // 105 onwards
74
 
    };
75
 
 
76
 
    AlarmsAdapter(AlarmManager *qq);
77
 
    virtual ~AlarmsAdapter();
78
 
 
79
 
    static AlarmsAdapter* get(AlarmManager *instance = 0) {
80
 
        return static_cast<AlarmsAdapter*>(AlarmManagerPrivate::get(instance));
81
 
    }
82
 
 
83
 
    QOrganizerManager manager;
84
 
    QOrganizerCollection collection;
85
 
 
86
 
    virtual bool fetchAlarms();
87
 
    void completeFetchAlarms(const QList<QOrganizerItem> &alarmList);
88
 
 
89
 
    // FIXME: remove once we have the Organizer backend ready
90
 
    void loadAlarms();
91
 
    void saveAlarms();
92
 
 
93
 
    void rawAlarm2Organizer(const AlarmData &alarm, QOrganizerTodo &event);
94
 
    void updateOrganizerFromRaw(const AlarmData &alarm, QOrganizerTodo &event);
95
 
    int organizer2RawAlarm(const QOrganizerItem &item, AlarmData &alarm);
96
 
    QSet<Qt::DayOfWeek> daysToSet(const AlarmData &alarm) const;
97
 
    void daysFromSet(AlarmData &alarm, QSet<Qt::DayOfWeek> set);
98
 
};
99
 
 
100
 
/*-----------------------------------------------------------------------------
101
 
 * Adaptation layer for Alarms. QOrganizer implementation may not require this,
102
 
 * however in case we decide to go with some other approach, this layer is welcome.
 
43
 * Adaptation layer for Alarms.
103
44
 */
104
45
AlarmManagerPrivate * createAlarmsAdapter(AlarmManager *alarms)
105
46
{
107
48
}
108
49
 
109
50
AlarmsAdapter::AlarmsAdapter(AlarmManager *qq)
110
 
    : AlarmManagerPrivate(qq)
111
 
    , manager("memory")
 
51
    : QObject(qq)
 
52
    , AlarmManagerPrivate(qq)
 
53
    , listDirty(false)
 
54
    , manager(0)
 
55
    , fetchRequest(0)
112
56
{
113
 
    bool alarmCollectionFound = false;
114
 
    QList<QOrganizerCollection> collections = manager.collections();
 
57
    QOrganizerManager local;
 
58
    bool usingDefaultManager = local.availableManagers().contains(ALARM_MANAGER);
 
59
    manager = (usingDefaultManager) ? new QOrganizerManager(ALARM_MANAGER) : new QOrganizerManager(ALARM_MANAGER_FALLBACK);
 
60
    manager->setParent(q_ptr);
 
61
    if (!usingDefaultManager) {
 
62
        qWarning() << "WARNING: default alarm manager not installed, using" << manager->managerName() << "manager.";
 
63
        qWarning() << "This manager may not provide all the needed features.";
 
64
    }
 
65
 
 
66
    QList<QOrganizerCollection> collections = manager->collections();
115
67
    if (collections.count() > 0) {
116
68
        Q_FOREACH(const QOrganizerCollection &c, collections) {
117
 
            if (c.metaData(QOrganizerCollection::KeyName).toString() == "alarms") {
118
 
                alarmCollectionFound = true;
 
69
            if (c.metaData(QOrganizerCollection::KeyName).toString() == ALARM_COLLECTION) {
119
70
                collection = c;
120
71
                break;
121
72
            }
122
73
        }
123
74
    }
124
 
    if (!alarmCollectionFound) {
 
75
    if (collection.id().isNull()) {
125
76
        // create alarm collection
126
 
        collection.setMetaData(QOrganizerCollection::KeyName, "alarms");
127
 
        manager.saveCollection(&collection);
 
77
        collection.setMetaData(QOrganizerCollection::KeyName, ALARM_COLLECTION);
 
78
        // EDS requires extra metadata to be set
 
79
        collection. setExtendedMetaData("collection-type", "Task List");
 
80
        if (!manager->saveCollection(&collection)) {
 
81
            qWarning() << "WARNING: Creating dedicated collection for alarms was not possible, alarms will be saved into the default collection!";
 
82
            collection = manager->defaultCollection();
 
83
        }
128
84
    }
129
85
    loadAlarms();
 
86
 
 
87
    // connect to manager to receive changes
 
88
    QObject::connect(manager, SIGNAL(dataChanged()), this, SLOT(fetchAlarms()));
 
89
    QObject::connect(manager, SIGNAL(itemsAdded(QList<QOrganizerItemId>)), this, SLOT(fetchAlarms()));
 
90
    QObject::connect(manager, SIGNAL(itemsChanged(QList<QOrganizerItemId>)), this, SLOT(fetchAlarms()));
 
91
    QObject::connect(manager, SIGNAL(itemsRemoved(QList<QOrganizerItemId>)), this, SLOT(fetchAlarms()));
130
92
}
131
93
 
132
94
AlarmsAdapter::~AlarmsAdapter()
134
96
    saveAlarms();
135
97
}
136
98
 
137
 
// FIXME: remove once we have the Organizer backend ready
 
99
// load fallback manager data
138
100
void AlarmsAdapter::loadAlarms()
139
101
{
 
102
    if (manager->managerName() != ALARM_MANAGER_FALLBACK) {
 
103
        return;
 
104
    }
140
105
    QFile file(QString(ALARM_DATABASE).arg(QStandardPaths::writableLocation(QStandardPaths::DataLocation)));
141
106
    if (!file.open(QFile::ReadOnly)) {
142
107
        return;
152
117
        alarm.days = static_cast<UCAlarm::DaysOfWeek>(days);
153
118
 
154
119
        QOrganizerTodo event;
155
 
        rawAlarm2Organizer(alarm, event);
156
 
        manager.saveItem(&event);
 
120
        organizerEventFromAlarmData(alarm, event);
 
121
        manager->saveItem(&event);
157
122
    }
158
123
    file.close();
159
124
}
160
125
 
161
 
// FIXME: remove once we have the Organizer backend ready
 
126
// save fallback manager data only
162
127
void AlarmsAdapter::saveAlarms()
163
128
{
 
129
    if ((manager->managerName() != ALARM_MANAGER_FALLBACK) || !listDirty) {
 
130
        return;
 
131
    }
164
132
    QDir dir(QStandardPaths::writableLocation(QStandardPaths::DataLocation));
165
133
    if (!dir.exists()) {
166
134
        dir.mkpath(QStandardPaths::writableLocation(QStandardPaths::DataLocation));
180
148
            << alarm.enabled;
181
149
    }
182
150
    file.close();
 
151
    listDirty = false;
183
152
}
184
153
 
185
 
void AlarmsAdapter::rawAlarm2Organizer(const AlarmData &alarm, QOrganizerTodo &event)
 
154
void AlarmsAdapter::organizerEventFromAlarmData(const AlarmData &alarm, QOrganizerTodo &event)
186
155
{
187
156
    event.setCollectionId(collection.id());
188
157
    event.setAllDay(false);
 
158
    event.setStartDateTime(alarm.date);
189
159
    event.setDueDateTime(alarm.date);
190
160
    event.setDisplayLabel(alarm.message);
191
161
 
226
196
    }
227
197
}
228
198
 
229
 
void AlarmsAdapter::updateOrganizerFromRaw(const AlarmData &alarm, QOrganizerTodo &event)
 
199
void AlarmsAdapter::updateOrganizerEventFromAlarmData(const AlarmData &alarm, QOrganizerTodo &event)
230
200
{
231
201
    // remove affected details
232
202
    if (!alarm.enabled || (alarm.changes & AlarmData::Enabled)) {
242
212
        event.removeDetail(&old);
243
213
    }
244
214
 
245
 
    rawAlarm2Organizer(alarm, event);
 
215
    organizerEventFromAlarmData(alarm, event);
246
216
}
247
217
 
248
 
int AlarmsAdapter::organizer2RawAlarm(const QOrganizerItem &item, AlarmData &alarm)
 
218
int AlarmsAdapter::alarmDataFromOrganizerEvent(const QOrganizerTodo &event, AlarmData &alarm)
249
219
{
250
 
    if ((item.type() != QOrganizerItemType::TypeTodo) &&
251
 
        (item.type() != QOrganizerItemType::TypeTodoOccurrence)){
252
 
        return DifferentTypeExpected;
253
 
    }
254
 
 
255
 
    QOrganizerTodo event;
256
 
    if (item.type() == QOrganizerItemType::TypeTodoOccurrence) {
257
 
        QOrganizerTodoOccurrence occurence = static_cast<QOrganizerTodoOccurrence>(item);
258
 
        QOrganizerItemId eventId = occurence.parentId();
259
 
        event = static_cast<QOrganizerTodo>(manager.item(eventId));
260
 
    } else {
261
 
        event = static_cast<QOrganizerTodo>(item);
262
 
    }
263
220
    if (event.isEmpty()) {
264
221
        return FetchedEventEmpty;
265
222
    }
266
223
 
267
224
    alarm.cookie = QVariant::fromValue<QOrganizerItemId>(event.id());
268
225
    alarm.message = event.displayLabel();
269
 
    alarm.date = event.dueDateTime();
 
226
    alarm.date = AlarmData::normalizeDate(event.dueDateTime());
270
227
    alarm.sound = QUrl(event.description());
271
228
 
272
229
    // check if the alarm is enabled or not
326
283
 */
327
284
bool AlarmsAdapter::fetchAlarms()
328
285
{
 
286
    if (fetchRequest) {
 
287
        // there is already a fetch request ongoing, exit
 
288
        return false;
 
289
    }
329
290
    // create self deleting request
330
 
    AlarmRequest *request = new AlarmRequest(true, q_ptr);
331
 
    AlarmRequestAdapter *adapter = static_cast<AlarmRequestAdapter*>(AlarmRequestPrivate::get(request));
 
291
    fetchRequest = new AlarmRequest(true, q_ptr);
 
292
    AlarmRequestAdapter *adapter = static_cast<AlarmRequestAdapter*>(AlarmRequestPrivate::get(fetchRequest));
332
293
    return adapter->fetch();
333
294
}
334
295
 
337
298
    alarmList.clear();
338
299
 
339
300
    QSet<QOrganizerItemId> parentId;
 
301
    QOrganizerTodo event;
340
302
    Q_FOREACH(const QOrganizerItem &item, alarms) {
341
303
        // repeating alarms may be fetched as occurences, therefore check their parent event
342
304
        if (item.type() == QOrganizerItemType::TypeTodoOccurrence) {
343
305
            QOrganizerTodoOccurrence occurence = static_cast<QOrganizerTodoOccurrence>(item);
344
 
            if (parentId.contains(occurence.parentId())) {
345
 
                // skip this as we only consider parent items
 
306
            QOrganizerItemId eventId = occurence.parentId();
 
307
            if (parentId.contains(eventId)) {
346
308
                continue;
347
309
            }
348
 
            parentId << occurence.parentId();
349
 
        } else if (item.type() != QOrganizerItemType::TypeTodo) {
350
 
            // skip any other type than Event
 
310
            parentId << eventId;
 
311
            event = static_cast<QOrganizerTodo>(manager->item(eventId));
 
312
        } else if (item.type() == QOrganizerItemType::TypeTodo){
 
313
            event = static_cast<QOrganizerTodo>(item);
 
314
        } else {
351
315
            continue;
352
316
        }
353
317
        AlarmData alarm;
354
 
        if (organizer2RawAlarm(item, alarm) == UCAlarm::NoError) {
 
318
        if (alarmDataFromOrganizerEvent(event, alarm) == UCAlarm::NoError) {
355
319
            alarmList << alarm;
356
320
        }
357
321
    }
358
322
 
359
323
    saveAlarms();
360
 
    if (completed) {
361
 
        Q_EMIT q_ptr->alarmsChanged();
362
 
    }
 
324
    Q_EMIT q_ptr->alarmsChanged();
363
325
    completed = true;
 
326
    fetchRequest = 0;
364
327
}
365
328
 
366
329
/*-----------------------------------------------------------------------------
387
350
 
388
351
    if (!alarm.cookie.isValid()) {
389
352
        // new event
390
 
        AlarmsAdapter::get()->rawAlarm2Organizer(alarm, event);
 
353
        AlarmsAdapter::get()->organizerEventFromAlarmData(alarm, event);
391
354
    } else {
392
355
        // update existing event
393
356
        QOrganizerItemId itemId = alarm.cookie.value<QOrganizerItemId>();
394
 
        event = AlarmsAdapter::get()->manager.item(itemId);
 
357
        event = AlarmsAdapter::get()->manager->item(itemId);
395
358
        if (event.isEmpty()) {
396
 
            setStatus(AlarmRequest::Fail, UCAlarm::AdaptationError);
 
359
            setStatus(AlarmRequest::Saving, AlarmRequest::Fail, UCAlarm::AdaptationError);
397
360
            return false;
398
361
        }
399
 
        AlarmsAdapter::get()->updateOrganizerFromRaw(alarm, event);
 
362
        AlarmsAdapter::get()->updateOrganizerEventFromAlarmData(alarm, event);
400
363
    }
401
364
 
402
365
    QOrganizerItemSaveRequest *operation = new QOrganizerItemSaveRequest(q_ptr);
403
 
    operation->setManager(&AlarmsAdapter::get()->manager);
 
366
    operation->setManager(AlarmsAdapter::get()->manager);
404
367
    operation->setItem(event);
 
368
    AlarmsAdapter::get()->listDirty = true;
405
369
    return start(operation);
406
370
}
407
371
 
411
375
bool AlarmRequestAdapter::remove(AlarmData &alarm)
412
376
{
413
377
    if (!alarm.cookie.isValid()) {
414
 
        setStatus(AlarmRequest::Fail, UCAlarm::InvalidEvent);
 
378
        setStatus(AlarmRequest::Canceling, AlarmRequest::Fail, UCAlarm::InvalidEvent);
415
379
        return false;
416
380
    }
417
381
 
418
 
    QOrganizerItemId itemId = alarm.cookie.value<QOrganizerItemId>();
419
 
    QOrganizerItemRemoveByIdRequest *operation = new QOrganizerItemRemoveByIdRequest(q_ptr);
420
 
    operation->setManager(&AlarmsAdapter::get()->manager);
421
 
    operation->setItemId(itemId);
 
382
    QOrganizerTodo event;
 
383
    AlarmsAdapter::get()->organizerEventFromAlarmData(alarm, event);
 
384
    event.setId(alarm.cookie.value<QOrganizerItemId>());
 
385
 
 
386
    QOrganizerItemRemoveRequest *operation = new QOrganizerItemRemoveRequest(q_ptr);
 
387
    operation->setManager(AlarmsAdapter::get()->manager);
 
388
    operation->setItem(event);
 
389
    AlarmsAdapter::get()->listDirty = true;
422
390
    return start(operation);
423
391
}
424
392
 
425
393
/*
 
394
 * Waits for event completion. msec zero means wait forever.
 
395
 */
 
396
bool AlarmRequestAdapter::wait(int msec)
 
397
{
 
398
    return (m_request) ? m_request->waitForFinished(msec) : true;
 
399
}
 
400
 
 
401
/*
426
402
 * Initiates alarm fetching.
427
403
 */
428
404
bool AlarmRequestAdapter::fetch()
431
407
    AlarmsAdapter *owner = AlarmsAdapter::get(manager);
432
408
 
433
409
    QOrganizerItemFetchRequest *operation = new QOrganizerItemFetchRequest(q_ptr);
434
 
    operation->setManager(&owner->manager);
 
410
    operation->setManager(owner->manager);
435
411
 
436
412
    // set sort order
437
413
    QOrganizerItemSortOrder sortOrder;
459
435
    }
460
436
    completed = false;
461
437
    // make sure we are in progress state
462
 
    setStatus(AlarmRequest::InProgress);
 
438
    setStatus(requestTypeToOperation(), AlarmRequest::InProgress);
 
439
    QObject::connect(m_request, SIGNAL(resultsAvailable()), q_ptr, SLOT(_q_updateProgress()));
463
440
    if (m_request->start()) {
464
441
        // check if the request got completed without having the slot called (some engines may do that)
465
442
        if (!completed && m_request->state() >= QOrganizerAbstractRequest::CanceledState) {
478
455
    completed = true;
479
456
 
480
457
    QOrganizerAbstractRequest::State state = m_request->state();
 
458
    AlarmRequest::Operation opCode = requestTypeToOperation();
481
459
    switch (state) {
482
460
    case QOrganizerAbstractRequest::InactiveState: {
483
 
        setStatus(AlarmRequest::Ready);
 
461
        setStatus(opCode, AlarmRequest::Ready);
484
462
        break;
485
463
    }
486
464
    case QOrganizerAbstractRequest::ActiveState: {
487
 
        setStatus(AlarmRequest::InProgress);
 
465
        setStatus(opCode, AlarmRequest::InProgress);
488
466
        completed = false;
489
467
        break;
490
468
    }
491
469
    case QOrganizerAbstractRequest::CanceledState: {
492
 
        setStatus(AlarmRequest::Fail, AlarmsAdapter::OrganizerError + m_request->error());
 
470
        setStatus(opCode, AlarmRequest::Fail, AlarmsAdapter::OrganizerError + m_request->error());
493
471
        break;
494
472
    }
495
473
    case QOrganizerAbstractRequest::FinishedState: {
496
474
        int code = m_request->error();
497
475
        if (code != QOrganizerManager::NoError) {
498
 
            setStatus(AlarmRequest::Fail, AlarmsAdapter::OrganizerError + code);
 
476
            setStatus(opCode, AlarmRequest::Fail, AlarmsAdapter::OrganizerError + code);
499
477
        } else {
500
 
            switch (m_request->type()) {
501
 
            case QOrganizerAbstractRequest::ItemSaveRequest: {
 
478
            switch (opCode) {
 
479
            case AlarmRequest::Saving: {
502
480
                completeUpdate();
503
481
                break;
504
482
            }
505
 
            case QOrganizerAbstractRequest::ItemRemoveByIdRequest: {
 
483
            case AlarmRequest::Canceling: {
506
484
                completeRemove();
507
485
                break;
508
486
            }
509
 
            case QOrganizerAbstractRequest::ItemFetchRequest: {
 
487
            case AlarmRequest::Fetching: {
510
488
                completeFetch();
511
489
                break;
512
490
            }
513
491
            default:
514
492
                qWarning() << "Unhandled request:" << m_request->type();
515
 
                setStatus(AlarmRequest::Fail, AlarmsAdapter::UnhandledRequest);
 
493
                setStatus(opCode, AlarmRequest::Fail, AlarmsAdapter::UnhandledRequest);
516
494
                break;
517
495
            }
518
496
 
519
 
            setStatus(AlarmRequest::Ready);
 
497
            setStatus(opCode, AlarmRequest::Ready);
520
498
        }
521
499
        break;
522
500
    }
523
501
    default: {
524
502
        qWarning() << "Invalid status" << state;
525
 
        setStatus(AlarmRequest::Fail, UCAlarm::InvalidEvent);
 
503
        setStatus(opCode, AlarmRequest::Fail, UCAlarm::InvalidEvent);
526
504
        break;
527
505
    }
528
506
    }
529
507
 
530
508
    if (completed) {
531
509
        // cleanup request
532
 
        delete m_request;
 
510
        m_request->deleteLater();
533
511
        m_request = 0;
534
512
 
535
513
        if (autoDelete) {
538
516
    }
539
517
}
540
518
 
 
519
AlarmRequest::Operation AlarmRequestAdapter::requestTypeToOperation()
 
520
{
 
521
    switch (m_request->type()) {
 
522
    case QOrganizerAbstractRequest::ItemSaveRequest: {
 
523
        return AlarmRequest::Saving;
 
524
    }
 
525
    case QOrganizerAbstractRequest::ItemRemoveRequest: {
 
526
        return AlarmRequest::Canceling;
 
527
    }
 
528
    case QOrganizerAbstractRequest::ItemFetchRequest: {
 
529
        return AlarmRequest::Fetching;
 
530
    }
 
531
    default:
 
532
        return AlarmRequest::NoOperation;
 
533
    }
 
534
}
 
535
 
541
536
void AlarmRequestAdapter::completeUpdate()
542
537
{
543
538
    UCAlarm *alarm = qobject_cast<UCAlarm*>(q_ptr->parent());
548
543
    QOrganizerItemSaveRequest *save = qobject_cast<QOrganizerItemSaveRequest*>(m_request);
549
544
    pAlarm->rawData.cookie = QVariant::fromValue<QOrganizerItemId>(save->items()[0].id());
550
545
    pAlarm->rawData.changes = AlarmData::NoChange;
551
 
 
552
 
    // request for refresh
553
 
    AlarmManagerPrivate::get()->fetchAlarms();
554
546
}
555
547
 
556
548
void AlarmRequestAdapter::completeRemove()
562
554
    UCAlarmPrivate *pAlarm = UCAlarmPrivate::get(alarm);
563
555
    pAlarm->rawData.cookie = QVariant();
564
556
    pAlarm->rawData.changes = AlarmData::NoChange;
565
 
 
566
 
    // request for refresh
567
 
    AlarmManagerPrivate::get()->fetchAlarms();
568
557
}
569
558
 
570
559
void AlarmRequestAdapter::completeFetch()