← Back to branch summary

~ubuntu-branches/ubuntu/quantal/qtmobility/quantal

« back to all changes in this revision

Viewing changes to plugins/organizer/symbian/qorganizersymbian_p.h

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-11-16 16:18:07 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20101116161807-k2dzt2nyse975r3l
Tags: 1.1.0-0ubuntu1
* New upstream release
* Syncronise with Debian, no remaining changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/organizer/symbian/qorganizersymbian_p.h
8
8
**
9
9
** $QT_BEGIN_LICENSE:LGPL$
10
10
** Commercial Usage
11
 
** Licensees holding valid Qt Commercial licenses may use this file in
12
 
** accordance with the Qt Solutions Commercial License Agreement provided
13
 
** with the Software or, alternatively, in accordance with the terms
 
11
** Licensees holding valid Qt Commercial licenses may use this file in 
 
12
** accordance with the Qt Commercial License Agreement provided with
 
13
** the Software or, alternatively, in accordance with the terms
14
14
** contained in a written agreement between you and Nokia.
15
15
**
16
16
** GNU Lesser General Public License Usage
33
33
** ensure the GNU General Public License version 3.0 requirements will be
34
34
** met: http://www.gnu.org/copyleft/gpl.html.
35
35
**
36
 
** Please note Third Party Software included with Qt Solutions may impose
37
 
** additional restrictions and it is the user's responsibility to ensure
38
 
** that they have met the licensing requirements of the GPL, LGPL, or Qt
39
 
** Solutions Commercial license and the relevant license of the Third
40
 
** Party Software they are using.
41
 
**
42
36
** If you are unsure which license is appropriate for your use, please
43
37
** contact the sales department at qt-sales@nokia.com.
44
38
** $QT_END_LICENSE$
72
66
#include <QObject>
73
67
 
74
68
#include "qorganizeritem.h"
75
 
#include "qorganizeritemmanager.h"
76
 
#include "qorganizeritemmanagerengine.h"
77
 
#include "qorganizeritemmanagerenginefactory.h"
 
69
#include "qorganizeritemengineid.h"
 
70
#include "qorganizercollectionengineid.h"
 
71
#include "qorganizermanager.h"
 
72
#include "qorganizermanagerengine.h"
 
73
#include "qorganizermanagerenginefactory.h"
78
74
#include "qorganizeritemchangeset.h"
79
75
 
80
76
#include "organizeritemtransform.h"
 
77
#include "organizersymbiancollection.h"
81
78
 
82
79
#include <calprogresscallback.h> // MCalProgressCallBack
83
80
#include <calchangecallback.h>
85
82
#include <calfilechangenotification.h>
86
83
#endif
87
84
 
 
85
 
88
86
QTM_USE_NAMESPACE
89
87
 
90
 
class QOrganizerItemSymbianFactory : public QObject, public QOrganizerItemManagerEngineFactory
 
88
class OrganizerItemTransform; // forward declare transform class.
 
89
class QOrganizerItemSymbianEngine; // forward declare symbian engine.
 
90
class QOrganizerCollectionSymbianEngineId : public QOrganizerCollectionEngineId
 
91
{
 
92
public:
 
93
    QOrganizerCollectionSymbianEngineId();
 
94
    QOrganizerCollectionSymbianEngineId(quint64 collectionId);
 
95
    ~QOrganizerCollectionSymbianEngineId();
 
96
    QOrganizerCollectionSymbianEngineId(const QOrganizerCollectionSymbianEngineId& other);
 
97
 
 
98
    bool isEqualTo(const QOrganizerCollectionEngineId* other) const;
 
99
    bool isLessThan(const QOrganizerCollectionEngineId* other) const;
 
100
 
 
101
    QString managerUri() const;
 
102
    QOrganizerCollectionEngineId* clone() const;
 
103
 
 
104
    QString toString() const;
 
105
 
 
106
#ifndef QT_NO_DEBUG_STREAM
 
107
    QDebug& debugStreamOut(QDebug& dbg) const;
 
108
#endif
 
109
    uint hash() const;
 
110
 
 
111
private:
 
112
    quint64 m_localCollectionId;
 
113
    friend class QOrganizerItemSymbianEngine;
 
114
};
 
115
 
 
116
class QOrganizerItemSymbianEngineId : public QOrganizerItemEngineId
 
117
{
 
118
public:
 
119
    QOrganizerItemSymbianEngineId();
 
120
    QOrganizerItemSymbianEngineId(quint64 collectionId, quint32 itemId);
 
121
    ~QOrganizerItemSymbianEngineId();
 
122
    QOrganizerItemSymbianEngineId(const QOrganizerItemSymbianEngineId& other);
 
123
 
 
124
    bool isEqualTo(const QOrganizerItemEngineId* other) const;
 
125
    bool isLessThan(const QOrganizerItemEngineId* other) const;
 
126
 
 
127
    QString managerUri() const;
 
128
    QOrganizerItemEngineId* clone() const;
 
129
 
 
130
    QString toString() const;
 
131
 
 
132
#ifndef QT_NO_DEBUG_STREAM
 
133
    QDebug& debugStreamOut(QDebug& dbg) const;
 
134
#endif
 
135
    uint hash() const;
 
136
    
 
137
public:
 
138
    quint32 calLocalUid() const { return m_localItemId; }
 
139
    quint64 calCollectionId() const { return m_localCollectionId; }
 
140
    
 
141
private:
 
142
    quint64 m_localCollectionId;
 
143
    quint32 m_localItemId; // the symbian backend requires quint32 for itemId + quint64 for collectionId
 
144
    friend class QOrganizerItemSymbianEngine;
 
145
    friend class OrganizerItemTransform;
 
146
};
 
147
 
 
148
 
 
149
 
 
150
 
 
151
class QOrganizerItemSymbianFactory : public QObject, 
 
152
public QOrganizerManagerEngineFactory
91
153
{
92
154
  Q_OBJECT
93
 
  Q_INTERFACES(QtMobility::QOrganizerItemManagerEngineFactory)
 
155
  Q_INTERFACES(QtMobility::QOrganizerManagerEngineFactory)
94
156
  public:
95
 
    QOrganizerItemManagerEngine* engine(const QMap<QString, QString>& parameters, QOrganizerItemManager::Error*);
 
157
    QOrganizerManagerEngine* engine(
 
158
        const QMap<QString, QString>& parameters, 
 
159
        QOrganizerManager::Error*);
96
160
    QString managerName() const;
 
161
    QOrganizerItemEngineId* createItemEngineId(const QMap<QString, QString>& parameters,
 
162
            const QString& engineIdString) const;
 
163
    QOrganizerCollectionEngineId* createCollectionEngineId(const QMap<QString, QString>& parameters,
 
164
            const QString& engineIdString) const;
97
165
};
98
166
 
99
167
class QOrganizerItemSymbianEngineData : public QSharedData
104
172
    {
105
173
    }
106
174
 
107
 
    QOrganizerItemSymbianEngineData(const QOrganizerItemSymbianEngineData& other)
108
 
        : QSharedData(other)
 
175
    QOrganizerItemSymbianEngineData(
 
176
        const QOrganizerItemSymbianEngineData& other) : QSharedData(other)
109
177
    {
110
178
    }
111
179
 
123
191
class CCalCalendarInfo;
124
192
#endif
125
193
 
126
 
class QOrganizerItemSymbianEngine : public QOrganizerItemManagerEngine, 
127
 
                                    public MCalProgressCallBack,
128
 
                                    public MCalChangeCallBack2
 
194
class QOrganizerItemSymbianEngine : public QOrganizerManagerEngine
 
195
 
129
196
#ifdef SYMBIAN_CALENDAR_V2
130
197
                                    ,public MCalFileChangeObserver
131
198
#endif
133
200
    Q_OBJECT
134
201
 
135
202
public:
136
 
    static QOrganizerItemSymbianEngine *createSkeletonEngine(const QMap<QString, QString>& parameters);
 
203
    static QOrganizerItemSymbianEngine *createSkeletonEngine(
 
204
        const QMap<QString, QString>& parameters);
137
205
 
138
206
    QOrganizerItemSymbianEngine();
139
207
    ~QOrganizerItemSymbianEngine();
143
211
    QMap<QString, QString> managerParameters() const;
144
212
    int managerVersion() const;
145
213
 
146
 
    QList<QOrganizerItem> itemInstances(const QOrganizerItem& generator, const QDateTime& periodStart, const QDateTime& periodEnd, int maxCount, QOrganizerItemManager::Error* error) const;
147
 
    QList<QOrganizerItem> itemInstances(const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint,QOrganizerItemManager::Error* error) const;
148
 
 
149
 
    QList<QOrganizerItemLocalId> itemIds(const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, QOrganizerItemManager::Error* error) const;
150
 
    QList<QOrganizerItem> items(const QOrganizerItemFilter& filter, const QList<QOrganizerItemSortOrder>& sortOrders, const QOrganizerItemFetchHint& fetchHint, QOrganizerItemManager::Error* error) const;
151
 
    QOrganizerItem item(const QOrganizerItemLocalId& itemId, const QOrganizerItemFetchHint& fetchHint, QOrganizerItemManager::Error* error) const;
152
 
 
153
 
    bool saveItem(QOrganizerItem* item, const QOrganizerCollectionLocalId& collectionId, QOrganizerItemManager::Error* error);
154
 
    bool saveItems(QList<QOrganizerItem> *items, const QOrganizerCollectionLocalId& collectionId, QMap<int, QOrganizerItemManager::Error> *errorMap, QOrganizerItemManager::Error *error);
155
 
 
156
 
    bool removeItem(const QOrganizerItemLocalId& organizeritemId, QOrganizerItemManager::Error* error);
157
 
    bool removeItems(const QList<QOrganizerItemLocalId> &itemIds, QMap<int, QOrganizerItemManager::Error> *errorMap, QOrganizerItemManager::Error *error);
 
214
    QList<QOrganizerItem> itemOccurrences(const QOrganizerItem& parentItem,
 
215
        const QDateTime& periodStart, const QDateTime& periodEnd,
 
216
        int maxCount, const QOrganizerItemFetchHint& fetchHint,
 
217
        QOrganizerManager::Error* error) const;
 
218
    QList<QOrganizerItem> items(const QDateTime& periodStart,
 
219
        const QDateTime& periodEnd,
 
220
        const QOrganizerItemFilter& filter, 
 
221
        const QList<QOrganizerItemSortOrder>& sortOrders, 
 
222
        const QOrganizerItemFetchHint& fetchHint, 
 
223
        QOrganizerManager::Error* error) const;
 
224
 
 
225
    QList<QOrganizerItemId> itemIds(const QDateTime& periodStart,
 
226
        const QDateTime& periodEnd,
 
227
        const QOrganizerItemFilter& filter, 
 
228
        const QList<QOrganizerItemSortOrder>& sortOrders, 
 
229
        QOrganizerManager::Error* error) const;
 
230
    QList<QOrganizerItemId> getIdsModifiedSinceDateL(
 
231
        const QDateTime& periodStart,
 
232
        const QDateTime& periodEnd,
 
233
        const QOrganizerItemFilter& filter) const;
 
234
    void itemIdsL(
 
235
        QList<QOrganizerItemId>& ids, 
 
236
        const QDateTime& periodStart,
 
237
        const QDateTime& periodEnd,
 
238
        const QOrganizerItemFilter& filter, 
 
239
        const QList<QOrganizerItemSortOrder>& sortOrders) const;
 
240
    QList<QOrganizerItem> itemsForExport(const QDateTime& periodStart,
 
241
        const QDateTime& periodEnd,
 
242
        const QOrganizerItemFilter& filter, 
 
243
        const QList<QOrganizerItemSortOrder>& sortOrders, 
 
244
        const QOrganizerItemFetchHint& fetchHint, 
 
245
        QOrganizerManager::Error* error) const;
 
246
    void itemsForExportL(QList<QOrganizerItem>& itemsList, 
 
247
        const QDateTime& periodStart,
 
248
        const QDateTime& periodEnd,
 
249
        const QOrganizerItemFilter& filter, 
 
250
        const QList<QOrganizerItemSortOrder>& sortOrders, 
 
251
        const QOrganizerItemFetchHint& fetchHint) const;
 
252
    QOrganizerItem item(const QOrganizerItemId& itemId, 
 
253
        const QOrganizerItemFetchHint& fetchHint, 
 
254
        QOrganizerManager::Error* error) const;
 
255
 
 
256
    bool saveItem(QOrganizerItem* item,
 
257
        QOrganizerManager::Error* error);
 
258
    bool saveItems(QList<QOrganizerItem> *items, 
 
259
        QMap<int, QOrganizerManager::Error> *errorMap, 
 
260
        QOrganizerManager::Error *error);
 
261
 
 
262
    bool removeItem(const QOrganizerItemId& organizeritemId, 
 
263
        QOrganizerManager::Error* error);
 
264
    bool removeItems(const QList<QOrganizerItemId> &itemIds, 
 
265
        QMap<int, QOrganizerManager::Error> *errorMap, 
 
266
        QOrganizerManager::Error *error);
158
267
    
159
268
    /* Collections - every item belongs to exactly one collection */
160
 
#ifdef SYMBIAN_CALENDAR_V2
161
 
    QOrganizerCollectionLocalId defaultCollectionId(QOrganizerItemManager::Error* error) const;
162
 
    QList<QOrganizerCollectionLocalId> collectionIds(QOrganizerItemManager::Error* error) const;
163
 
    QList<QOrganizerCollection> collections(const QList<QOrganizerCollectionLocalId>& collectionIds, QOrganizerItemManager::Error* error) const;
164
 
    bool collectionL(const int 
165
 
        index, const QList<QOrganizerCollectionLocalId>& collectionIds, 
166
 
        QOrganizerCollection& collection) const;
167
 
    bool saveCollection(QOrganizerCollection* collection, QOrganizerItemManager::Error* error);
168
 
    bool removeCollection(const QOrganizerCollectionLocalId& collectionId, QOrganizerItemManager::Error* error);
169
 
#endif
 
269
    QOrganizerCollection defaultCollection(
 
270
        QOrganizerManager::Error* error) const;
 
271
    QOrganizerCollection collection(
 
272
        const QOrganizerCollectionId& collectionId,
 
273
        QOrganizerManager::Error* error) const;
 
274
    QList<QOrganizerCollection> collections(
 
275
        QOrganizerManager::Error* error) const;
 
276
    bool saveCollection(QOrganizerCollection* collection, 
 
277
        QOrganizerManager::Error* error);
 
278
    bool removeCollection(const QOrganizerCollectionId& collectionId, 
 
279
        QOrganizerManager::Error* error);
 
280
 
 
281
    /* Return a pruned or modified item which is valid and can be saved in the backend */
 
282
    QOrganizerItem compatibleItem(const QOrganizerItem& original, QOrganizerManager::Error* error) const;
 
283
    QOrganizerCollection compatibleCollection(const QOrganizerCollection& original, QOrganizerManager::Error* error) const;
170
284
 
171
285
    /* Definitions - Accessors and Mutators */
172
 
    QMap<QString, QOrganizerItemDetailDefinition> detailDefinitions(const QString& itemType, QOrganizerItemManager::Error* error) const;
 
286
    QMap<QString, QOrganizerItemDetailDefinition> detailDefinitions(
 
287
        const QString& itemType, QOrganizerManager::Error* error) const;
173
288
 
174
289
    /* Capabilities reporting */
175
 
    bool hasFeature(QOrganizerItemManager::ManagerFeature feature, const QString& itemType) const;
 
290
    bool hasFeature(QOrganizerManager::ManagerFeature feature, 
 
291
        const QString& itemType) const;
176
292
    bool isFilterSupported(const QOrganizerItemFilter& filter) const;
177
 
    QList<QVariant::Type> supportedDataTypes() const;
 
293
    QList<int> supportedDataTypes() const;
178
294
    QStringList supportedItemTypes() const;
179
295
 
180
296
    /* Asynchronous Request Support */
181
 
    void requestDestroyed(QOrganizerItemAbstractRequest* req);
182
 
    bool startRequest(QOrganizerItemAbstractRequest* req);
183
 
    bool cancelRequest(QOrganizerItemAbstractRequest* req);
184
 
    bool waitForRequestFinished(QOrganizerItemAbstractRequest* req, int msecs);
 
297
    void requestDestroyed(QOrganizerAbstractRequest* req);
 
298
    bool startRequest(QOrganizerAbstractRequest* req);
 
299
    bool cancelRequest(QOrganizerAbstractRequest* req);
 
300
    bool waitForRequestFinished(QOrganizerAbstractRequest* req, int msecs);
185
301
 
186
302
public: // MCalProgressCallBack
187
303
    void Progress(TInt aPercentageCompleted);
188
304
    void Completed(TInt aError);
189
305
    TBool NotifyProgress();
190
306
 
191
 
public: // MCalChangeCallBack2
192
 
    void CalChangeNotification(RArray<TCalChangeEntry>& aChangeItems);
193
 
 
194
307
#ifdef SYMBIAN_CALENDAR_V2
195
308
public: // MCalFileChangeObserver
196
 
    void CalendarInfoChangeNotificationL(RPointerArray<CCalFileChangeInfo>& aCalendarInfoChangeEntries);
 
309
    void CalendarInfoChangeNotificationL(
 
310
        RPointerArray<CCalFileChangeInfo>& aCalendarInfoChangeEntries);
197
311
#endif
198
312
    
199
 
public: 
 
313
public:
 
314
    void initializeL();
200
315
    /* Util functions */
201
 
    static bool transformError(TInt symbianError, QOrganizerItemManager::Error* qtError);
202
 
    void saveItemL(QOrganizerItem *item, const QOrganizerCollectionLocalId& collectionId, QOrganizerItemChangeSet *changeSet);
203
 
    void itemL(const QOrganizerItemLocalId& itemId, QOrganizerItem *item, 
 
316
    static bool transformError(TInt symbianError, 
 
317
        QOrganizerManager::Error* qtError);
 
318
    void itemOccurrencesL(
 
319
        QList<QOrganizerItem> &itemOccurrences,
 
320
        const QOrganizerItem &parentItem,
 
321
        const QDateTime &periodStart,
 
322
        const QDateTime &periodEnd,
 
323
        int maxCount,
 
324
        const QOrganizerItemFetchHint &fetchHint) const;
 
325
    QList<QOrganizerItem> itemsL(
 
326
        QList<QOrganizerItem> &itemOccurrences,
 
327
        const QDateTime& periodStart,
 
328
        const QDateTime& periodEnd,
 
329
        const QOrganizerItemFilter &filter,
 
330
        const QList<QOrganizerItemSortOrder> &sortOrders,
 
331
        const QOrganizerItemFetchHint &fetchHint) const;
 
332
    void toItemOccurrencesL(
 
333
        const RPointerArray<CCalInstance> &calInstanceList,
 
334
        QOrganizerItem parentItem,
 
335
        const int maxCount,
 
336
        QOrganizerCollectionId collectionId,
 
337
        QList<QOrganizerItem> &itemOccurrences) const;
 
338
    QOrganizerItem itemL(const QOrganizerItemId& itemId,
204
339
            const QOrganizerItemFetchHint& fetchHint) const;
205
 
    void removeItemL(const QOrganizerItemLocalId& organizeritemId);
 
340
    void saveItemL(QOrganizerItem *item,
 
341
        QOrganizerItemChangeSet *changeSet);
 
342
    void removeItemL(const QOrganizerItemId& organizeritemId);
206
343
    QList<QOrganizerItem> slowFilter(const QList<QOrganizerItem> &items, 
207
344
        const QOrganizerItemFilter& filter, 
208
345
        const QList<QOrganizerItemSortOrder>& sortOrders) const;
209
 
#ifdef SYMBIAN_CALENDAR_V2
210
 
    QList<QOrganizerCollectionLocalId> collectionIdsL() const;
211
 
    int sessionCount() const;
212
 
    QList<QOrganizerCollection> collectionsL(const QList<QOrganizerCollectionLocalId>& collectionIds) const;
 
346
 
 
347
private:
 
348
    QList<QOrganizerCollection> collectionsL() const;
213
349
    void saveCollectionL(QOrganizerCollection* collection);
214
 
    void removeCollectionL(const QOrganizerCollectionLocalId& collectionId);
215
 
#endif
216
 
    
217
 
private:
218
 
    CCalEntryView* entryViewL(const QOrganizerCollectionLocalId& collectionId) const;
219
 
    QOrganizerCollectionLocalId collectionLocalIdL(QOrganizerItem item, const QOrganizerCollectionLocalId& collectionId = 0) const;
220
 
    CCalEntry* entryForItemOccurrenceL(const QOrganizerCollectionLocalId collectionId, QOrganizerItem *item, bool &isNewEntry) const;
221
 
    CCalEntry* entryForItemL(const QOrganizerCollectionLocalId collectionId, QOrganizerItem *item, bool &isNewEntry) const;
222
 
    CCalEntry* findEntryL(const QOrganizerCollectionLocalId collectionId, QOrganizerItemLocalId localId, QString manageruri) const;
223
 
    CCalEntry* findEntryL(const QOrganizerCollectionLocalId collectionId, const TDesC8& globalUid) const;
224
 
    CCalEntry* findParentEntryLC(const QOrganizerCollectionLocalId collectionId, QOrganizerItem *item, const TDesC8& globalUid) const;
225
 
        
 
350
    void removeCollectionL(const QOrganizerCollectionId& collectionId);
 
351
    bool isCollectionNameAvailable(QString name) const;
 
352
    CCalEntryView* entryViewL(const QOrganizerCollectionId& collectionId) const;
 
353
    CCalInstanceView* instanceViewL(const QOrganizerCollectionId& collectionId) const;
 
354
    QOrganizerCollectionId collectionIdL(const QOrganizerItem &item, 
 
355
        const QOrganizerCollectionId &collectionId = QOrganizerCollectionId()) const;
 
356
    CCalEntry* entryForItemOccurrenceL(
 
357
        const QOrganizerCollectionId &collectionId, const QOrganizerItem &item, 
 
358
        bool &isNewEntry) const;
 
359
    CCalEntry* entryForItemL(const QOrganizerCollectionId &collectionId, 
 
360
        const QOrganizerItem &item, bool &isNewEntry) const;
 
361
    CCalEntry* findEntryL(const QOrganizerCollectionId &collectionId, 
 
362
        const QOrganizerItemId &localId, QString manageruri) const;
 
363
    CCalEntry* findEntryL(const QOrganizerCollectionId &collectionId, 
 
364
        const TDesC8& globalUid) const;
 
365
    CCalEntry* findParentEntryLC(const QOrganizerCollectionId &collectionId,
 
366
        const QOrganizerItem &item, const TDesC8& globalUid) const;
 
367
 
226
368
private:
227
369
    QOrganizerItemSymbianEngineData *d;
228
 
    CCalSession *m_defaultCalSession;
229
 
#ifdef SYMBIAN_CALENDAR_V2    
230
 
    RPointerArray<CCalSession> m_calSessions;
231
 
#endif
232
 
    QMap<QOrganizerCollectionLocalId, CCalEntryView *> m_entryViews;
233
 
    CCalInstanceView *m_instanceView;
234
 
    CActiveSchedulerWait *m_activeSchedulerWait;
 
370
    
 
371
    OrganizerSymbianCollection m_defaultCollection;
 
372
    QMap<QOrganizerCollectionId, OrganizerSymbianCollection> m_collections;
235
373
    QOrganizerItemRequestQueue* m_requestServiceProviderQueue;
236
 
 
237
 
    // TODO: replace this with an algorithm that generates the calendar entry UID
238
 
    int m_entrycount;
239
374
    OrganizerItemTransform m_itemTransform;
240
375
    mutable QMap<QString, QMap<QString, QOrganizerItemDetailDefinition> > m_definition;
241
376