|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 #include "afentry.h" |
|
18 #include <s32mem.h> |
|
19 |
|
20 // ----------------------------------------------------------------------------- |
|
21 /** |
|
22 * Two-phase constructor. Create and initialize instance |
|
23 * @return entry instance |
|
24 */ |
|
25 CAfEntry* CAfEntry::NewL() |
|
26 { |
|
27 CAfEntry *self = CAfEntry::NewLC(); |
|
28 CleanupStack::Pop(self); |
|
29 return self; |
|
30 } |
|
31 |
|
32 // ----------------------------------------------------------------------------- |
|
33 /** |
|
34 * Two-phase constructor. Create, initialize and push instance into cleanup stack |
|
35 * @return entry instance |
|
36 */ |
|
37 CAfEntry* CAfEntry::NewLC() |
|
38 { |
|
39 CAfEntry *self = new (ELeave)CAfEntry(); |
|
40 CleanupStack::PushL(self); |
|
41 return self; |
|
42 } |
|
43 |
|
44 // ----------------------------------------------------------------------------- |
|
45 /** |
|
46 * Two-phase constructor. Create and initialize instance |
|
47 * @param flags - entry flags |
|
48 * @param applicationId - application unique identifier |
|
49 * @param activityId - activity unique identifier |
|
50 * @param imgSrc - thumbanail source |
|
51 * @param privateData - privated application data |
|
52 * @param publicData - public activity data |
|
53 * @return entry instance |
|
54 */ |
|
55 CAfEntry* CAfEntry::NewL(TInt flags, |
|
56 TInt applicationId, |
|
57 const TDesC &activityId, |
|
58 const TDesC &imgSrc, |
|
59 const TDesC8 &privateData, |
|
60 const TDesC8 &publicData) |
|
61 { |
|
62 CAfEntry* self = CAfEntry::NewLC(flags, |
|
63 applicationId, |
|
64 activityId, |
|
65 imgSrc, |
|
66 privateData, |
|
67 publicData); |
|
68 CleanupStack::Pop(self); |
|
69 return self; |
|
70 } |
|
71 |
|
72 // ----------------------------------------------------------------------------- |
|
73 /** |
|
74 * Two-phase constructor. Create, initialize and push instance into cleanup stack |
|
75 * @param flags - entry flags |
|
76 * @param applicationId - application unique identifier |
|
77 * @param activityId - activity unique identifier |
|
78 * @param imgSrc - thumbanail source |
|
79 * @param privateData - privated application data |
|
80 * @param publicData - public activity data |
|
81 * @return entry instance |
|
82 */ |
|
83 CAfEntry* CAfEntry::NewLC(TInt flags, |
|
84 TInt applicationId, |
|
85 const TDesC &activityId, |
|
86 const TDesC &imgSrc, |
|
87 const TDesC8 &privateData, |
|
88 const TDesC8 &publicData) |
|
89 { |
|
90 CAfEntry *self = CAfEntry::NewLC(); |
|
91 self->ConstructL(flags, |
|
92 applicationId, |
|
93 activityId, |
|
94 imgSrc, |
|
95 privateData, |
|
96 publicData); |
|
97 return self; |
|
98 } |
|
99 |
|
100 // ----------------------------------------------------------------------------- |
|
101 CAfEntry* CAfEntry::NewLC(const RMessage2& msg, int offset) |
|
102 { |
|
103 CAfEntry* self = CAfEntry::NewLC(); |
|
104 RBuf8 serializedEntry; |
|
105 CleanupClosePushL(serializedEntry); |
|
106 ReallocL(serializedEntry, msg.GetDesMaxLength(offset)); |
|
107 msg.ReadL(offset, serializedEntry); |
|
108 RDesReadStream entryReader(serializedEntry); |
|
109 CleanupClosePushL(entryReader); |
|
110 entryReader >> (*self); |
|
111 CleanupStack::PopAndDestroy(&entryReader); |
|
112 CleanupStack::PopAndDestroy(&serializedEntry); |
|
113 return self; |
|
114 } |
|
115 // ----------------------------------------------------------------------------- |
|
116 /** |
|
117 * First phase constructor |
|
118 */ |
|
119 CAfEntry::CAfEntry() |
|
120 { |
|
121 } |
|
122 |
|
123 // ----------------------------------------------------------------------------- |
|
124 /** |
|
125 * Second phase constructor. Initialize instance |
|
126 * @param flags - entry flags |
|
127 * @param applicationId - application unique identifier |
|
128 * @param activityId - activity unique identifier |
|
129 * @param imgSrc - thumbanail source |
|
130 * @param privateData - privated application data |
|
131 * @param publicData - public activity data |
|
132 */ |
|
133 void CAfEntry::ConstructL(TInt flags, |
|
134 TInt applicationId, |
|
135 const TDesC &activityId, |
|
136 const TDesC &imgSrc, |
|
137 const TDesC8 &privateData, |
|
138 const TDesC8 &publicData) |
|
139 { |
|
140 mFlags = flags; |
|
141 mAppId = applicationId; |
|
142 CopyL(mActivityId, activityId); |
|
143 CopyL(mImgSrc, imgSrc); |
|
144 CopyL(mPrivateData, privateData); |
|
145 CopyL(mPublicData, publicData); |
|
146 } |
|
147 |
|
148 // ----------------------------------------------------------------------------- |
|
149 /** |
|
150 * Destructor. Release allocated resources |
|
151 */ |
|
152 CAfEntry::~CAfEntry() |
|
153 { |
|
154 mActivityId.Close(); |
|
155 mPrivateData.Close(); |
|
156 mPublicData.Close(); |
|
157 mImgSrc.Close(); |
|
158 } |
|
159 |
|
160 // ----------------------------------------------------------------------------- |
|
161 /** |
|
162 * Provide size of serialized entry |
|
163 * @return size of serialized entry instance |
|
164 */ |
|
165 TInt CAfEntry::Size() const |
|
166 { |
|
167 return (sizeof(TInt) * 3) + //flags + appId + actId size info |
|
168 mActivityId.Size() + //actId content size |
|
169 DataSize(); //data size |
|
170 |
|
171 } |
|
172 |
|
173 // ----------------------------------------------------------------------------- |
|
174 /** |
|
175 * Provide size of serialized entry |
|
176 * @return size of serialized entry instance |
|
177 */ |
|
178 TInt CAfEntry::DataSize() const |
|
179 { |
|
180 return (sizeof(TInt) * 3) + //privData size info + pubData size info + imgSrc size info |
|
181 mImgSrc.Size() + //imgSize content size |
|
182 mPrivateData.Size() + //privData content size |
|
183 mPublicData.Size(); //pubData content size |
|
184 } |
|
185 // ----------------------------------------------------------------------------- |
|
186 /** |
|
187 * Serialize entry content into output stream. |
|
188 * @param stream - output stream |
|
189 */ |
|
190 void CAfEntry::ExternalizeL(RWriteStream &stream) const |
|
191 { |
|
192 stream.WriteInt32L(mFlags); |
|
193 stream.WriteInt32L(mAppId); |
|
194 ExternalizeL(stream, mActivityId); |
|
195 ExternalizeDataOnlyL(stream); |
|
196 } |
|
197 |
|
198 // ----------------------------------------------------------------------------- |
|
199 /** |
|
200 * Deserialize entry content from input stream |
|
201 * @param stream - input stream |
|
202 */ |
|
203 void CAfEntry::InternalizeL(RReadStream &stream) |
|
204 { |
|
205 mFlags = stream.ReadInt32L(); |
|
206 mAppId = stream.ReadInt32L(); |
|
207 InternalizeL(mActivityId, stream); |
|
208 InternalizeDataOnlyL(stream); |
|
209 } |
|
210 |
|
211 // ----------------------------------------------------------------------------- |
|
212 /** |
|
213 * Serialize entry content into output stream. |
|
214 * @param stream - output stream |
|
215 */ |
|
216 void CAfEntry::ExternalizeDataOnlyL(RWriteStream &stream) const |
|
217 { |
|
218 ExternalizeL(stream, mImgSrc); |
|
219 ExternalizeL(stream, mPrivateData); |
|
220 ExternalizeL(stream, mPublicData); |
|
221 } |
|
222 |
|
223 // ----------------------------------------------------------------------------- |
|
224 /** |
|
225 * Deserialize entry content from input stream |
|
226 * @param stream - input stream |
|
227 */ |
|
228 void CAfEntry::InternalizeDataOnlyL(RReadStream &stream) |
|
229 { |
|
230 |
|
231 InternalizeL(mImgSrc, stream); |
|
232 InternalizeL(mPrivateData, stream); |
|
233 InternalizeL(mPublicData, stream); |
|
234 |
|
235 } |
|
236 |
|
237 // ----------------------------------------------------------------------------- |
|
238 /** |
|
239 * Provide access to activity flags |
|
240 * @return activity flags |
|
241 */ |
|
242 TInt CAfEntry::Flags() const |
|
243 { |
|
244 return mFlags; |
|
245 } |
|
246 |
|
247 // ----------------------------------------------------------------------------- |
|
248 /** |
|
249 * Provide access to activity identifier. |
|
250 * @return activity identifier |
|
251 */ |
|
252 TInt CAfEntry::ApplicationId() const |
|
253 { |
|
254 return mAppId; |
|
255 } |
|
256 |
|
257 // ----------------------------------------------------------------------------- |
|
258 /** |
|
259 * Provide access to activity identifier. |
|
260 * @return activity identifier |
|
261 */ |
|
262 const TDesC& CAfEntry::ActivityId() const |
|
263 { |
|
264 return mActivityId; |
|
265 } |
|
266 |
|
267 // ----------------------------------------------------------------------------- |
|
268 /** |
|
269 * Provide access to activity data. |
|
270 * @param rights - type of requested data |
|
271 * @return activity data |
|
272 */ |
|
273 const TDesC8& CAfEntry::Data(CAfEntry::AccessRights rights) const |
|
274 { |
|
275 return Private == rights ? mPrivateData : mPublicData; |
|
276 } |
|
277 |
|
278 // ----------------------------------------------------------------------------- |
|
279 /** |
|
280 * Provide access to activity data. |
|
281 * @param rights - type of requested data |
|
282 * @return activity data |
|
283 */ |
|
284 void CAfEntry::SetDataL(const TDesC8& src, CAfEntry::AccessRights rights) |
|
285 { |
|
286 CopyL(Private == rights ? mPrivateData : mPublicData, src); |
|
287 } |
|
288 |
|
289 // ----------------------------------------------------------------------------- |
|
290 /** |
|
291 * Provide access to activity thumbail path |
|
292 * @return path to activity thumbnail |
|
293 */ |
|
294 const TDesC& CAfEntry::ImageSrc() const |
|
295 { |
|
296 return mImgSrc; |
|
297 } |
|
298 |
|
299 // ----------------------------------------------------------------------------- |
|
300 /** |
|
301 * Set new value of image source |
|
302 */ |
|
303 void CAfEntry::SetImageSrcL(const TDesC& src) |
|
304 { |
|
305 CopyL(mImgSrc, src); |
|
306 } |
|
307 |
|
308 // ----------------------------------------------------------------------------- |
|
309 /** |
|
310 * Reallocate blob buffer to requested size |
|
311 * @param dst - destination buffer |
|
312 * @param length - requested length |
|
313 */ |
|
314 void CAfEntry::ReallocL(RBuf8 &dst,TInt length) |
|
315 { |
|
316 if (0 < length) { |
|
317 if (dst.MaxLength() < length) { |
|
318 dst.ReAllocL(length); |
|
319 } |
|
320 } else { |
|
321 dst.Close(); |
|
322 } |
|
323 } |
|
324 |
|
325 // ----------------------------------------------------------------------------- |
|
326 /** |
|
327 * Reallocate text buffer to requested size |
|
328 * @param dst - destination buffer |
|
329 * @param length - requested length |
|
330 */ |
|
331 void CAfEntry::ReallocL(RBuf &dst,TInt length) |
|
332 { |
|
333 if (0 < length) { |
|
334 if (dst.MaxLength() < length) { |
|
335 dst.ReAllocL(length); |
|
336 } |
|
337 } else { |
|
338 dst.Close(); |
|
339 } |
|
340 } |
|
341 // ----------------------------------------------------------------------------- |
|
342 /** |
|
343 * Copy blob content from input stream |
|
344 * @param dst - destination buffer |
|
345 * @param src - source buffer |
|
346 */ |
|
347 void CAfEntry::CopyL(RBuf8 &dst,const TDesC8 &src) |
|
348 { |
|
349 ReallocL(dst, src.Length()); |
|
350 if(0 < src.Length()) { |
|
351 dst.Copy(src); |
|
352 } |
|
353 } |
|
354 |
|
355 // ----------------------------------------------------------------------------- |
|
356 /** |
|
357 * Copy text content from input buffer |
|
358 * @param dst - destination buffer |
|
359 * @param src - source buffer |
|
360 */ |
|
361 void CAfEntry::CopyL(RBuf &dst,const TDesC &src) |
|
362 { |
|
363 ReallocL(dst, src.Length()); |
|
364 if(0 < src.Length()) { |
|
365 dst.Copy(src); |
|
366 } |
|
367 } |
|
368 |
|
369 // ----------------------------------------------------------------------------- |
|
370 /** |
|
371 * Deserialize blob content from input stream |
|
372 * @param dst - destination buffer |
|
373 * @param src - input stream |
|
374 */ |
|
375 void CAfEntry::InternalizeL(RBuf8 &dst, RReadStream &src) |
|
376 { |
|
377 const TInt length(src.ReadInt32L()); |
|
378 ReallocL(dst, length); |
|
379 if (0 < length) { |
|
380 src.ReadL(dst, length); |
|
381 } |
|
382 } |
|
383 |
|
384 // ----------------------------------------------------------------------------- |
|
385 /** |
|
386 * Deserialize text content from input stream |
|
387 * @param dst - destination buffer |
|
388 * @param src - input stream |
|
389 */ |
|
390 void CAfEntry::InternalizeL(RBuf &dst, RReadStream &src) |
|
391 { |
|
392 const TInt length(src.ReadInt32L()); |
|
393 ReallocL(dst, length); |
|
394 if (0 < length) { |
|
395 src.ReadL(dst, length); |
|
396 } |
|
397 } |
|
398 |
|
399 // ----------------------------------------------------------------------------- |
|
400 /** |
|
401 * Serialize blob content into output stream |
|
402 * @param dst - destination stream |
|
403 * @param src - input buffer |
|
404 */ |
|
405 void CAfEntry::ExternalizeL(RWriteStream &dst,const TDesC8 & src) |
|
406 { |
|
407 dst.WriteInt32L(src.Length()); |
|
408 if (src.Length()) { |
|
409 dst.WriteL(src, src.Length()); |
|
410 } |
|
411 } |
|
412 |
|
413 // ----------------------------------------------------------------------------- |
|
414 /** |
|
415 * Serialize text content into output stream |
|
416 * @param dst - destination stream |
|
417 * @param src - input buffer |
|
418 */ |
|
419 void CAfEntry::ExternalizeL(RWriteStream &dst,const TDesC& src) |
|
420 { |
|
421 dst.WriteInt32L(src.Length()); |
|
422 if (src.Length()) { |
|
423 dst.WriteL(src, src.Length()); |
|
424 } |
|
425 } |
|
426 |
|
427 // ----------------------------------------------------------------------------- |
|
428 RPointerArray<CAfEntry>& operator <<(RPointerArray<CAfEntry>& dst, const TDesC8 &src) |
|
429 { |
|
430 dst.ResetAndDestroy(); |
|
431 RDesReadStream srcStream(src); |
|
432 CleanupClosePushL(srcStream); |
|
433 int numOfItems(srcStream.ReadInt32L()); |
|
434 for (int i(0); i < numOfItems; ++i) { |
|
435 CAfEntry *entry = CAfEntry::NewLC(); |
|
436 srcStream >> (*entry); |
|
437 dst.AppendL(entry); |
|
438 CleanupStack::Pop(entry); |
|
439 } |
|
440 CleanupStack::PopAndDestroy(&srcStream); |
|
441 return dst; |
|
442 } |
|
443 |
|
444 // ----------------------------------------------------------------------------- |
|
445 RBuf8& operator <<(RBuf8 &dst, const RPointerArray<CAfEntry>& src) |
|
446 { |
|
447 int iter(0), |
|
448 requiredSize(sizeof(int)); |
|
449 for(iter =0; iter< src.Count(); ++iter) { |
|
450 requiredSize += src[iter]->Size(); |
|
451 } |
|
452 CAfEntry::ReallocL(dst, requiredSize); |
|
453 RDesWriteStream dstStream(dst); |
|
454 CleanupClosePushL(dstStream); |
|
455 dstStream.WriteInt32L(src.Count()); |
|
456 for (iter =0; iter < src.Count(); ++iter) { |
|
457 dstStream << *(src[iter]); |
|
458 } |
|
459 CleanupStack::PopAndDestroy(&dstStream); |
|
460 return dst; |
|
461 } |