Fixes : NB#233744
[meego-sharing-framework:transfer-ui.git] / transfer-ui / src / tuidatamodelproxy.cpp
1
2 /*
3  * This file is part of Handset UX Transfer user interface
4  *
5  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
6  * Contact: Jukka Tiihonen <jukka.tiihonen@nokia.com>
7  *
8  * Permission is hereby granted, free of charge, to any person obtaining a copy
9  * of this software and associated documentation files (the "Software"), to 
10  * deal in the Software without restriction, including without limitation the
11  * rights to use, copy, modify, merge, publish, distribute, sublicense,     
12  * and/or sell copies of the Software, and to permit persons to whom the
13  * Software is furnished to do so, subject to the following conditions:
14  *
15  * The above copyright notice and this permission notice shall be included in
16  * all copies or substantial portions of the Software.
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS  
23  * IN THE SOFTWARE. 
24  */
25
26
27
28
29
30
31
32
33  //local headers
34 #include "tuidatamodelproxy.h"
35 #include "transferenums.h"
36 #include "tuidatamodel.h"
37
38 //Qt headers
39 #include <QObject>
40 #include <QStringList>
41 #include <QDateTime>
42 #include <QDebug>
43
44 TUIDataModelProxy::TUIDataModelProxy(QObject *parent) : QObject(parent) {
45     model = new TUIDataModel(this);
46 }
47
48 TUIDataModelProxy::~TUIDataModelProxy() {
49     if(model != 0) {
50         delete model;
51     }
52     qDebug() << __FUNCTION__ << "Deleting Data Model Proxy";
53 }
54
55 TUIAbstractModel * TUIDataModelProxy::dataModel() const {
56     return model;
57 }
58
59 void TUIDataModelProxy::registerTransfer(const QString& id, TransferType type,
60     const QString& title, const QString& clientId, const QString& target, double
61     bytes) {
62     int rowNo = model->rowCount(QModelIndex());
63     model->insertRows(rowNo,1);
64     QModelIndex index = model->index(rowNo,Init);
65     QMap<int, QVariant> mapVariant = model->itemData(index);
66     QVariant data = mapVariant.value(Qt::EditRole);
67     TUIData *tuiData = data.value<TUIData*>();
68     if(tuiData != 0) {
69         tuiData->name = title;
70         tuiData->targetName = target;
71         tuiData->bytes = bytes;
72         tuiData->status = TransferStatusInactive;
73         tuiData->message.clear();
74         tuiData->method = type;
75         tuiData->thumbnailMimeType.clear();
76         tuiData->fileTypeIcon.clear();
77                 tuiData->clientId = clientId;
78         tuiData->startTime = QDateTime::currentDateTime();
79         QVariant variantData = qVariantFromValue(tuiData);
80         QMap<int,QVariant> rolesVariant;
81         rolesVariant.insert(Qt::EditRole, variantData);
82         model->setItemData(index,rolesVariant);
83         tuiDataMap.insert(id, tuiData);
84     }
85     QModelIndex newTransferAddedIndex = model->index(rowNo,NewTransferAdded);
86     model->setData(newTransferAddedIndex,QVariant());
87 }
88
89 void TUIDataModelProxy::removeTransfer(const QString& id) {
90     if(tuiDataMap.contains(id)) {
91         int rowNo = model->rowIndex(tuiDataMap.value(id));
92         model->removeRows(rowNo,1);
93         tuiDataMap.remove(id);
94     }
95 }
96
97 void TUIDataModelProxy::displayTransfers() {
98     model->refreshUIList();
99 }
100
101 QModelIndex TUIDataModelProxy::modelIndex(const QString& id) const {
102     QModelIndex index;
103     if (tuiDataMap.contains(id) == true) {
104         int rowNo = model->rowIndex(tuiDataMap.value(id));
105         index = model->index(rowNo,0);
106     }
107     return index;
108 }
109
110 /************************** Attribute changes *********************************/
111
112 void TUIDataModelProxy::setName(const QString &id, const QString &name) {
113     if (tuiDataMap.contains(id) == true) {
114         int rowNo = model->rowIndex(tuiDataMap.value(id));
115         QModelIndex index = model->index(rowNo,Name);
116         model->setData(index,name);
117     }
118 }
119
120 void TUIDataModelProxy::setProgress(const QString &id, double done) {
121     if (tuiDataMap.contains(id) == true) {
122         int rowNo = model->rowIndex(tuiDataMap.value(id));
123         QModelIndex index = model->index(rowNo,Progress);
124         model->setData(index,done);
125     }
126 }
127
128 void TUIDataModelProxy::setSize(const QString &id, qulonglong bytes) {
129     if (tuiDataMap.contains(id) == true) {
130         int rowNo = model->rowIndex(tuiDataMap.value(id));
131         QModelIndex index = model->index(rowNo,Size);
132         model->setData(index,bytes);
133     }
134 }
135
136 void TUIDataModelProxy::setThumbnailForFile(const QString& id,
137     const QString& fileName, const QString& mimeType) {
138
139     if (tuiDataMap.contains(id) == true) {
140         int rowNo = model->rowIndex(tuiDataMap.value(id));
141         QModelIndex index = model->index(rowNo,Thumbnail);
142         QStringList param;
143         param << fileName << mimeType;
144         model->setData(index,param);
145     }
146 }
147
148 void TUIDataModelProxy::setIcon(const QString& id, const QString& iconId) {
149     if (tuiDataMap.contains(id) == true) {
150         int rowNo = model->rowIndex(tuiDataMap.value(id));
151         QModelIndex index = model->index(rowNo,Icon);
152         model->setData(index,iconId);
153     }
154 }
155
156 void TUIDataModelProxy::setCanPause(const QString &id, bool canPause) {
157     if (tuiDataMap.contains(id) == true) {
158         int rowNo = model->rowIndex(tuiDataMap.value(id));
159         QModelIndex index = model->index(rowNo,CanPause);
160         model->setData(index,canPause);
161     }
162 }
163
164 void TUIDataModelProxy::setCanSendNow(const QString &id, bool canSendNow) {
165     if (tuiDataMap.contains(id) == true) {
166         int rowNo = model->rowIndex(tuiDataMap.value(id));
167         QModelIndex index = model->index(rowNo,SendNow);
168         model->setData(index,canSendNow);
169     }
170 }
171
172 void TUIDataModelProxy::setEstimate(const QString &id, int seconds) {
173     if (tuiDataMap.contains(id) == true) {
174         int rowNo = model->rowIndex(tuiDataMap.value(id));
175         QModelIndex index = model->index(rowNo,Estimate);
176         model->setData(index,seconds);
177     }
178 }
179
180 void TUIDataModelProxy::setFilesCount(const QString &id, int count) {
181     if (tuiDataMap.contains(id) == true) {
182         int rowNo = model->rowIndex(tuiDataMap.value(id));
183         QModelIndex index = model->index(rowNo,TotalCount);
184         model->setData(index,count);
185     }
186 }
187
188 void TUIDataModelProxy::setCurrentFileIndex(const QString &id, int fileIndex) {
189     if (tuiDataMap.contains(id) == true) {
190         int rowNo = model->rowIndex(tuiDataMap.value(id));
191         QModelIndex index = model->index(rowNo,CurrentFile);
192         model->setData(index,fileIndex);
193     }
194 }
195
196 void TUIDataModelProxy::setMessage(const QString &id, const QString &message) {
197     if (tuiDataMap.contains(id) == true) {
198         int rowNo = model->rowIndex(tuiDataMap.value(id));
199         QModelIndex index = model->index(rowNo,Message);
200         model->setData(index,message);
201     }
202 }
203
204 void TUIDataModelProxy::setTransferType(const QString &id, int transferType) {
205     if (tuiDataMap.contains(id) == true) {
206         int rowNo = model->rowIndex(tuiDataMap.value(id));
207         QModelIndex index = model->index(rowNo,Type);
208         model->setData(index,transferType);
209     }
210 }
211
212 void TUIDataModelProxy::setTargetName(const QString &id,
213     const QString &targetName) {
214     if (tuiDataMap.contains(id) == true) {
215         int rowNo = model->rowIndex(tuiDataMap.value(id));
216         QModelIndex index = model->index(rowNo,Target);
217         model->setData(index,targetName);
218     }
219 }
220
221 void TUIDataModelProxy::setCancelButtonText(const QString& id,
222     const QString& text) {
223     if (tuiDataMap.contains(id) == true) {
224         int rowNo = model->rowIndex(tuiDataMap.value(id));
225         QModelIndex index = model->index(rowNo,CancelText);
226         model->setData(index,text);
227     }
228 }
229
230 void TUIDataModelProxy::setTransferTypeTitle(const QString& id,
231     const QString& title) {
232     if (tuiDataMap.contains(id) == true) {
233         int rowNo = model->rowIndex(tuiDataMap.value(id));
234         QModelIndex index = model->index(rowNo,TransferTitle);
235         model->setData(index,title);
236     }
237 }
238
239 void TUIDataModelProxy::setImageFromFile(const QString& id, const QString&
240         filePath) {
241     if (tuiDataMap.contains(id) == true) {
242         int rowNo = model->rowIndex(tuiDataMap.value(id));
243         QModelIndex index = model->index(rowNo,TransferImage);
244         model->setData(index,filePath);
245     }
246 }
247
248 /******************************State changes **********************************/
249 void TUIDataModelProxy::started(const QString &id, double done) {
250     if (tuiDataMap.contains(id) == true) {
251         int rowNo = model->rowIndex(tuiDataMap.value(id));
252         QModelIndex index = model->index(rowNo,Active);
253         TUIData *tuiData = data(index);
254         if(tuiData != 0) {
255             tuiData->status = TransferStatusActive;
256             tuiData->progressData = done;
257             tuiData->message.clear();
258             setModelData(index, tuiData);
259         }
260     }
261 }
262
263 void TUIDataModelProxy::pending(const QString &id, const QString &message) {
264     if (tuiDataMap.contains(id) == true) {
265         int rowNo = model->rowIndex(tuiDataMap.value(id));
266         QModelIndex index = model->index(rowNo,Inactive);
267         TUIData *tuiData = data(index);
268         if(tuiData != 0) {
269             tuiData->status = TransferStatusInactive;
270             tuiData->message = message;
271             setModelData(index, tuiData);
272         }
273     }
274 }
275
276 void TUIDataModelProxy::paused(const QString &id) {
277     if (tuiDataMap.contains(id) == true) {
278         int rowNo = model->rowIndex(tuiDataMap.value(id));
279         QModelIndex index = model->index(rowNo,Paused);
280         TUIData *tuiData = data(index);
281         if(tuiData != 0) {
282             tuiData->status = TransferStatusPaused;
283             setModelData(index, tuiData);
284         }
285     }
286 }
287
288 void TUIDataModelProxy::resumed(const QString &id) {
289     if (tuiDataMap.contains(id) == true) {
290         int rowNo = model->rowIndex(tuiDataMap.value(id));
291         QModelIndex index = model->index(rowNo,Resumed);
292         TUIData *tuiData = data(index);
293         if(tuiData != 0) {
294             tuiData->status = TransferStatusResume;
295             tuiData->message.clear();
296             setModelData(index, tuiData);
297         }
298     }
299 }
300
301 void TUIDataModelProxy::markError(const QString &id, const QString &headerMsg,
302     const QString &detailMsg, bool canRepair, const QString &actionName) {
303     if (tuiDataMap.contains(id) == true) {
304         int rowNo = model->rowIndex(tuiDataMap.value(id));
305         QModelIndex index = model->index(rowNo,Error);
306         TUIData *tuiData = data(index);
307         if(tuiData != 0) {
308             tuiData->status = TransferStatusError;
309             tuiData->headerMsg = headerMsg;
310             tuiData->detailMsg = detailMsg;
311             tuiData->actionName = actionName;
312             tuiData->canRepair = canRepair;
313             tuiData->message.clear();
314             setModelData(index, tuiData);
315         }
316     }
317 }
318
319 void TUIDataModelProxy::cancelled(const QString &id) {
320     if (tuiDataMap.contains(id) == true) {
321         int rowNo = model->rowIndex(tuiDataMap.value(id));
322         QModelIndex index = model->index(rowNo,Canceled);
323         TUIData *tuiData = data(index);
324         if(tuiData != 0) {
325             tuiData->status = TransferStatusCanceled;
326             setModelData(index, tuiData);
327         }
328     }
329 }
330
331 void TUIDataModelProxy::done(const QString &id, const QString& resultUri) {
332     if (tuiDataMap.contains(id) == true) {
333         int rowNo = model->rowIndex(tuiDataMap.value(id));
334         QModelIndex index = model->index(rowNo,Done);
335         TUIData *tuiData = data(index);
336         if(tuiData != 0) {
337             tuiData->status = TransferStatusDone;
338             tuiData->resultUri = resultUri;
339             tuiData->completedTime = QDateTime::currentDateTime();
340             tuiData->message.clear();
341             setModelData(index, tuiData);
342         }
343     }
344 }
345
346 void TUIDataModelProxy::cleanUpTransfer(const QString &id) {
347     if (tuiDataMap.contains(id) == true) {
348         int rowNo = model->rowIndex(tuiDataMap.value(id));
349         QModelIndex index = model->index(rowNo,CleanUp);
350         TUIData *tuiData = data(index);
351         if(tuiData != 0) {
352             tuiData->status = TransferStatusDone;
353             tuiData->message.clear();
354             setModelData(index, tuiData);
355         }
356     }
357 }
358
359 void TUIDataModelProxy::waitToCancelled(const QString& id) {
360     if (tuiDataMap.contains(id) == true) {
361         int rowNo = model->rowIndex(tuiDataMap.value(id));
362         QModelIndex index = model->index(rowNo,Cancel);
363         TUIData *tuiData = data(index);
364         if(tuiData != 0) {
365             if( tuiData->status != TransferStatusError) {
366                 tuiData->status = TransferStatusCancel;
367                 setModelData(index, tuiData);
368             }
369         }
370     }
371 }
372
373 QString TUIDataModelProxy::transferId(const TUIData* data) const {
374     QString retString = tuiDataMap.key(data);
375     return retString;
376 }
377
378 bool TUIDataModelProxy::transferPresent(const QString& id) {
379     bool retVal = false;
380     if(tuiDataMap.contains(id)) {
381         retVal = true;
382     }
383     return retVal;
384 }
385
386 const TUIData * TUIDataModelProxy::tuiData(const QString& id) const {
387     const TUIData *data = 0;
388     if (tuiDataMap.contains(id)) {
389         data = tuiDataMap.value(id);
390     }
391     return data;
392 }
393
394 TUIData* TUIDataModelProxy::data(const QModelIndex& index) {
395     TUIData *tuiData = 0;
396     QMap<int, QVariant> mapVariant = model->itemData(index);
397     QVariant dataVariant = mapVariant.value(Qt::EditRole);
398     if(dataVariant.isValid()) {
399         tuiData = dataVariant.value<TUIData*>();
400     }
401     return tuiData;
402 }
403
404 void TUIDataModelProxy::getTransfersCount(int& activeCount ,
405     int& inactiveCount, int& errorCount) {
406     activeCount = 0;
407     inactiveCount = 0;
408     errorCount = 0;
409     TransferStatus status;
410     QMap<QString, const TUIData*>::const_iterator iter
411                 = tuiDataMap.constBegin();
412     while (iter != tuiDataMap.constEnd()) {
413
414         status = iter.value()->status;
415         //error count
416         if(TransferStatusError==status) {
417                 ++errorCount;
418         }
419         //inactive count
420         else if((TransferStatusInactive==status)
421             ||(TransferStatusPaused==status)) {
422                 ++inactiveCount;
423         }
424         //active count
425         else if((TransferStatusActive==status)
426             || (TransferStatusResume==status)) {
427                 ++activeCount;
428         }
429         ++iter;
430     }
431 }
432
433 void TUIDataModelProxy::getTransfersCount(int& activeCount, int& inactiveCount,
434     int& errorCount, int& completedCount) {
435     activeCount = 0;
436     inactiveCount = 0;
437     errorCount = 0;
438     completedCount = 0;
439     TransferStatus status;
440     QMap<QString, const TUIData*>::const_iterator iter
441                 = tuiDataMap.constBegin();
442     while (iter != tuiDataMap.constEnd()) {
443
444         status = iter.value()->status;
445         //error count
446         if(TransferStatusError==status) {
447             ++errorCount;
448         } else if((TransferStatusInactive==status) //inactive count
449             ||(TransferStatusPaused==status)) {
450             ++inactiveCount;
451         } else if((TransferStatusActive==status) //active count
452             || (TransferStatusResume==status)) {
453             ++activeCount;
454         } else if(TransferStatusDone==status) {
455             ++completedCount;            
456         }
457         ++iter;
458     }    
459 }
460
461 int TUIDataModelProxy::completedCount() const {
462     int completedTransfersCount = 0;
463     TransferStatus status;
464     QMap<QString, const TUIData*>::const_iterator iter
465                 = tuiDataMap.constBegin();
466     while (iter != tuiDataMap.constEnd()) {
467         status = iter.value()->status;
468         if(TransferStatusDone==status) {
469             ++completedTransfersCount;            
470         }
471         ++iter;
472     }
473     return completedTransfersCount;
474 }
475
476 void TUIDataModelProxy::clearCompletedTransfers() {
477     QMap<QString, const TUIData*>::const_iterator iter
478                 = tuiDataMap.constBegin();
479     TransferStatus status;
480     while (iter != tuiDataMap.constEnd()) {    
481         status = iter.value()->status;
482         if(TransferStatusDone==status) {
483             removeTransfer(iter.key());          
484         }
485         ++iter;
486     }
487 }
488
489 void TUIDataModelProxy::addTransfer(const QString& id, QSharedPointer<TUIData> data) {
490     int rowNo = model->rowCount(QModelIndex());
491     model->insertRows(rowNo,1);
492     QModelIndex index = model->index(rowNo,Init);
493     QMap<int, QVariant> mapVariant = model->itemData(index);
494     QVariant variantData = mapVariant.value(Qt::EditRole);
495     TUIData *tuiData = variantData.value<TUIData*>();
496     if(tuiData != 0) {
497         tuiData->name = data->name;
498         tuiData->targetName = data->targetName;
499         tuiData->bytes = data->bytes;
500         tuiData->status = TransferStatusDone;
501         tuiData->message = QString();
502         tuiData->method = data->method;
503         tuiData->thumbnailFile = data->thumbnailFile;
504         tuiData->thumbnailMimeType = data->thumbnailMimeType;
505         tuiData->completedTime = data->completedTime;
506         tuiData->fileTypeIcon = data->fileTypeIcon;
507         tuiData->resultUri = data->resultUri;
508         tuiData->startTime = data->startTime;
509         QVariant variantData = qVariantFromValue(tuiData);
510         QMap<int,QVariant> rolesVariant;
511         rolesVariant.insert(Qt::EditRole, variantData);
512         model->setItemData(index,rolesVariant);
513         tuiDataMap.insert(id, tuiData);
514     }
515     data.clear();
516     QModelIndex newTransferAddedIndex = model->index(rowNo,NewTransferAdded);
517     model->setData(newTransferAddedIndex,QVariant());
518 }
519
520 void TUIDataModelProxy::dateSettingsChanged() {
521     model->clearCompletedMessages();
522 }
523
524
525 int TUIDataModelProxy::count() const {
526     return tuiDataMap.count();
527 }
528
529 void TUIDataModelProxy::setModelData(const QModelIndex& index, TUIData* data) {
530     QVariant variantData = qVariantFromValue(data);
531     QMap<int,QVariant> rolesVariant;
532     rolesVariant.insert(Qt::EditRole, variantData);
533     model->setItemData(index,rolesVariant);
534 }