37 mClient->Subscribe(*this); |
38 mClient->Subscribe(*this); |
38 } |
39 } |
39 |
40 |
40 TsTaskMonitorPrivate::~TsTaskMonitorPrivate() |
41 TsTaskMonitorPrivate::~TsTaskMonitorPrivate() |
41 { |
42 { |
|
43 mUpdateSet.ResetAndDestroy(); |
42 mClient->CancelSubscribe(); |
44 mClient->CancelSubscribe(); |
43 delete mClient; |
45 delete mClient; |
44 } |
46 } |
45 |
47 |
46 |
48 |
47 QList<TsTaskChange> TsTaskMonitorPrivate::changeList(bool fullList) |
49 QList<TsTaskChange> TsTaskMonitorPrivate::changeList(bool fullList) |
48 { |
50 { |
49 QList<TsTaskChange> retVal; |
51 QList<TsTaskChange> retVal; |
50 |
52 QT_TRAP_THROWING(changeListL()); |
51 QT_TRAP_THROWING ( |
|
52 |
|
53 HBufC8 *data = mClient->TasksContentLC(); |
|
54 if (data->Size() == 0) { |
|
55 CleanupStack::PopAndDestroy(data); |
|
56 return retVal; |
|
57 } |
|
58 TPtr8 dataPointer(data->Des()); |
|
59 RDesReadStream dataStream(dataPointer); |
|
60 CleanupClosePushL(dataStream); |
|
61 |
|
62 int count = dataStream.ReadInt32L(); |
|
63 |
|
64 QT_TRYCATCH_LEAVING( |
|
65 QList< QSharedPointer<TsTaskContent> > taskList; |
|
66 QList<TsTaskMonitorHistory> newTaskHistory; |
|
67 for (int iter(0); iter < count; iter++) { |
|
68 QSharedPointer<TsTaskContent> content(new TsTaskContent); |
|
69 TsTaskMonitorHistory newHistoryItem = internalizeContentL(dataStream, content); |
|
70 newHistoryItem.setOffset(iter); |
|
71 newTaskHistory.append(newHistoryItem); |
|
72 taskList.append(content); |
|
73 } |
|
74 if (fullList) { |
|
75 mTaskHistory.clear(); |
|
76 } |
|
77 QList<int> insertsList = findInserts(newTaskHistory); |
|
78 QList<int> deletesList = findDeletes(newTaskHistory); |
|
79 QList<TsTaskMonitorHistory> newMinusInserts; |
|
80 if (insertsList.count() > 0 ) { |
|
81 newMinusInserts = substractInsertsFromNew(insertsList, newTaskHistory); |
|
82 } else { |
|
83 newMinusInserts = newTaskHistory; |
|
84 } |
|
85 QList<TsTaskMonitorHistory> interimList; |
|
86 if (deletesList.count() > 0 ) { |
|
87 retVal.append(getDeletesChangeset(deletesList)); |
|
88 interimList = substractDeletesFromOld(deletesList); |
|
89 } else { |
|
90 interimList = mTaskHistory; |
|
91 } |
|
92 retVal.append(findMovesAndUpdates(newMinusInserts, taskList, interimList)); |
|
93 if (mTaskHistory.isEmpty()) { |
|
94 retVal.append(TsTaskChange(TsTaskChangeInfo(), QSharedPointer<TsTask>())); |
|
95 } |
|
96 retVal.append(getInsertsChangeset(insertsList, taskList)); |
|
97 mTaskHistory = newTaskHistory; |
|
98 )//QT_TRYCATCH_LEAVING |
|
99 CleanupStack::PopAndDestroy(&dataStream); |
|
100 CleanupStack::PopAndDestroy(data); |
|
101 );//QT_TRAP_THROWING |
|
102 |
|
103 return retVal; |
|
104 } |
|
105 |
|
106 TsTaskMonitorHistory TsTaskMonitorPrivate::internalizeContentL(RDesReadStream & dataStream, |
|
107 QSharedPointer<TsTaskContent> &content) |
|
108 { |
|
109 // get name |
|
110 TInt nameLength(dataStream.ReadInt32L()); |
|
111 if (0 < nameLength) { |
|
112 HBufC* name = HBufC::NewLC(dataStream, nameLength); |
|
113 content->mName = XQConversions::s60DescToQString(*name); |
|
114 CleanupStack::PopAndDestroy(name); |
|
115 } |
|
116 TPckgBuf<TTime> updateTime; |
|
117 dataStream.ReadL(updateTime); |
|
118 QDateTime historyTime = dateTimeFromS60(updateTime()); |
|
119 |
53 |
120 // get screenshot |
54 QList< QSharedPointer<CTsClientEntry> > taskList; |
121 TInt screenshotHandle = dataStream.ReadInt32L(); |
55 QList<TsTaskMonitorHistory> newTaskHistory; |
122 CFbsBitmap *screenshot = new (ELeave) CFbsBitmap; |
56 for (int offset(0); 0 < mUpdateSet.Count(); ++offset) { |
123 CleanupStack::PushL(screenshot); |
57 QSharedPointer<CTsClientEntry> content(mUpdateSet[0]); |
124 if (KErrNone == screenshot->Duplicate(screenshotHandle)) { |
58 taskList.append(content); |
125 content->mScreenshot = QPixmap::fromSymbianCFbsBitmap(screenshot); |
59 newTaskHistory.append(TsTaskMonitorHistory(content, offset)); |
126 } |
60 mUpdateSet.Remove(0); |
127 CleanupStack::PopAndDestroy(screenshot); |
61 } |
128 // get key |
62 if (fullList) { |
129 TInt keyLength(dataStream.ReadInt32L()); |
63 mTaskHistory.clear(); |
130 if (0 < keyLength) { |
64 } |
131 HBufC8* key = HBufC8::NewLC(keyLength); |
65 QList<int> insertsList = findInserts(newTaskHistory); |
132 TPtr8 des(key->Des()); |
66 QList<int> deletesList = findDeletes(newTaskHistory); |
133 dataStream.ReadL(des, keyLength); |
67 QList<TsTaskMonitorHistory> newMinusInserts; |
134 content->mKey = XQConversions::s60Desc8ToQByteArray(*key); |
68 if (insertsList.count() > 0 ) { |
135 CleanupStack::PopAndDestroy(key); |
69 newMinusInserts = substractInsertsFromNew(insertsList, newTaskHistory); |
136 } |
70 } else { |
137 // get other values |
71 newMinusInserts = newTaskHistory; |
138 content->mActive = dataStream.ReadInt32L(); |
72 } |
139 content->mClosable = dataStream.ReadInt32L(); |
73 QList<TsTaskMonitorHistory> interimList; |
140 return TsTaskMonitorHistory(content->mKey, historyTime); |
74 if (deletesList.count() > 0 ) { |
|
75 retVal.append(getDeletesChangeset(deletesList)); |
|
76 interimList = substractDeletesFromOld(deletesList); |
|
77 } else { |
|
78 interimList = mTaskHistory; |
|
79 } |
|
80 retVal.append(findMovesAndUpdates(newMinusInserts, taskList, interimList)); |
|
81 if (mTaskHistory.isEmpty()) { |
|
82 retVal.append(TsTaskChange(TsTaskChangeInfo(), QSharedPointer<TsTask>())); |
|
83 } |
|
84 retVal.append(getInsertsChangeset(insertsList, taskList)); |
|
85 mTaskHistory = newTaskHistory; |
|
86 return retVal; |
|
87 } |
|
88 |
|
89 void TsTaskMonitorPrivate::changeListL() |
|
90 { |
|
91 mUpdateSet.ResetAndDestroy(); |
|
92 HBufC8 *data = mClient->TasksContentLC(); |
|
93 if (data->Size() == 0) { |
|
94 User::Leave(KErrCorrupt); |
|
95 } |
|
96 RDesReadStream dataStream; |
|
97 CleanupClosePushL(dataStream); |
|
98 dataStream.Open(*data); |
|
99 const int count(dataStream.ReadInt32L()); |
|
100 for (int offset(0); offset < count; ++offset) { |
|
101 CTsClientEntry* entry = CTsClientEntry::NewLC(dataStream); |
|
102 mUpdateSet.AppendL(entry); |
|
103 CleanupStack::Pop(entry); |
|
104 } |
|
105 CleanupStack::PopAndDestroy(&dataStream); |
|
106 CleanupStack::PopAndDestroy(data); |
141 } |
107 } |
142 |
108 |
143 QDateTime TsTaskMonitorPrivate::dateTimeFromS60(const TTime &s60Time) |
109 QDateTime TsTaskMonitorPrivate::dateTimeFromS60(const TTime &s60Time) |
144 { |
110 { |
145 TTime posixEpoch(_L("19700000:")); |
111 TTime posixEpoch(_L("19700000:")); |
252 workingList.move(previousPos, newPos); |
218 workingList.move(previousPos, newPos); |
253 } |
219 } |
254 // case 2 item has changed |
220 // case 2 item has changed |
255 if (newMinusInserts[newPos].isUpdated(workingList[newPos])) { |
221 if (newMinusInserts[newPos].isUpdated(workingList[newPos])) { |
256 TsTaskChangeInfo updateChange(newPos, newPos); |
222 TsTaskChangeInfo updateChange(newPos, newPos); |
257 int taskListOffset = newMinusInserts[newPos].offset(); |
|
258 retVal.append( TsTaskChange( |
223 retVal.append( TsTaskChange( |
259 updateChange, |
224 updateChange, |
260 QSharedPointer<TsTask>(new TsTask(taskList[taskListOffset], *this)))); |
225 QSharedPointer<TsTask>(new TsTask(taskList[newMinusInserts[newPos].offset()], *this)))); |
261 } |
226 } |
262 } |
227 } |
263 return retVal; |
228 return retVal; |
264 } |
229 } |
265 |
230 |
266 void TsTaskMonitorPrivate::HandleRunningAppChange() |
231 void TsTaskMonitorPrivate::HandleRunningAppChange() |
267 { |
232 { |
268 emit q_ptr->taskListChanged(); |
233 emit q_ptr->taskListChanged(); |
269 } |
234 } |
270 |
235 |
271 void TsTaskMonitorPrivate::openTask(const QByteArray &key) |
236 void TsTaskMonitorPrivate::openTask(const MTsEntry &entry) |
272 { |
237 { |
273 TPtrC8 desC(reinterpret_cast<const TUint8*>(key.constData()), key.length()); |
238 QT_TRAP_THROWING( |
274 mClient->OpenTask(desC); |
239 HBufC8 *dataPtr = keyLC(entry); |
|
240 TPtr8 dataBuf(dataPtr->Des()); |
|
241 mClient->OpenTask(dataBuf); |
|
242 CleanupStack::PopAndDestroy(dataPtr); |
|
243 ) |
|
244 } |
|
245 |
|
246 void TsTaskMonitorPrivate::closeTask(const MTsEntry &entry) |
|
247 { |
|
248 QT_TRAP_THROWING( |
|
249 HBufC8 *dataPtr = keyLC(entry); |
|
250 TPtr8 dataBuf(dataPtr->Des()); |
|
251 mClient->CloseTask(dataBuf); |
|
252 CleanupStack::PopAndDestroy(dataPtr); |
|
253 ) |
|
254 } |
|
255 |
|
256 HBufC8* TsTaskMonitorPrivate::keyLC(const MTsEntry &entry) |
|
257 { |
|
258 HBufC8 *dataPtr = HBufC8::NewLC(TTsEntryKey::Size()); |
|
259 TPtr8 dataBuf(dataPtr->Des()); |
275 |
260 |
276 } |
261 RDesWriteStream dataStream; |
277 |
262 CleanupClosePushL(dataStream); |
278 void TsTaskMonitorPrivate::closeTask(const QByteArray &key) |
263 dataStream.Open(dataBuf); |
279 { |
264 dataStream << entry.Key(); |
280 TPtrC8 desC(reinterpret_cast<const TUint8*>(key.constData()), key.length()); |
265 CleanupStack::PopAndDestroy(&dataStream); |
281 mClient->CloseTask(desC); |
266 |
282 } |
267 return dataPtr; |
|
268 } |