|
1 /* |
|
2 * Copyright (c) 2006 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: Implements the functions to manipulate the Podcast table |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <PCRes.rsg> |
|
21 #include <sqldb.h> |
|
22 |
|
23 #include <mpxmedia.h> |
|
24 #include <mpxmediaarray.h> |
|
25 #include <mpxmediageneraldefs.h> |
|
26 #include <mpxmediamusicdefs.h> |
|
27 #include <mpxmediaaudiodefs.h> |
|
28 #include <mpxmediadrmdefs.h> |
|
29 #include <mpxpodcastdefs.h> |
|
30 #include <mpxlog.h> |
|
31 |
|
32 #include "mpxdbcommondef.h" |
|
33 #include "mpxdbcommonstd.h" |
|
34 #include "mpxresource.h" |
|
35 #include "mpxdbcommonutil.h" |
|
36 #include "mpxdbmanager.h" |
|
37 |
|
38 #include "mpxdbutil.h" |
|
39 #include "mpxpodcastcollectiondbdef.h" |
|
40 #include "mpxpodcastdbpluginqueries.h" |
|
41 #include "mpxdbpodcast.h" |
|
42 |
|
43 //CONSTANTS |
|
44 // UniqueID column in Uris requests |
|
45 const TInt KColUniqueID = 0; |
|
46 // URI column in Uris requests |
|
47 const TInt KColUri = 1; |
|
48 |
|
49 // ============================ MEMBER FUNCTIONS ============================== |
|
50 |
|
51 // ---------------------------------------------------------------------------- |
|
52 // Two-phased constructor. |
|
53 // ---------------------------------------------------------------------------- |
|
54 // |
|
55 CMPXDbPodcast* CMPXDbPodcast::NewL( |
|
56 CMPXDbManager& aDbManager, |
|
57 CMPXResource& aResource, |
|
58 MMPXDbPodcastObserver& aObserver) |
|
59 { |
|
60 MPX_FUNC("CMPXDbPodcast::NewL"); |
|
61 |
|
62 CMPXDbPodcast* self = CMPXDbPodcast::NewLC(aDbManager, aResource, aObserver); |
|
63 CleanupStack::Pop(self); |
|
64 return self; |
|
65 } |
|
66 |
|
67 // ---------------------------------------------------------------------------- |
|
68 // Two-phased constructor. |
|
69 // ---------------------------------------------------------------------------- |
|
70 // |
|
71 CMPXDbPodcast* CMPXDbPodcast::NewLC( |
|
72 CMPXDbManager& aDbManager, |
|
73 CMPXResource& aResource, |
|
74 MMPXDbPodcastObserver& aObserver) |
|
75 { |
|
76 MPX_FUNC("CMPXDbPodcast::NewLC"); |
|
77 |
|
78 CMPXDbPodcast* self = new (ELeave) CMPXDbPodcast(aDbManager, aObserver); |
|
79 CleanupStack::PushL(self); |
|
80 self->ConstructL(aResource); |
|
81 return self; |
|
82 } |
|
83 |
|
84 // ---------------------------------------------------------------------------- |
|
85 // Destructor. |
|
86 // ---------------------------------------------------------------------------- |
|
87 // |
|
88 CMPXDbPodcast::~CMPXDbPodcast() |
|
89 { |
|
90 MPX_FUNC("CMPXDbPodcast::~CMPXDbPodcast"); |
|
91 delete iExtensionsDrm; |
|
92 } |
|
93 |
|
94 // ---------------------------------------------------------------------------- |
|
95 // Constructor |
|
96 // ---------------------------------------------------------------------------- |
|
97 // |
|
98 CMPXDbPodcast::CMPXDbPodcast( |
|
99 CMPXDbManager& aDbManager, |
|
100 MMPXDbPodcastObserver& aObserver) : |
|
101 CMPXDbTable(aDbManager), |
|
102 iObserver(aObserver) |
|
103 { |
|
104 MPX_FUNC("CMPXDbPodcast::CMPXDbPodcast"); |
|
105 } |
|
106 |
|
107 // ---------------------------------------------------------------------------- |
|
108 // Symbian 2nd phase constructor can leave. |
|
109 // ---------------------------------------------------------------------------- |
|
110 // |
|
111 void CMPXDbPodcast::ConstructL( |
|
112 CMPXResource& aResource) |
|
113 { |
|
114 MPX_FUNC("CMPXDbPodcast::ConstructL"); |
|
115 |
|
116 BaseConstructL(); |
|
117 iExtensionsDrm = aResource.ReadDesCArrayL(R_MC_FILE_EXTENSIONS_DRM); |
|
118 } |
|
119 |
|
120 // ---------------------------------------------------------------------------- |
|
121 // Add a episode to the podcast table |
|
122 // ---------------------------------------------------------------------------- |
|
123 // |
|
124 TUint32 CMPXDbPodcast::AddEpisodeL( |
|
125 const CMPXMedia& aMedia, |
|
126 TInt aDrive) |
|
127 { |
|
128 MPX_FUNC("CMPXDbPodcast::AddEpisodeL"); |
|
129 |
|
130 if (!aMedia.IsSupported(KMPXMediaGeneralUri)) |
|
131 { |
|
132 User::Leave(KErrArgument); |
|
133 } |
|
134 |
|
135 TUint32 episodeId(MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXCollection, |
|
136 aMedia.ValueText(KMPXMediaGeneralUri), EFalse)); |
|
137 if ( EpisodeExistsL( episodeId )) |
|
138 { |
|
139 // Return deleted file paths to caller |
|
140 CDesCArray* fp = new( ELeave ) CDesCArrayFlat( 1 ); |
|
141 CleanupStack::PushL( fp ); |
|
142 |
|
143 // a list of change event messages a result of the item being removed |
|
144 CMPXMessageArray* itemChangedMessages = CMPXMediaArray::NewL(); |
|
145 CleanupStack::PushL( itemChangedMessages ); |
|
146 |
|
147 //Isadd is passed as true as its called from AddEpisodeL |
|
148 //IsAdd true means dont decrement the episode count from tables like |
|
149 //Artist Genere, Album, and Composer , which is not needed when |
|
150 //DeleteEpisodeL is called as part of Add operation |
|
151 TRAPD( err, DeleteEpisodeL( episodeId, *fp, *itemChangedMessages, ETrue, ETrue ) ); |
|
152 |
|
153 if ( err != KErrNone ) // EpisodeExistL has found a record from a previously deleted episode, cleanup it now |
|
154 { |
|
155 iDbManager.ExecuteQueryL( aDrive, KQueryPodcastDelete(), episodeId ); |
|
156 } |
|
157 |
|
158 CleanupStack::PopAndDestroy( itemChangedMessages ); |
|
159 CleanupStack::PopAndDestroy( fp ); |
|
160 } |
|
161 // add the song |
|
162 DoAddEpisodeL(episodeId, aMedia, aDrive, NULL); |
|
163 |
|
164 |
|
165 |
|
166 return episodeId; |
|
167 } |
|
168 |
|
169 // ---------------------------------------------------------------------------- |
|
170 // CMPXDbPodcast::UpdateEpisodeL |
|
171 // ---------------------------------------------------------------------------- |
|
172 // |
|
173 CMPXDbActiveTask::TChangeVisibility CMPXDbPodcast::UpdateEpisodeL( |
|
174 TUint32 aEpisodeId, |
|
175 const CMPXMedia& aMedia, |
|
176 CMPXMessageArray& aItemChangedMessages) |
|
177 { |
|
178 MPX_FUNC("CMPXDbPodcast::UpdateEpisodeL"); |
|
179 return DoUpdateEpisodeL(aEpisodeId, aMedia, &aItemChangedMessages); |
|
180 } |
|
181 |
|
182 // ---------------------------------------------------------------------------- |
|
183 // CMPXDbPodcast::CleanupL |
|
184 // ---------------------------------------------------------------------------- |
|
185 // |
|
186 void CMPXDbPodcast::CleanupL() |
|
187 { |
|
188 MPX_FUNC("CMPXDbPodcast::CleanupL"); |
|
189 iDbManager.ExecuteQueryL(KDbManagerAllDrives, KQueryPodcastCleanup); |
|
190 } |
|
191 |
|
192 // ---------------------------------------------------------------------------- |
|
193 // Remove a episode from the podcast table |
|
194 // ---------------------------------------------------------------------------- |
|
195 // |
|
196 void CMPXDbPodcast::DeleteEpisodeL( |
|
197 TUint32 aEpisodeId, |
|
198 CDesCArray& aUriArray, |
|
199 CMPXMessageArray& aItemChangedMessages, TBool IsAdd, |
|
200 TBool aDeleteRecord) |
|
201 { |
|
202 MPX_FUNC("CMPXDbPodcast::DeleteEpisodeL"); |
|
203 |
|
204 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetEpisode, |
|
205 aEpisodeId)); |
|
206 CleanupClosePushL(recordset); |
|
207 if (recordset.Next() != KSqlAtRow) |
|
208 { |
|
209 User::Leave(KErrNotFound); |
|
210 } |
|
211 DoDeleteEpisodeL(recordset, aUriArray, aItemChangedMessages, IsAdd, aDeleteRecord); |
|
212 CleanupStack::PopAndDestroy(&recordset); |
|
213 } |
|
214 |
|
215 // ---------------------------------------------------------------------------- |
|
216 // CMPXDbPodcast::DeleteCategoryL |
|
217 // ---------------------------------------------------------------------------- |
|
218 // |
|
219 void CMPXDbPodcast::DeleteCategoryL( |
|
220 TMPXGeneralCategory aCategory, |
|
221 TUint32 aCategoryId, |
|
222 CDesCArray& aUriArray, |
|
223 CMPXMessageArray& aItemChangedMessages) |
|
224 { |
|
225 MPX_FUNC("CMPXDbPodcast::DeleteCategoryL"); |
|
226 |
|
227 TPtrC ptr(MPXDbUtil::PodcastFieldNameForCategoryL(aCategory)); |
|
228 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastCategory, |
|
229 &ptr, aCategoryId)); |
|
230 CleanupClosePushL(recordset); |
|
231 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
232 CleanupStack::PopAndDestroy(&recordset); |
|
233 } |
|
234 |
|
235 // ---------------------------------------------------------------------------- |
|
236 // Remove all podcast episodes from the podcast table that are published today |
|
237 // ---------------------------------------------------------------------------- |
|
238 // |
|
239 void CMPXDbPodcast::DeleteTodayEpisodesL( |
|
240 CDesCArray& aUriArray, |
|
241 CMPXMessageArray& aItemChangedMessages) |
|
242 { |
|
243 MPX_FUNC("CMPXDbPodcast::DeleteTodayEpisodesL"); |
|
244 |
|
245 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
246 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastToday, now, now)); |
|
247 CleanupClosePushL(recordset); |
|
248 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
249 CleanupStack::PopAndDestroy(&recordset); |
|
250 CleanupStack::PopAndDestroy(now); |
|
251 } |
|
252 |
|
253 // ---------------------------------------------------------------------------- |
|
254 // Remove all podcast episodes from the podcast table that are published yesterday |
|
255 // ---------------------------------------------------------------------------- |
|
256 // |
|
257 void CMPXDbPodcast::DeleteYesterdayEpisodesL( |
|
258 CDesCArray& aUriArray, |
|
259 CMPXMessageArray& aItemChangedMessages) |
|
260 { |
|
261 MPX_FUNC("CMPXDbPodcast::DeleteYesterdayEpisodesL"); |
|
262 |
|
263 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
264 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastYesterday, now, now)); |
|
265 CleanupClosePushL(recordset); |
|
266 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
267 CleanupStack::PopAndDestroy(&recordset); |
|
268 CleanupStack::PopAndDestroy(now); |
|
269 } |
|
270 |
|
271 // ---------------------------------------------------------------------------- |
|
272 // Remove all podcast episodes from the podcast table that are published this week |
|
273 // ---------------------------------------------------------------------------- |
|
274 // |
|
275 void CMPXDbPodcast::DeleteThisWeekEpisodesL( |
|
276 CDesCArray& aUriArray, |
|
277 CMPXMessageArray& aItemChangedMessages) |
|
278 { |
|
279 MPX_FUNC("CMPXDbPodcast::DeleteThisWeekEpisodesL"); |
|
280 |
|
281 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
282 dayNo++; // shifted by 1 day to get correct results |
|
283 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
284 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween, |
|
285 now, dayNo, now, 1)); |
|
286 CleanupClosePushL(recordset); |
|
287 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
288 CleanupStack::PopAndDestroy(&recordset); |
|
289 CleanupStack::PopAndDestroy(now); |
|
290 } |
|
291 |
|
292 // ---------------------------------------------------------------------------- |
|
293 // Remove all podcast episodes from the podcast table that are published last week |
|
294 // ---------------------------------------------------------------------------- |
|
295 // |
|
296 void CMPXDbPodcast::DeleteLastWeekEpisodesL( |
|
297 CDesCArray& aUriArray, |
|
298 CMPXMessageArray& aItemChangedMessages) |
|
299 { |
|
300 MPX_FUNC("CMPXDbPodcast::DeleteLastWeekEpisodesL"); |
|
301 |
|
302 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
303 dayNo++; // shifted by 1 day to get correct results |
|
304 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
305 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween, |
|
306 now, dayNo + 7, now, dayNo)); |
|
307 CleanupClosePushL(recordset); |
|
308 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
309 CleanupStack::PopAndDestroy(&recordset); |
|
310 CleanupStack::PopAndDestroy(now); |
|
311 } |
|
312 |
|
313 // ---------------------------------------------------------------------------- |
|
314 // Remove all podcast episodes from the podcast table that are published 2 weeks ago |
|
315 // ---------------------------------------------------------------------------- |
|
316 // |
|
317 void CMPXDbPodcast::Delete2WeeksAgoEpisodesL( |
|
318 CDesCArray& aUriArray, |
|
319 CMPXMessageArray& aItemChangedMessages) |
|
320 { |
|
321 MPX_FUNC("CMPXDbPodcast::Delete2WeeksAgoEpisodesL"); |
|
322 |
|
323 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
324 dayNo++; // shifted by 1 day to get correct results |
|
325 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
326 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween, |
|
327 now, dayNo + 14, now, dayNo + 7)); |
|
328 CleanupClosePushL(recordset); |
|
329 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
330 CleanupStack::PopAndDestroy(&recordset); |
|
331 CleanupStack::PopAndDestroy(now); |
|
332 } |
|
333 |
|
334 // ---------------------------------------------------------------------------- |
|
335 // Remove all podcast episodes from the podcast table that are published 3 weeks ago |
|
336 // ---------------------------------------------------------------------------- |
|
337 // |
|
338 void CMPXDbPodcast::Delete3WeeksAgoEpisodesL( |
|
339 CDesCArray& aUriArray, |
|
340 CMPXMessageArray& aItemChangedMessages) |
|
341 { |
|
342 MPX_FUNC("CMPXDbPodcast::Delete3WeeksAgoEpisodesL"); |
|
343 |
|
344 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
345 dayNo++; // shifted by 1 day to get correct results |
|
346 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
347 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastBetween, |
|
348 now, dayNo + 21, now, dayNo + 14)); |
|
349 CleanupClosePushL(recordset); |
|
350 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
351 CleanupStack::PopAndDestroy(&recordset); |
|
352 CleanupStack::PopAndDestroy(now); |
|
353 } |
|
354 |
|
355 // ---------------------------------------------------------------------------- |
|
356 // Remove all podcast episodes from the podcast table that are published last month |
|
357 // ---------------------------------------------------------------------------- |
|
358 // |
|
359 void CMPXDbPodcast::DeleteLastMonthEpisodesL( |
|
360 CDesCArray& aUriArray, |
|
361 CMPXMessageArray& aItemChangedMessages) |
|
362 { |
|
363 MPX_FUNC("CMPXDbPodcast::DeleteLastMonthEpisodesL"); |
|
364 |
|
365 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
366 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastLastMonth, now, now)); |
|
367 CleanupClosePushL(recordset); |
|
368 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
369 CleanupStack::PopAndDestroy(&recordset); |
|
370 CleanupStack::PopAndDestroy(now); |
|
371 } |
|
372 |
|
373 // ---------------------------------------------------------------------------- |
|
374 // Remove all podcast episodes from the podcast table that are published earlier |
|
375 // ---------------------------------------------------------------------------- |
|
376 // |
|
377 void CMPXDbPodcast::DeleteEarlierEpisodesL( |
|
378 CDesCArray& aUriArray, |
|
379 CMPXMessageArray& aItemChangedMessages) |
|
380 { |
|
381 MPX_FUNC("CMPXDbPodcast::DeleteEarlierEpisodesL"); |
|
382 |
|
383 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
384 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastEarlier, now)); |
|
385 CleanupClosePushL(recordset); |
|
386 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
387 CleanupStack::PopAndDestroy(&recordset); |
|
388 CleanupStack::PopAndDestroy(now); |
|
389 } |
|
390 |
|
391 // ---------------------------------------------------------------------------- |
|
392 // Remove all podcast episodes from the podcast table that do not have a published date |
|
393 // ---------------------------------------------------------------------------- |
|
394 // |
|
395 void CMPXDbPodcast::DeleteUnknownEpisodesL( |
|
396 CDesCArray& aUriArray, |
|
397 CMPXMessageArray& aItemChangedMessages) |
|
398 { |
|
399 MPX_FUNC("CMPXDbPodcast::DeleteUnknownEpisodesL"); |
|
400 |
|
401 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
402 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastUnknown, now)); |
|
403 CleanupClosePushL(recordset); |
|
404 DeleteRecordsetL(recordset, aUriArray, aItemChangedMessages); |
|
405 CleanupStack::PopAndDestroy(&recordset); |
|
406 CleanupStack::PopAndDestroy(now); |
|
407 } |
|
408 |
|
409 // ---------------------------------------------------------------------------- |
|
410 // Get the episode Id and duration |
|
411 // ---------------------------------------------------------------------------- |
|
412 // |
|
413 TInt CMPXDbPodcast::EpisodeDurationL( |
|
414 TUint32 aEpisodeId) |
|
415 { |
|
416 MPX_FUNC("CMPXDbPodcast::EpisodeDurationL"); |
|
417 return ExecuteSumQueryL(KQueryPodcastEpisodeDuration, aEpisodeId); |
|
418 } |
|
419 |
|
420 // ---------------------------------------------------------------------------- |
|
421 // CMPXDbPodcast::AllEpisodesDurationL |
|
422 // ---------------------------------------------------------------------------- |
|
423 // |
|
424 TInt CMPXDbPodcast::AllEpisodesDurationL() |
|
425 { |
|
426 MPX_FUNC("CMPXDbPodcast::AllEpisodesDurationL"); |
|
427 return ExecuteSumQueryL(KQueryPodcastDurationAll); |
|
428 } |
|
429 |
|
430 // ---------------------------------------------------------------------------- |
|
431 // CMPXDbPodcast::TitleDurationL |
|
432 // ---------------------------------------------------------------------------- |
|
433 // |
|
434 TInt CMPXDbPodcast::TitleDurationL( |
|
435 TUint32 aTitleId) |
|
436 { |
|
437 MPX_FUNC("CMPXDbPodcast::TitleDurationL"); |
|
438 return ExecuteSumQueryL(KQueryPodcastDurationAlbum, aTitleId); |
|
439 } |
|
440 |
|
441 // ---------------------------------------------------------------------------- |
|
442 // CMPXDbPodcast::NotPlayedDurationL |
|
443 // ---------------------------------------------------------------------------- |
|
444 // |
|
445 TInt CMPXDbPodcast::NotPlayedDurationL() |
|
446 { |
|
447 MPX_FUNC("CMPXDbPodcast::NotPlayedDurationL"); |
|
448 return ExecuteSumQueryL(KQueryPodcastNotPlayedDuration); |
|
449 } |
|
450 |
|
451 // ---------------------------------------------------------------------------- |
|
452 // CMPXDbPodcast::RecentlyAddedDurationL |
|
453 // ---------------------------------------------------------------------------- |
|
454 // |
|
455 TInt CMPXDbPodcast::RecentlyAddedDurationL() |
|
456 { |
|
457 MPX_FUNC("CMPXDbPodcast::RecentlyAddedDurationL"); |
|
458 return ExecuteSumQueryL(KQueryPodcastRecentlyAddedDuration); |
|
459 } |
|
460 |
|
461 // ---------------------------------------------------------------------------- |
|
462 // Get the name of the episode matching the given ID |
|
463 // ---------------------------------------------------------------------------- |
|
464 // |
|
465 HBufC* CMPXDbPodcast::GetNameL( |
|
466 TUint32 aEpisodeId) |
|
467 { |
|
468 MPX_FUNC("CMPXDbPodcast::GetNameL"); |
|
469 |
|
470 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetTitle, |
|
471 aEpisodeId)); |
|
472 CleanupClosePushL(recordset); |
|
473 |
|
474 if (recordset.Next() != KSqlAtRow) |
|
475 { |
|
476 User::Leave(KErrNotFound); |
|
477 } |
|
478 |
|
479 HBufC* name = recordset.ColumnTextL(KMPXTableDefaultIndex).AllocL(); |
|
480 CleanupStack::PopAndDestroy(&recordset); |
|
481 |
|
482 return name; |
|
483 } |
|
484 |
|
485 // ---------------------------------------------------------------------------- |
|
486 // Get URI of the episode |
|
487 // ---------------------------------------------------------------------------- |
|
488 // |
|
489 HBufC* CMPXDbPodcast::GetUriL( |
|
490 TUint32 aEpisodeId) |
|
491 { |
|
492 MPX_FUNC("CMPXDbPodcast::GetUriL"); |
|
493 |
|
494 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetEpisodeNoCat, |
|
495 aEpisodeId)); |
|
496 CleanupClosePushL(recordset); |
|
497 |
|
498 if (recordset.Next() != KSqlAtRow) |
|
499 { |
|
500 User::Leave(KErrNotFound); |
|
501 } |
|
502 |
|
503 HBufC* uri = ConstructUriL(recordset); |
|
504 CleanupStack::PopAndDestroy(&recordset); |
|
505 |
|
506 return uri; |
|
507 } |
|
508 |
|
509 // ---------------------------------------------------------------------------- |
|
510 // Find the drive Ids of corresponding unique Episode Id |
|
511 // ---------------------------------------------------------------------------- |
|
512 // |
|
513 TInt CMPXDbPodcast::GetDriveL( |
|
514 TUint32 aEpisodeId) |
|
515 { |
|
516 MPX_FUNC("CMPXDbPodcast::GetDriveL"); |
|
517 return MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), |
|
518 ExecuteIntQueryL(KQueryPodcastVolume, aEpisodeId)); |
|
519 } |
|
520 |
|
521 // ---------------------------------------------------------------------------- |
|
522 // CMPXDbPodcast::GetEpisodeL |
|
523 // ---------------------------------------------------------------------------- |
|
524 // |
|
525 void CMPXDbPodcast::GetEpisodeL( |
|
526 TUint32 aEpisodeId, |
|
527 const TArray<TMPXAttribute>& aAttrs, |
|
528 CMPXMedia& aMedia) |
|
529 { |
|
530 MPX_FUNC("CMPXDbPodcast::GetEpisodeL"); |
|
531 ExecuteMediaQueryL(aAttrs, aMedia, ExtraFieldsRequired(aAttrs) ? |
|
532 KQueryPodcastGetEpisode() : KQueryPodcastGetEpisodeNoCat(), aEpisodeId); |
|
533 } |
|
534 |
|
535 // ---------------------------------------------------------------------------- |
|
536 // CMPXDbPodcast::GetAllEpisodesL |
|
537 // ---------------------------------------------------------------------------- |
|
538 // |
|
539 void CMPXDbPodcast::GetAllEpisodesL( |
|
540 const TArray<TMPXAttribute>& aAttrs, |
|
541 CMPXMediaArray& aMediaArray) |
|
542 { |
|
543 MPX_FUNC("CMPXDbPodcast::GetAllEpisodesL"); |
|
544 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
545 KQueryPodcastGetAllEpisodes() : KQueryPodcastGetAllEpisodesNoCat()); |
|
546 } |
|
547 |
|
548 // ---------------------------------------------------------------------------- |
|
549 // CMPXDbPodcast::GetEpisodesForCategoryL |
|
550 // ---------------------------------------------------------------------------- |
|
551 // |
|
552 void CMPXDbPodcast::GetEpisodesForCategoryL( |
|
553 TMPXGeneralCategory aCategory, |
|
554 TUint32 aCategoryId, |
|
555 const TArray<TMPXAttribute>& aAttrs, |
|
556 CMPXMediaArray& aMediaArray, |
|
557 TBool aOrder ) |
|
558 { |
|
559 MPX_FUNC("CMPXDbPodcast::GetEpisodesForCategoryL"); |
|
560 TPtrC ptr(MPXDbUtil::PodcastFieldNameForCategoryL(aCategory)); |
|
561 |
|
562 if( aOrder ) |
|
563 { |
|
564 ExecuteMediaQueryL(aAttrs, aMediaArray, KQueryPodcastCategoryOrdered, ptr, aCategoryId); |
|
565 } |
|
566 else |
|
567 { |
|
568 ExecuteMediaQueryL(aAttrs, aMediaArray, KQueryPodcastCategory, ptr, aCategoryId); |
|
569 } |
|
570 } |
|
571 |
|
572 // ---------------------------------------------------------------------------- |
|
573 // Retrieve the episode(s) with the specified title |
|
574 // ---------------------------------------------------------------------------- |
|
575 // |
|
576 void CMPXDbPodcast::GetEpisodesMatchingTitleL( |
|
577 TUint aTitleId, |
|
578 const TArray<TMPXAttribute>& aAttrs, |
|
579 CMPXMediaArray& aMediaArray) |
|
580 { |
|
581 MPX_FUNC("CMPXDbPodcast::GetEpisodesMatchingTitleL"); |
|
582 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
583 KQueryPodcastGetEpisodesForAlbum() : KQueryPodcastGetEpisodesForAlbumNoCat(), |
|
584 aTitleId); |
|
585 } |
|
586 |
|
587 // ---------------------------------------------------------------------------- |
|
588 // Get all podcast episodes from the podcast table that have not been played |
|
589 // ---------------------------------------------------------------------------- |
|
590 // |
|
591 void CMPXDbPodcast::GetNotYetPlayedPlaylistEpisodesL( |
|
592 const TArray<TMPXAttribute>& aAttrs, |
|
593 CMPXMediaArray& aMediaArray, |
|
594 TInt& aIndexOfCurrentlyPlayingItem) |
|
595 { |
|
596 MPX_FUNC("CMPXDbPodcast::GetNotYetPlayedPlaylistEpisodesL"); |
|
597 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
598 KQueryPodcastNotPlayed() : KQueryPodcastNotPlayedNoCat()); |
|
599 |
|
600 aIndexOfCurrentlyPlayingItem = GetPlayingItemL(aMediaArray); |
|
601 } |
|
602 |
|
603 // ---------------------------------------------------------------------------- |
|
604 // Get all podcast episodes from the podcast table were added within the last 7 days |
|
605 // ---------------------------------------------------------------------------- |
|
606 // |
|
607 void CMPXDbPodcast::GetRecentlyAddedPlaylistEpisodesL( |
|
608 const TArray<TMPXAttribute>& aAttrs, |
|
609 CMPXMediaArray& aMediaArray, |
|
610 TInt& aIndexOfCurrentlyPlayingItem) |
|
611 { |
|
612 MPX_FUNC("CMPXDbPodcast::GetRecentlyAddedPlaylistEpisodesL"); |
|
613 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
614 KQueryPodcastRecentlyAdded() : KQueryPodcastRecentlyAddedNoCat()); |
|
615 |
|
616 aIndexOfCurrentlyPlayingItem = GetPlayingItemL(aMediaArray); |
|
617 } |
|
618 |
|
619 // ---------------------------------------------------------------------------- |
|
620 // Get all episodes from the podcast table that are published today |
|
621 // ---------------------------------------------------------------------------- |
|
622 // |
|
623 void CMPXDbPodcast::GetTodayEpisodesL( |
|
624 const TMPXItemId& aPublishDateCategoryId, |
|
625 const TArray<TMPXAttribute>& aAttrs, |
|
626 CMPXMediaArray& aMediaArray) |
|
627 { |
|
628 MPX_FUNC("CMPXDbPodcast::GetTodayEpisodesL"); |
|
629 |
|
630 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
631 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
632 KQueryPodcastToday() : KQueryPodcastTodayNoCat(), *now, *now); |
|
633 CleanupStack::PopAndDestroy(now); |
|
634 |
|
635 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
636 } |
|
637 |
|
638 // ---------------------------------------------------------------------------- |
|
639 // Get all episodes from the podcast table that are published yesterday |
|
640 // ---------------------------------------------------------------------------- |
|
641 // |
|
642 void CMPXDbPodcast::GetYesterdayEpisodesL( |
|
643 const TMPXItemId& aPublishDateCategoryId, |
|
644 const TArray<TMPXAttribute>& aAttrs, |
|
645 CMPXMediaArray& aMediaArray) |
|
646 { |
|
647 MPX_FUNC("CMPXDbPodcast::GetYesterdayEpisodesL"); |
|
648 |
|
649 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
650 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
651 KQueryPodcastYesterday() : KQueryPodcastYesterdayNoCat(), *now, *now); |
|
652 CleanupStack::PopAndDestroy(now); |
|
653 |
|
654 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
655 } |
|
656 |
|
657 // ---------------------------------------------------------------------------- |
|
658 // Get all episodes from the podcast table that are published this weeks |
|
659 // This doesn't include Today or Yesterday's episodes |
|
660 // ---------------------------------------------------------------------------- |
|
661 // |
|
662 void CMPXDbPodcast::GetThisWeekEpisodesL( |
|
663 const TMPXItemId& aPublishDateCategoryId, |
|
664 const TArray<TMPXAttribute>& aAttrs, |
|
665 CMPXMediaArray& aMediaArray) |
|
666 { |
|
667 MPX_FUNC("CMPXDbPodcast::GetThisWeekEpisodesL"); |
|
668 |
|
669 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
670 dayNo++; // shifted by 1 day to get correct results |
|
671 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
672 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
673 KQueryPodcastBetween() : KQueryPodcastBetweenNoCat(), |
|
674 *now, dayNo, *now, 1); |
|
675 CleanupStack::PopAndDestroy(now); |
|
676 |
|
677 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
678 } |
|
679 |
|
680 // ---------------------------------------------------------------------------- |
|
681 // Get all episodes from the podcast table that are published last weeks |
|
682 // ---------------------------------------------------------------------------- |
|
683 // |
|
684 void CMPXDbPodcast::GetLastWeekEpisodesL( |
|
685 const TMPXItemId& aPublishDateCategoryId, |
|
686 const TArray<TMPXAttribute>& aAttrs, |
|
687 CMPXMediaArray& aMediaArray) |
|
688 { |
|
689 MPX_FUNC("CMPXDbPodcast::GetLastWeekEpisodesL"); |
|
690 |
|
691 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
692 dayNo++; // shifted by 1 day to get correct results |
|
693 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
694 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
695 KQueryPodcastBetween() : KQueryPodcastBetweenNoCat(), |
|
696 *now, dayNo + 7, *now, dayNo); |
|
697 CleanupStack::PopAndDestroy(now); |
|
698 |
|
699 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
700 } |
|
701 |
|
702 // ---------------------------------------------------------------------------- |
|
703 // Get all episodes from the podcast table that are published 2 weeks ago |
|
704 // ---------------------------------------------------------------------------- |
|
705 // |
|
706 void CMPXDbPodcast::Get2WeeksAgoEpisodesL( |
|
707 const TMPXItemId& aPublishDateCategoryId, |
|
708 const TArray<TMPXAttribute>& aAttrs, |
|
709 CMPXMediaArray& aMediaArray) |
|
710 { |
|
711 MPX_FUNC("CMPXDbPodcast::Get2WeeksAgoEpisodesL"); |
|
712 |
|
713 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
714 dayNo++; // shifted by 1 day to get correct results |
|
715 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
716 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
717 KQueryPodcastBetween() : KQueryPodcastBetweenNoCat(), |
|
718 *now, dayNo + 14, *now, dayNo + 7); |
|
719 |
|
720 CleanupStack::PopAndDestroy(now); |
|
721 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
722 } |
|
723 |
|
724 // ---------------------------------------------------------------------------- |
|
725 // Get all episodes from the podcast table that are published 3 weeks ago |
|
726 // ---------------------------------------------------------------------------- |
|
727 // |
|
728 void CMPXDbPodcast::Get3WeeksAgoEpisodesL( |
|
729 const TMPXItemId& aPublishDateCategoryId, |
|
730 const TArray<TMPXAttribute>& aAttrs, |
|
731 CMPXMediaArray& aMediaArray) |
|
732 { |
|
733 MPX_FUNC("CMPXDbPodcast::Get3WeeksAgoEpisodesL"); |
|
734 |
|
735 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
736 dayNo++; // shifted by 1 day to get correct results |
|
737 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
738 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
739 KQueryPodcastBetween() : KQueryPodcastBetweenNoCat(), |
|
740 *now, dayNo + 21, *now, dayNo + 14); |
|
741 CleanupStack::PopAndDestroy(now); |
|
742 |
|
743 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
744 } |
|
745 |
|
746 // ---------------------------------------------------------------------------- |
|
747 // Get all episodes from the podcast table that are published last month |
|
748 // ---------------------------------------------------------------------------- |
|
749 // |
|
750 void CMPXDbPodcast::GetLastMonthEpisodesL( |
|
751 const TMPXItemId& aPublishDateCategoryId, |
|
752 const TArray<TMPXAttribute>& aAttrs, |
|
753 CMPXMediaArray& aMediaArray) |
|
754 { |
|
755 MPX_FUNC("CMPXDbPodcast::GetLastMonthEpisodesL"); |
|
756 |
|
757 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
758 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
759 KQueryPodcastLastMonth() : KQueryPodcastLastMonthNoCat(), *now, *now); |
|
760 CleanupStack::PopAndDestroy(now); |
|
761 |
|
762 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
763 } |
|
764 |
|
765 // ---------------------------------------------------------------------------- |
|
766 // Get all episodes from the podcast table that are published earlier |
|
767 // ---------------------------------------------------------------------------- |
|
768 // |
|
769 void CMPXDbPodcast::GetEarlierEpisodesL( |
|
770 const TMPXItemId& aPublishDateCategoryId, |
|
771 const TArray<TMPXAttribute>& aAttrs, |
|
772 CMPXMediaArray& aMediaArray) |
|
773 { |
|
774 MPX_FUNC("CMPXDbPodcast::GetEarlierEpisodesL"); |
|
775 |
|
776 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
777 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
778 KQueryPodcastEarlier() : KQueryPodcastEarlierNoCat(), *now); |
|
779 CleanupStack::PopAndDestroy(now); |
|
780 |
|
781 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
782 } |
|
783 |
|
784 // ---------------------------------------------------------------------------- |
|
785 // Get all episodes from the podcast table that are published on unknown date |
|
786 // ---------------------------------------------------------------------------- |
|
787 // |
|
788 void CMPXDbPodcast::GetUnknownEpisodesL( |
|
789 const TMPXItemId& aPublishDateCategoryId, |
|
790 const TArray<TMPXAttribute>& aAttrs, |
|
791 CMPXMediaArray& aMediaArray) |
|
792 { |
|
793 MPX_FUNC("CMPXDbPodcast::GetUnknownEpisodesL"); |
|
794 |
|
795 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
796 ExecuteMediaQueryL(aAttrs, aMediaArray, ExtraFieldsRequired(aAttrs) ? |
|
797 KQueryPodcastUnknown() : KQueryPodcastUnknownNoCat(), *now); |
|
798 CleanupStack::PopAndDestroy(now); |
|
799 |
|
800 ProcessPublishDateCategoryL(aPublishDateCategoryId, aMediaArray); |
|
801 } |
|
802 |
|
803 // ---------------------------------------------------------------------------- |
|
804 // Count the total number of items |
|
805 // ---------------------------------------------------------------------------- |
|
806 // |
|
807 TInt CMPXDbPodcast::CountL() |
|
808 { |
|
809 MPX_FUNC("CMPXDbPodcast::CountL"); |
|
810 return ExecuteSumQueryL(KQueryPodcastCount); |
|
811 } |
|
812 |
|
813 // ---------------------------------------------------------------------------- |
|
814 // Get number of episodes from the podcast table that are published today |
|
815 // ---------------------------------------------------------------------------- |
|
816 // |
|
817 TInt CMPXDbPodcast::GetTodayEpisodesCountL() |
|
818 { |
|
819 MPX_FUNC("CMPXDbPodcast::GetTodayEpisodesCountL"); |
|
820 |
|
821 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
822 TInt count = ExecuteSumQueryL(KQueryPodcastTodayCount, *now, *now); |
|
823 CleanupStack::PopAndDestroy(now); |
|
824 |
|
825 return count; |
|
826 } |
|
827 |
|
828 // ---------------------------------------------------------------------------- |
|
829 // Get number of episodes from the podcast table that are published yesterday |
|
830 // ---------------------------------------------------------------------------- |
|
831 // |
|
832 TInt CMPXDbPodcast::GetYesterdayEpisodesCountL() |
|
833 { |
|
834 MPX_FUNC("CMPXDbPodcast::GetYesterdayEpisodesCountL"); |
|
835 |
|
836 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
837 TInt count = ExecuteSumQueryL(KQueryPodcastYesterdayCount, *now, *now); |
|
838 CleanupStack::PopAndDestroy(now); |
|
839 |
|
840 return count; |
|
841 } |
|
842 |
|
843 // ---------------------------------------------------------------------------- |
|
844 // Get number of episodes from the podcast table that are published this weeks |
|
845 // This doesn't include Today or Yesterday's episodes |
|
846 // ---------------------------------------------------------------------------- |
|
847 // |
|
848 TInt CMPXDbPodcast::GetThisWeekEpisodesCountL() |
|
849 { |
|
850 MPX_FUNC("CMPXDbPodcast::GetThisWeekEpisodesCountL"); |
|
851 |
|
852 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
853 dayNo++; // shifted by 1 day to get correct results |
|
854 |
|
855 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
856 TInt count = ExecuteSumQueryL(KQueryPodcastBetweenCount, *now, dayNo, *now, 1); |
|
857 CleanupStack::PopAndDestroy(now); |
|
858 |
|
859 return count; |
|
860 } |
|
861 |
|
862 // ---------------------------------------------------------------------------- |
|
863 // Get number of episodes from the podcast table that are published last weeks |
|
864 // ---------------------------------------------------------------------------- |
|
865 // |
|
866 TInt CMPXDbPodcast::GetLastWeekEpisodesCountL() |
|
867 { |
|
868 MPX_FUNC("CMPXDbPodcast::GetLastWeekEpisodesCountL"); |
|
869 |
|
870 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
871 dayNo++; // shifted by 1 day to get correct results |
|
872 |
|
873 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
874 TInt count = ExecuteSumQueryL(KQueryPodcastBetweenCount, *now, dayNo + 7, *now, dayNo); |
|
875 CleanupStack::PopAndDestroy(now); |
|
876 |
|
877 return count; |
|
878 } |
|
879 |
|
880 // ---------------------------------------------------------------------------- |
|
881 // Get number of episodes from the podcast table that are published 2 weeks ago |
|
882 // ---------------------------------------------------------------------------- |
|
883 // |
|
884 TInt CMPXDbPodcast::Get2WeeksAgoEpisodesCountL() |
|
885 { |
|
886 MPX_FUNC("CMPXDbPodcast::Get2WeeksAgoEpisodesCountL"); |
|
887 |
|
888 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
889 dayNo++; // shifted by 1 day to get correct results |
|
890 |
|
891 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
892 TInt count = ExecuteSumQueryL(KQueryPodcastBetweenCount, *now, dayNo + 14, *now, dayNo + 7); |
|
893 CleanupStack::PopAndDestroy(now); |
|
894 |
|
895 return count; |
|
896 } |
|
897 |
|
898 // ---------------------------------------------------------------------------- |
|
899 // Get number of episodes from the podcast table that are published 3 weeks ago |
|
900 // ---------------------------------------------------------------------------- |
|
901 // |
|
902 TInt CMPXDbPodcast::Get3WeeksAgoEpisodesCountL() |
|
903 { |
|
904 MPX_FUNC("CMPXDbPodcast::Get3WeeksAgoEpisodesCountL"); |
|
905 |
|
906 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
907 dayNo++; // shifted by 1 day to get correct results |
|
908 |
|
909 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
910 TInt count = ExecuteSumQueryL(KQueryPodcastBetweenCount, *now, dayNo + 21, *now, dayNo + 14); |
|
911 CleanupStack::PopAndDestroy(now); |
|
912 |
|
913 return count; |
|
914 } |
|
915 |
|
916 // ---------------------------------------------------------------------------- |
|
917 // Get number of episodes from the podcast table that are published last month |
|
918 // ---------------------------------------------------------------------------- |
|
919 // |
|
920 TInt CMPXDbPodcast::GetLastMonthEpisodesCountL() |
|
921 { |
|
922 MPX_FUNC("CMPXDbPodcast::GetLastMonthEpisodesCountL"); |
|
923 |
|
924 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
925 TInt count = ExecuteSumQueryL(KQueryPodcastLastMonthCount, *now, *now); |
|
926 CleanupStack::PopAndDestroy(now); |
|
927 |
|
928 return count; |
|
929 } |
|
930 |
|
931 // ---------------------------------------------------------------------------- |
|
932 // Get number of episodes from the podcast table that are published earlier |
|
933 // ---------------------------------------------------------------------------- |
|
934 // |
|
935 TInt CMPXDbPodcast::GetEarlierEpisodesCountL() |
|
936 { |
|
937 MPX_FUNC("CMPXDbPodcast::GetEarlierEpisodesCountL"); |
|
938 |
|
939 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
940 TInt count = ExecuteSumQueryL(KQueryPodcastEarlierCount, *now); |
|
941 CleanupStack::PopAndDestroy(now); |
|
942 |
|
943 return count; |
|
944 } |
|
945 |
|
946 // ---------------------------------------------------------------------------- |
|
947 // Get number of episodes from the podcast table that are published on unknown date |
|
948 // ---------------------------------------------------------------------------- |
|
949 // |
|
950 TInt CMPXDbPodcast::GetUnknownEpisodesCountL() |
|
951 { |
|
952 MPX_FUNC("CMPXDbPodcast::GetUnknownEpisodesCountL"); |
|
953 |
|
954 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
955 TInt count = ExecuteSumQueryL(KQueryPodcastUnknownCount, *now); |
|
956 CleanupStack::PopAndDestroy(now); |
|
957 |
|
958 return count; |
|
959 } |
|
960 |
|
961 // ---------------------------------------------------------------------------- |
|
962 // Count the number of episodes recently added |
|
963 // ---------------------------------------------------------------------------- |
|
964 // |
|
965 TInt CMPXDbPodcast::GetRecentlyAddedEpisodesCountL() |
|
966 { |
|
967 MPX_FUNC("CMPXDbPodcast::GetRecentlyAddedEpisodesCountL"); |
|
968 return ExecuteSumQueryL(KQueryPodcastRecentlyAddedCount); |
|
969 } |
|
970 |
|
971 // ---------------------------------------------------------------------------- |
|
972 // Get count of all podcast episodes from the Podcast table that have not been played |
|
973 // ---------------------------------------------------------------------------- |
|
974 // |
|
975 TInt CMPXDbPodcast::GetNotYetPlayedEpisodesCountL() |
|
976 { |
|
977 MPX_FUNC("CMPXDbPodcast::GetNotYetPlayedPlaylistEpisodes"); |
|
978 return ExecuteSumQueryL(KQueryPodcastNotPlayedCount); |
|
979 } |
|
980 |
|
981 // ---------------------------------------------------------------------------- |
|
982 // Get episode(s) from the podcast table that match the given criteria |
|
983 // ---------------------------------------------------------------------------- |
|
984 // |
|
985 void CMPXDbPodcast::FindEpisodesL( |
|
986 TUint32 aGeneralId, |
|
987 TUint32 aContainerId, |
|
988 TMPXGeneralType aType, |
|
989 TMPXPodcastType aPodcastType, |
|
990 const CMPXMedia& aCriteria, |
|
991 const TArray<TMPXAttribute>& aAttrs, |
|
992 CMPXMediaArray& aMediaArray) |
|
993 { |
|
994 MPX_FUNC("CMPXDbPodcast::FindEpisodesL"); |
|
995 |
|
996 // set up the selection criteria |
|
997 HBufC* criteriaStr = GeneratePodcastMatchingCriteriaLC(aGeneralId, aContainerId, |
|
998 aType, aPodcastType, aCriteria); |
|
999 |
|
1000 // iterate the results and append media objects to the destination array |
|
1001 ExecuteMediaQueryL(aAttrs, aMediaArray, KQueryPodcastFindAll, *criteriaStr); |
|
1002 |
|
1003 CleanupStack::PopAndDestroy(criteriaStr); |
|
1004 } |
|
1005 |
|
1006 // ---------------------------------------------------------------------------- |
|
1007 // CMPXDbPodcast::SetIsPlayingL |
|
1008 // ---------------------------------------------------------------------------- |
|
1009 // |
|
1010 void CMPXDbPodcast::SetIsPlayingL( |
|
1011 TUint32 aEpisodeId, |
|
1012 TBool aIsPlaying) |
|
1013 { |
|
1014 MPX_FUNC("CMPXDbPodcast::SetIsPlayingL"); |
|
1015 TInt drive(GetDriveL(aEpisodeId)); |
|
1016 iDbManager.ExecuteQueryL(drive, KQueryPodcastSetIsPlaying, aIsPlaying, aEpisodeId); |
|
1017 } |
|
1018 |
|
1019 // ---------------------------------------------------------------------------- |
|
1020 // CMPXDbPodcast::GetDrivePodcastCountL |
|
1021 // ---------------------------------------------------------------------------- |
|
1022 // |
|
1023 TUint CMPXDbPodcast::GetDrivePodcastCountL(TInt aDrive) |
|
1024 { |
|
1025 TUint count(0); |
|
1026 |
|
1027 //podcast |
|
1028 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aDrive,KQueryPodcastCount)); |
|
1029 CleanupClosePushL(recordset); |
|
1030 |
|
1031 if (recordset.Next() != KSqlAtRow) |
|
1032 { |
|
1033 User::Leave(KErrCorrupt); |
|
1034 } |
|
1035 |
|
1036 count = TUint(recordset.ColumnInt64(KMPXTableDefaultIndex)); |
|
1037 CleanupStack::PopAndDestroy(&recordset); |
|
1038 |
|
1039 return count; |
|
1040 } |
|
1041 |
|
1042 // ---------------------------------------------------------------------------- |
|
1043 // CMPXDbPodcast::GetPodcastUriArrayL |
|
1044 // ---------------------------------------------------------------------------- |
|
1045 // |
|
1046 void CMPXDbPodcast::GetPodcastUriArrayL(TInt aDrive, TInt aFromID, TInt aRecords, |
|
1047 CDesCArray& aUriArr, TInt& aLastID) |
|
1048 { |
|
1049 MPX_FUNC("CMPXDbPodcast::GetPodcastUriArrayL"); |
|
1050 |
|
1051 HBufC* query = NULL; |
|
1052 if(aFromID == 0) |
|
1053 { |
|
1054 query = HBufC::NewLC(KQueryPodcastGetUris().Length() |
|
1055 + KMCIntegerLen); |
|
1056 query->Des().Format(KQueryPodcastGetUris, aRecords); |
|
1057 } |
|
1058 else |
|
1059 { |
|
1060 query = HBufC::NewLC(KQueryPodcastGetUrisFrom().Length() |
|
1061 + 2*KMCIntegerLen); |
|
1062 query->Des().Format(KQueryPodcastGetUrisFrom, aFromID, aRecords); |
|
1063 } |
|
1064 |
|
1065 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(aDrive,*query)); |
|
1066 |
|
1067 CleanupStack::PopAndDestroy(query); |
|
1068 |
|
1069 CleanupClosePushL(recordset); |
|
1070 |
|
1071 TInt lastID = 0; |
|
1072 TInt err(KErrNone); |
|
1073 while((err = recordset.Next()) == KSqlAtRow) |
|
1074 { |
|
1075 HBufC* fullPath = MPXDbCommonUtil::CreateFullPathL(aDrive, |
|
1076 MPXDbCommonUtil::GetColumnTextL(recordset, KColUri)); |
|
1077 CleanupStack::PushL(fullPath); |
|
1078 aUriArr.AppendL(*fullPath); |
|
1079 CleanupStack::PopAndDestroy(fullPath); |
|
1080 |
|
1081 lastID = recordset.ColumnInt(KColUniqueID); |
|
1082 } |
|
1083 CleanupStack::PopAndDestroy(&recordset); |
|
1084 |
|
1085 aLastID = lastID; |
|
1086 |
|
1087 if (err!= KSqlAtEnd) |
|
1088 { |
|
1089 User::Leave(KErrCorrupt); |
|
1090 } |
|
1091 } |
|
1092 |
|
1093 // ---------------------------------------------------------------------------- |
|
1094 // CMPXDbPodcast::DoAddEpisodeL |
|
1095 // ---------------------------------------------------------------------------- |
|
1096 // |
|
1097 TBool CMPXDbPodcast::DoAddEpisodeL( |
|
1098 TUint32 aEpisodeId, |
|
1099 const CMPXMedia& aMedia, |
|
1100 TInt aDrive, |
|
1101 CMPXMessageArray* aItemChangedMessages) |
|
1102 { |
|
1103 MPX_FUNC("CMPXDbPodcast::DoAddEpisodeL"); |
|
1104 |
|
1105 CDesCArrayFlat* fields = new (ELeave) CDesCArrayFlat(EPodcastFieldCount); |
|
1106 CleanupStack::PushL(fields); |
|
1107 CDesCArrayFlat* values = new (ELeave) CDesCArrayFlat(EPodcastFieldCount); |
|
1108 CleanupStack::PushL(values); |
|
1109 |
|
1110 // add known fields |
|
1111 MPXDbCommonUtil::AppendValueL(*fields, *values, KMCPodcastUniqueId, aEpisodeId); |
|
1112 MPXDbCommonUtil::AppendValueL(*fields, *values, KMCPodcastDel, 0); |
|
1113 |
|
1114 HBufC* date = MPXDbCommonUtil::CurrentDateDesLC(); |
|
1115 MPXDbCommonUtil::AppendValueL(*fields, *values, KMCPodcastTimeAdded, *date); |
|
1116 CleanupStack::PopAndDestroy(date); |
|
1117 |
|
1118 // process the media parameter and construct the fields and values array |
|
1119 TBool visible(GeneratePodcastFieldsValuesL(aEpisodeId, aMedia, aItemChangedMessages, |
|
1120 NULL, *fields, *values, aDrive)); |
|
1121 |
|
1122 // create the fields and values strings |
|
1123 HBufC* fieldStr = MPXDbCommonUtil::StringFromArrayLC(*fields, KMCCommaSign); |
|
1124 HBufC* valueStr = MPXDbCommonUtil::StringFromArrayLC(*values, KMCCommaSign); |
|
1125 |
|
1126 // execute the query |
|
1127 iDbManager.ExecuteQueryL(aDrive, KQueryPodcastInsert, fieldStr, valueStr); |
|
1128 |
|
1129 CleanupStack::PopAndDestroy(valueStr); |
|
1130 CleanupStack::PopAndDestroy(fieldStr); |
|
1131 CleanupStack::PopAndDestroy(values); |
|
1132 CleanupStack::PopAndDestroy(fields); |
|
1133 |
|
1134 return visible; |
|
1135 } |
|
1136 |
|
1137 // ---------------------------------------------------------------------------- |
|
1138 // CMPXDbPodcast::DoUpdateEpisodeL |
|
1139 // ---------------------------------------------------------------------------- |
|
1140 // |
|
1141 CMPXDbActiveTask::TChangeVisibility CMPXDbPodcast::DoUpdateEpisodeL( |
|
1142 TUint32 aEpisodeId, |
|
1143 const CMPXMedia& aMedia, |
|
1144 CMPXMessageArray* aItemChangedMessages) |
|
1145 { |
|
1146 MPX_FUNC("CMPXDbPodcast::DoUpdateEpisodeL"); |
|
1147 |
|
1148 // retrieve the existing record |
|
1149 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastGetEpisode, aEpisodeId)); |
|
1150 CleanupClosePushL(recordset); |
|
1151 |
|
1152 if (recordset.Next() != KSqlAtRow) |
|
1153 { |
|
1154 User::Leave(KErrNotFound); |
|
1155 } |
|
1156 |
|
1157 TDriveUnit driveUnit(MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), |
|
1158 recordset.ColumnInt64(EPodcastVolumeId))); |
|
1159 CMPXDbActiveTask::TChangeVisibility visible(DoUpdateEpisodeL(aEpisodeId, aMedia, driveUnit, aItemChangedMessages, |
|
1160 recordset)); |
|
1161 |
|
1162 CleanupStack::PopAndDestroy(&recordset); |
|
1163 |
|
1164 return visible; |
|
1165 } |
|
1166 |
|
1167 // ---------------------------------------------------------------------------- |
|
1168 // CMPXDbPodcast::DoUpdateEpisodeL |
|
1169 // ---------------------------------------------------------------------------- |
|
1170 // |
|
1171 CMPXDbActiveTask::TChangeVisibility CMPXDbPodcast::DoUpdateEpisodeL( |
|
1172 TUint32 aEpisodeId, |
|
1173 const CMPXMedia& aMedia, |
|
1174 TInt aDrive, |
|
1175 CMPXMessageArray* aItemChangedMessages, |
|
1176 RSqlStatement& aRecordset) |
|
1177 { |
|
1178 MPX_FUNC("CMPXDbPodcast::DoUpdateEpisodeL"); |
|
1179 |
|
1180 CDesCArrayFlat* fields = new (ELeave) CDesCArrayFlat(EPodcastFieldCount); |
|
1181 CleanupStack::PushL(fields); |
|
1182 CDesCArrayFlat* values = new (ELeave) CDesCArrayFlat(EPodcastFieldCount); |
|
1183 CleanupStack::PushL(values); |
|
1184 |
|
1185 // process the media parameter and construct the fields and values array |
|
1186 CMPXDbActiveTask::TChangeVisibility visible(GeneratePodcastFieldsValuesL(aEpisodeId, aMedia, aItemChangedMessages, |
|
1187 &aRecordset, *fields, *values, aDrive)); |
|
1188 |
|
1189 // construct the SET string |
|
1190 HBufC* setStr = MPXDbCommonUtil::StringFromArraysLC(*fields, *values, |
|
1191 KMCEqualSign, KMCCommaSign); |
|
1192 if (setStr->Length()) |
|
1193 { |
|
1194 // execute the query |
|
1195 iDbManager.ExecuteQueryL(aDrive, KQueryPodcastUpdate, setStr, aEpisodeId); |
|
1196 } |
|
1197 |
|
1198 CleanupStack::PopAndDestroy(setStr); |
|
1199 CleanupStack::PopAndDestroy(values); |
|
1200 CleanupStack::PopAndDestroy(fields); |
|
1201 |
|
1202 return visible; |
|
1203 } |
|
1204 |
|
1205 // ---------------------------------------------------------------------------- |
|
1206 // CMPXDbPodcast::DeleteRecordsetL |
|
1207 // ---------------------------------------------------------------------------- |
|
1208 // |
|
1209 void CMPXDbPodcast::DeleteRecordsetL( |
|
1210 RSqlStatement& aRecordset, |
|
1211 CDesCArray& aUriArray, |
|
1212 CMPXMessageArray& aItemChangedMessages, |
|
1213 TBool aDeleteRecord /* = EFalse */) |
|
1214 { |
|
1215 MPX_FUNC("CMPXDbPodcast::DeleteRecordsetL"); |
|
1216 |
|
1217 TInt err(KErrNone); |
|
1218 while ((err = aRecordset.Next()) == KSqlAtRow) |
|
1219 { |
|
1220 DoDeleteEpisodeL(aRecordset, aUriArray, aItemChangedMessages, aDeleteRecord); |
|
1221 } |
|
1222 |
|
1223 if (err!= KSqlAtEnd) |
|
1224 { |
|
1225 User::Leave(KErrCorrupt); |
|
1226 } |
|
1227 } |
|
1228 |
|
1229 // ---------------------------------------------------------------------------- |
|
1230 // Remove a episode from the podcast table |
|
1231 // ---------------------------------------------------------------------------- |
|
1232 // |
|
1233 void CMPXDbPodcast::DoDeleteEpisodeL( |
|
1234 RSqlStatement& aRecordset, |
|
1235 CDesCArray& aUriArray, |
|
1236 CMPXMessageArray& aItemChangedMessages, TBool IsAdd , |
|
1237 TBool aDeleteRecord) |
|
1238 { |
|
1239 MPX_FUNC("CMPXDbPodcast::DoDeleteEpisodeL"); |
|
1240 |
|
1241 // add the full path to the URI array |
|
1242 HBufC* uri = ConstructUriL(aRecordset); |
|
1243 CleanupStack::PushL(uri); |
|
1244 aUriArray.AppendL(*uri); |
|
1245 TDriveUnit driveUnit(*uri); |
|
1246 CleanupStack::PopAndDestroy(uri); |
|
1247 |
|
1248 //if adding then dont delete episode category |
|
1249 if(!IsAdd) |
|
1250 { |
|
1251 // process the author |
|
1252 iObserver.DeleteEpisodeForCategoryL(EMPXArtist, aRecordset.ColumnInt64(EPodcastArtist), |
|
1253 driveUnit, &aItemChangedMessages ); |
|
1254 |
|
1255 // process the title |
|
1256 iObserver.DeleteEpisodeForCategoryL(EMPXAlbum, aRecordset.ColumnInt64(EPodcastAlbum), |
|
1257 driveUnit, &aItemChangedMessages); |
|
1258 |
|
1259 // process the genre |
|
1260 iObserver.DeleteEpisodeForCategoryL(EMPXGenre, aRecordset.ColumnInt64(EPodcastGenre), |
|
1261 driveUnit, &aItemChangedMessages); |
|
1262 |
|
1263 // process the composer |
|
1264 iObserver.DeleteEpisodeForCategoryL(EMPXComposer, aRecordset.ColumnInt64(EPodcastComposer), |
|
1265 driveUnit, &aItemChangedMessages); |
|
1266 } |
|
1267 |
|
1268 |
|
1269 |
|
1270 // add a change event for removing the episode itself |
|
1271 TUint32 episodeId(aRecordset.ColumnInt64(EPodcastUniqueId)); |
|
1272 MPXDbCommonUtil::AddItemChangedMessageL(aItemChangedMessages, episodeId, |
|
1273 EMPXItemDeleted, EMPXPodcast, KDBPluginUid); |
|
1274 |
|
1275 // delete or update the episode |
|
1276 iDbManager.ExecuteQueryL(driveUnit, aDeleteRecord ? KQueryPodcastDelete() : |
|
1277 KQueryPodcastDeleteUpdate(), episodeId); |
|
1278 |
|
1279 MPX_DEBUG2(_L("CMPXDbPodcast::RemoveEpisodeL Removed episodeId[0x%x]"), episodeId); |
|
1280 } |
|
1281 |
|
1282 // ---------------------------------------------------------------------------- |
|
1283 // CMPXDbPodcast::GeneratePodcastFieldsValuesL |
|
1284 // ---------------------------------------------------------------------------- |
|
1285 // |
|
1286 CMPXDbActiveTask::TChangeVisibility CMPXDbPodcast::GeneratePodcastFieldsValuesL( |
|
1287 TUint32 aEpisodeId, |
|
1288 const CMPXMedia& aMedia, |
|
1289 CMPXMessageArray* aItemChangedMessages, |
|
1290 RSqlStatement* aPodcastTable, |
|
1291 CDesCArray& aFields, |
|
1292 CDesCArray& aValues, |
|
1293 TInt aDrive) |
|
1294 { |
|
1295 MPX_FUNC("CMPXDbMusic::GeneratePodcastFieldsValuesL"); |
|
1296 |
|
1297 CMPXDbActiveTask::TChangeVisibility visibleChange(CMPXDbActiveTask::ENotVisibile); |
|
1298 TBool metaDataModified(EFalse); |
|
1299 const TArray<TMPXAttribute> attributes = aMedia.Attributes(); |
|
1300 |
|
1301 CMPXMessage* episodeChangedMessage(NULL); |
|
1302 if (aItemChangedMessages) |
|
1303 { |
|
1304 episodeChangedMessage = CMPXMedia::NewL(); |
|
1305 CleanupStack::PushL(episodeChangedMessage); |
|
1306 MPXDbCommonUtil::FillItemChangedMessageL(*episodeChangedMessage, aEpisodeId, |
|
1307 aPodcastTable ? EMPXItemModified : EMPXItemInserted, EMPXPodcast, KDBPluginUid); |
|
1308 } |
|
1309 |
|
1310 TInt attrCount(attributes.Count()); |
|
1311 for (TInt i = 0; i < attrCount; ++i) |
|
1312 { |
|
1313 TInt contentId(attributes[i].ContentId()); |
|
1314 TUint attributeId(attributes[i].AttributeId()); |
|
1315 |
|
1316 switch (contentId) |
|
1317 { |
|
1318 case KMPXMediaIdGeneral: |
|
1319 { |
|
1320 if (attributeId & EMPXMediaGeneralTitle) |
|
1321 { |
|
1322 TBool titleChanged(NULL == aPodcastTable); |
|
1323 |
|
1324 const TDesC& title = aMedia.ValueText(KMPXMediaGeneralTitle); |
|
1325 TPtrC truncatedTitle(title.Left(KMCMaxTextLen)); |
|
1326 if (aPodcastTable) |
|
1327 { |
|
1328 // title of the song has been changed |
|
1329 if (truncatedTitle.Compare(aPodcastTable->ColumnTextL(EPodcastTitle)) != 0) |
|
1330 { |
|
1331 titleChanged = ETrue; |
|
1332 } |
|
1333 } |
|
1334 |
|
1335 if (titleChanged) |
|
1336 { |
|
1337 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastName, truncatedTitle); |
|
1338 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1339 metaDataModified = ETrue; |
|
1340 |
|
1341 MPX_DEBUG2(" Title[%S]", &truncatedTitle); |
|
1342 } |
|
1343 } |
|
1344 |
|
1345 if (attributeId & EMPXMediaGeneralUri) |
|
1346 { |
|
1347 const TDesC& uri = aMedia.ValueText(KMPXMediaGeneralUri); |
|
1348 const TDesC& uriTrunc(uri.Mid(KMCPathStartPos)); |
|
1349 |
|
1350 TDriveUnit driveUnit(uri); |
|
1351 TUint volId(MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), driveUnit)); |
|
1352 |
|
1353 if (!aPodcastTable || ((uriTrunc != aPodcastTable->ColumnTextL(EPodcastLocation)) || |
|
1354 (volId != aPodcastTable->ColumnInt64(EPodcastVolumeId)))) |
|
1355 { |
|
1356 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastVolumeId, volId); |
|
1357 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastLocation, uri.Mid(KMCPathStartPos)); |
|
1358 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastDRM, DRMTypeL(uri)); |
|
1359 |
|
1360 const TDesC& mimeTypeText = MPXDbCommonUtil::GetMimeTypeForUriL(uri).Des(); |
|
1361 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastMimeType, mimeTypeText); |
|
1362 |
|
1363 MPX_DEBUG3(" VolumeId[%u] Location[%S]", volId, &uri); |
|
1364 MPX_DEBUG2(" MimeType[%S]", &mimeTypeText); |
|
1365 |
|
1366 if (!aPodcastTable && !aMedia.IsSupported(KMPXMediaGeneralTitle)) |
|
1367 { |
|
1368 TParsePtrC parser(uri); |
|
1369 TPtrC title = parser.Name(); |
|
1370 // use file name as song name |
|
1371 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastName, title.Left(KMCMaxTextLen)); |
|
1372 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1373 |
|
1374 MPX_DEBUG2(" Title[%S]", &title); |
|
1375 } |
|
1376 |
|
1377 // URI of the song has been changed. This changes the Id of the song |
|
1378 if (aPodcastTable) |
|
1379 { |
|
1380 TUint32 newEpisodeId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), EMPXCollection, uri, EFalse); |
|
1381 if (aEpisodeId != newEpisodeId) |
|
1382 { |
|
1383 MPX_DEBUG3(" CurrentEpisodeId[0x%x] changed to [0x%x]", aEpisodeId, newEpisodeId); |
|
1384 |
|
1385 if (episodeChangedMessage) |
|
1386 { |
|
1387 episodeChangedMessage->SetTObjectValueL<TMPXItemId>(KMPXMessageMediaGeneralId, newEpisodeId); |
|
1388 episodeChangedMessage->SetTObjectValueL<TMPXItemId>(KMPXMessageMediaDeprecatedId, aEpisodeId); |
|
1389 } |
|
1390 |
|
1391 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastUniqueId, newEpisodeId); |
|
1392 } |
|
1393 } |
|
1394 } |
|
1395 } |
|
1396 |
|
1397 if (attributeId & EMPXMediaGeneralComment) |
|
1398 { |
|
1399 const TDesC& comment = aMedia.ValueText(KMPXMediaGeneralComment).Left(KMCMaxTextLen); |
|
1400 |
|
1401 if (!aPodcastTable || (comment != aPodcastTable->ColumnTextL(EPodcastComment))) |
|
1402 { |
|
1403 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastComment, comment); |
|
1404 metaDataModified = ETrue; |
|
1405 } |
|
1406 MPX_DEBUG2(" Comment[%S]", &comment); |
|
1407 } |
|
1408 |
|
1409 if (attributeId & EMPXMediaGeneralSynchronized) |
|
1410 { |
|
1411 TBool synced(aMedia.ValueTObjectL<TBool>(KMPXMediaGeneralSynchronized)); |
|
1412 if (!aPodcastTable || (synced != aPodcastTable->ColumnInt(EPodcastSync))) |
|
1413 { |
|
1414 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastSync, synced); |
|
1415 } |
|
1416 MPX_DEBUG2(" Synchronized[%d]", synced); |
|
1417 } |
|
1418 |
|
1419 if (attributeId & EMPXMediaGeneralDeleted) |
|
1420 { |
|
1421 TBool deleted(aMedia.ValueTObjectL<TBool>(KMPXMediaGeneralDeleted)); |
|
1422 if (!aPodcastTable || (deleted != aPodcastTable->ColumnInt(EPodcastDeleted))) |
|
1423 { |
|
1424 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastDel, deleted); |
|
1425 } |
|
1426 MPX_DEBUG2(" Deleted[%d]", deleted); |
|
1427 } |
|
1428 |
|
1429 if (attributeId & EMPXMediaGeneralModified) |
|
1430 { |
|
1431 TBool modified(aMedia.ValueTObjectL<TBool>(KMPXMediaGeneralModified)); |
|
1432 if (!aPodcastTable || (modified != aPodcastTable->ColumnInt(EPodcastModified))) |
|
1433 { |
|
1434 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastMod, modified); |
|
1435 } |
|
1436 MPX_DEBUG2(" Modified[%d]", modified); |
|
1437 } |
|
1438 |
|
1439 if (attributeId & EMPXMediaGeneralCopyright) |
|
1440 { |
|
1441 const TDesC& copyright = aMedia.ValueText(KMPXMediaGeneralCopyright).Left(KMCMaxTextLen); |
|
1442 if (!aPodcastTable || (copyright != aPodcastTable->ColumnTextL(EPodcastCopyright))) |
|
1443 { |
|
1444 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastCopyright, copyright); |
|
1445 metaDataModified = ETrue; |
|
1446 } |
|
1447 MPX_DEBUG2(" Copyright[%S]", ©right); |
|
1448 } |
|
1449 |
|
1450 if (attributeId & EMPXMediaGeneralDuration) |
|
1451 { |
|
1452 TInt duration(aMedia.ValueTObjectL<TInt>(KMPXMediaGeneralDuration)); |
|
1453 if (!aPodcastTable || (duration != aPodcastTable->ColumnInt(EPodcastDuration))) |
|
1454 { |
|
1455 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastDuration, duration); |
|
1456 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1457 metaDataModified = ETrue; |
|
1458 } |
|
1459 MPX_DEBUG2(" Duration[%d]", duration); |
|
1460 } |
|
1461 |
|
1462 if (attributeId & EMPXMediaGeneralFlags) |
|
1463 { |
|
1464 TUint flag(aMedia.ValueTObjectL<TUint>(KMPXMediaGeneralFlags)); |
|
1465 TUint32 curFlag(0); |
|
1466 if (aPodcastTable) |
|
1467 { |
|
1468 curFlag = aPodcastTable->ColumnInt64(EPodcastDbFlag); |
|
1469 } |
|
1470 TUint32 oldFlag(curFlag); |
|
1471 |
|
1472 if (flag & KMPXMediaGeneralFlagsSetOrUnsetBit) |
|
1473 { |
|
1474 // Set bits |
|
1475 curFlag |= flag; |
|
1476 } |
|
1477 else |
|
1478 { |
|
1479 // Clear bits |
|
1480 curFlag &= (~flag); |
|
1481 } |
|
1482 |
|
1483 // The field is written ONLY if the flag value is changing |
|
1484 if (((curFlag ^ oldFlag) & 0x7FFFFFFF) != 0) |
|
1485 { |
|
1486 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastDbFlag, curFlag); |
|
1487 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1488 } |
|
1489 MPX_DEBUG2(" GeneralFlags[%b]", curFlag); |
|
1490 } |
|
1491 |
|
1492 if (attributeId & EMPXMediaGeneralPlayCount) |
|
1493 { |
|
1494 TInt increment(aMedia.ValueTObjectL<TInt>(KMPXMediaGeneralPlayCount)); |
|
1495 TUint32 curCount(increment); |
|
1496 |
|
1497 // Only add to the current number if the value received is positive |
|
1498 // otherwise reset |
|
1499 if (curCount && aPodcastTable) |
|
1500 { |
|
1501 curCount += aPodcastTable->ColumnInt(EPodcastPlayCount); |
|
1502 } |
|
1503 |
|
1504 if (!aPodcastTable || (curCount != aPodcastTable->ColumnInt(EPodcastPlayCount))) |
|
1505 { |
|
1506 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastPlayCount, curCount); |
|
1507 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1508 } |
|
1509 MPX_DEBUG2(" PlayCount[%d]", curCount); |
|
1510 } |
|
1511 |
|
1512 if (attributeId & EMPXMediaGeneralLastPlaybackPosition) |
|
1513 { |
|
1514 TInt32 lastPlayPosition(aMedia.ValueTObjectL<TInt32>(KMPXMediaGeneralLastPlaybackPosition)); |
|
1515 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastIsPlaying, EFalse); |
|
1516 |
|
1517 if (!aPodcastTable || (lastPlayPosition != aPodcastTable->ColumnInt(EPodcastLastPlayPosition))) |
|
1518 { |
|
1519 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastLastPlayPosition, lastPlayPosition); |
|
1520 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1521 } |
|
1522 MPX_DEBUG2(" Last Playback Position[%d]", lastPlayPosition); |
|
1523 } |
|
1524 |
|
1525 if (attributeId & EMPXMediaGeneralLastPlaybackTime) |
|
1526 { |
|
1527 HBufC* time = MPXDbCommonUtil::TTimeToDesLC( |
|
1528 TTime(aMedia.ValueTObjectL<TInt64>(KMPXMediaGeneralLastPlaybackTime))); |
|
1529 if (!aPodcastTable || (*time != aPodcastTable->ColumnTextL(EPodcastTimePlayed))) |
|
1530 { |
|
1531 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastTimePlayed, *time); |
|
1532 } |
|
1533 MPX_DEBUG2(" PlaybackTime[%S]", time); |
|
1534 CleanupStack::PopAndDestroy(time); |
|
1535 } |
|
1536 } |
|
1537 break; |
|
1538 |
|
1539 case KMPXMediaIdMusic: |
|
1540 { |
|
1541 if (attributeId & EMPXMediaMusicAlbumTrack) |
|
1542 { |
|
1543 const TDesC& trackNumber = aMedia.ValueText(KMPXMediaMusicAlbumTrack); |
|
1544 |
|
1545 // KMaxTInt is used to represent null album track |
|
1546 TInt track(KMaxTInt); |
|
1547 if (trackNumber.Length()) |
|
1548 { |
|
1549 TLex stringParser(trackNumber); |
|
1550 if (stringParser.Val(track) != KErrNone) |
|
1551 { |
|
1552 track = KMaxTInt; |
|
1553 } |
|
1554 } |
|
1555 |
|
1556 if (!aPodcastTable || (track != aPodcastTable->ColumnInt(EPodcastAlbumTrack))) |
|
1557 { |
|
1558 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastTrackNumber, track); |
|
1559 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1560 metaDataModified = ETrue; |
|
1561 } |
|
1562 MPX_DEBUG3(" Album Track[%S][%d]", &trackNumber, track); |
|
1563 } |
|
1564 |
|
1565 if (attributeId & EMPXMediaMusicYear) |
|
1566 { |
|
1567 TInt64 int64(aMedia.ValueTObjectL<TInt64>(KMPXMediaMusicYear)); |
|
1568 |
|
1569 TTime maxTime(0); |
|
1570 maxTime += TTimeIntervalYears(9999); // Limit years to 4 characters |
|
1571 TTime time(int64); |
|
1572 |
|
1573 if (time > maxTime) |
|
1574 { |
|
1575 time = Time::NullTTime(); |
|
1576 } |
|
1577 |
|
1578 HBufC* timeStr = MPXDbCommonUtil::TTimeToDesLC(time); |
|
1579 if (!aPodcastTable || (*timeStr != aPodcastTable->ColumnTextL(EPodcastReleaseDate))) |
|
1580 { |
|
1581 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastReleaseDate, *timeStr); |
|
1582 metaDataModified = ETrue; |
|
1583 } |
|
1584 MPX_DEBUG2(" Music Year[%S]", timeStr); |
|
1585 CleanupStack::PopAndDestroy(timeStr); |
|
1586 } |
|
1587 |
|
1588 if (attributeId & EMPXMediaMusicRating) |
|
1589 { |
|
1590 TInt rating(aMedia.ValueTObjectL<TInt>(KMPXMediaMusicRating)); |
|
1591 |
|
1592 if (!aPodcastTable || (rating != aPodcastTable->ColumnInt(EPodcastRating))) |
|
1593 { |
|
1594 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastRating, rating); |
|
1595 metaDataModified = ETrue; |
|
1596 } |
|
1597 MPX_DEBUG2(" Rating[%d]", rating); |
|
1598 } |
|
1599 |
|
1600 if (attributeId & EMPXMediaMusicAlbumArtFileName) |
|
1601 { |
|
1602 const TDesC& albumArtFilename(aMedia.ValueText(KMPXMediaMusicAlbumArtFileName).Left(KMCMaxTextLen)); |
|
1603 if (!aPodcastTable || (albumArtFilename != aPodcastTable->ColumnTextL(EPodcastArt))) |
|
1604 { |
|
1605 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastArt, albumArtFilename); |
|
1606 metaDataModified = ETrue; |
|
1607 } |
|
1608 MPX_DEBUG2(" Album Art Filename[%S]", &albumArtFilename); |
|
1609 } |
|
1610 |
|
1611 if (attributeId & EMPXMediaMusicURL) |
|
1612 { |
|
1613 const TDesC& url(aMedia.ValueText(KMPXMediaMusicURL).Left(KMCMaxTextLen)); |
|
1614 if (!aPodcastTable || (url != aPodcastTable->ColumnTextL(EPodcastUrl))) |
|
1615 { |
|
1616 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastUrl, url); |
|
1617 metaDataModified = ETrue; |
|
1618 } |
|
1619 MPX_DEBUG2(" Music URL[%S]", &url); |
|
1620 } |
|
1621 } |
|
1622 break; |
|
1623 |
|
1624 case KMPXMediaIdAudio: |
|
1625 { |
|
1626 if (attributeId & EMPXMediaAudioSamplerate) |
|
1627 { |
|
1628 TInt samplerate(aMedia.ValueTObjectL<TInt>(KMPXMediaAudioSamplerate)); |
|
1629 if (!aPodcastTable || (samplerate != aPodcastTable->ColumnInt(EPodcastSampleRate))) |
|
1630 { |
|
1631 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastSampleRate, samplerate); |
|
1632 metaDataModified = ETrue; |
|
1633 } |
|
1634 MPX_DEBUG2(" Sample Rate[%d]", samplerate); |
|
1635 } |
|
1636 |
|
1637 if (attributeId & EMPXMediaAudioBitrate) |
|
1638 { |
|
1639 TInt bitrate(aMedia.ValueTObjectL<TInt>(KMPXMediaAudioBitrate)); |
|
1640 if (!aPodcastTable || (bitrate != aPodcastTable->ColumnInt(EPodcastBitRate))) |
|
1641 { |
|
1642 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastBitRate, bitrate); |
|
1643 metaDataModified = ETrue; |
|
1644 } |
|
1645 MPX_DEBUG2(" Bitrate[%d]", bitrate); |
|
1646 } |
|
1647 |
|
1648 if (attributeId & EMPXMediaAudioNumberOfChannels) |
|
1649 { |
|
1650 TUint32 val = aMedia.ValueTObjectL<TUint32>(KMPXMediaAudioNumberOfChannels); |
|
1651 if (!aPodcastTable || (val != aPodcastTable->ColumnInt(EPodcastNumChannels))) |
|
1652 { |
|
1653 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastNumChannels, val); |
|
1654 } |
|
1655 MPX_DEBUG2(" Num of Channels[%d]", val); |
|
1656 } |
|
1657 } |
|
1658 break; |
|
1659 |
|
1660 case KMPXMediaIdDrm: |
|
1661 { |
|
1662 if (attributeId & EMPXMediaDrmType) |
|
1663 { |
|
1664 TInt drmType(aMedia.ValueTObjectL<TInt>(KMPXMediaDrmType)); |
|
1665 if (!aPodcastTable || (drmType != aPodcastTable->ColumnInt(EPodcastDRM))) |
|
1666 { |
|
1667 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastDRM, drmType); |
|
1668 } |
|
1669 MPX_DEBUG2(" DRM type[%d]", drmType); |
|
1670 } |
|
1671 |
|
1672 if (attributeId & KMPXMediaDrmRightsStatus.iAttributeId) |
|
1673 { |
|
1674 if (aPodcastTable) |
|
1675 { |
|
1676 TMPXMediaDrmRightsStatus status = |
|
1677 aMedia.ValueTObjectL<TMPXMediaDrmRightsStatus>(KMPXMediaDrmRightsStatus); |
|
1678 |
|
1679 //.Set the db flag |
|
1680 TUint32 curFlag(aPodcastTable->ColumnInt64(EPodcastDbFlag)); |
|
1681 |
|
1682 if ((status != EMPXDrmRightsFull) && (status != EMPXDrmRightsRestricted)) |
|
1683 { |
|
1684 // No rights |
|
1685 curFlag |= KMPXMediaGeneralFlagsIsDrmLicenceInvalid; |
|
1686 } |
|
1687 else |
|
1688 { |
|
1689 // Rights valid |
|
1690 curFlag &= (KMPXMediaGeneralFlagsIsDrmLicenceInvalid ^ 0xFFFFFFFF); |
|
1691 } |
|
1692 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastDbFlag, curFlag); |
|
1693 MPX_DEBUG2(" Rights Status[%d]", curFlag); |
|
1694 } |
|
1695 } |
|
1696 |
|
1697 break; |
|
1698 } |
|
1699 |
|
1700 case KMPXMediaIdPodcast: |
|
1701 { |
|
1702 if (attributeId & EMPXMediaPodcastPubDate) |
|
1703 { |
|
1704 HBufC* time = MPXDbCommonUtil::TTimeToDesLC( |
|
1705 TTime(aMedia.ValueTObjectL<TInt64>(KMPXMediaPodcastPubDate))); |
|
1706 if (!aPodcastTable || (*time != aPodcastTable->ColumnTextL(EPodcastPublishDate))) |
|
1707 { |
|
1708 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastPublishDate, *time); |
|
1709 } |
|
1710 MPX_DEBUG2(" PublishDate[%S]", time); |
|
1711 CleanupStack::PopAndDestroy(time); |
|
1712 } |
|
1713 |
|
1714 if (attributeId & EMPXMediaPodcastIsPlaying) |
|
1715 { |
|
1716 TInt isPlaying = aMedia.ValueTObjectL<TBool>(KMPXMediaPodcastIsPlaying); |
|
1717 if (!aPodcastTable || (isPlaying != aPodcastTable->ColumnInt(EPodcastIsPlaying))) |
|
1718 { |
|
1719 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastIsPlaying, isPlaying); |
|
1720 } |
|
1721 MPX_DEBUG2(" IsPlaying[%d]", isPlaying); |
|
1722 } |
|
1723 |
|
1724 break; |
|
1725 } |
|
1726 |
|
1727 default: |
|
1728 break; |
|
1729 } // end switch |
|
1730 } // end for |
|
1731 |
|
1732 // get the current author/album/genre/composer |
|
1733 // this is required because the recordset may be reused by the code below |
|
1734 TUint32 artistId(0); |
|
1735 TUint32 albumId(0); |
|
1736 TUint32 genreId(0); |
|
1737 TUint32 composerId(0); |
|
1738 if (aPodcastTable) |
|
1739 { |
|
1740 artistId = aPodcastTable->ColumnInt64(EPodcastArtist); |
|
1741 albumId = aPodcastTable->ColumnInt64(EPodcastAlbum); |
|
1742 genreId = aPodcastTable->ColumnInt64(EPodcastGenre); |
|
1743 composerId = aPodcastTable->ColumnInt64(EPodcastComposer); |
|
1744 } |
|
1745 |
|
1746 // update the artist field |
|
1747 TUint32 id(0); |
|
1748 if (UpdateCategoryFieldL(EMPXArtist, aMedia, KMPXMediaMusicArtist, artistId, |
|
1749 aDrive, aItemChangedMessages, id)) |
|
1750 { |
|
1751 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastAuthor, id); |
|
1752 metaDataModified = (aPodcastTable != NULL); |
|
1753 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1754 } |
|
1755 |
|
1756 // update the album field |
|
1757 if (UpdateCategoryFieldL(EMPXAlbum, aMedia, KMPXMediaMusicAlbum, albumId, |
|
1758 aDrive, aItemChangedMessages, id)) |
|
1759 { |
|
1760 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastTitle, id); |
|
1761 metaDataModified = (aPodcastTable != NULL); |
|
1762 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1763 } |
|
1764 |
|
1765 // update the genre field |
|
1766 if (UpdateCategoryFieldL(EMPXGenre, aMedia, KMPXMediaMusicGenre, genreId, |
|
1767 aDrive, aItemChangedMessages, id)) |
|
1768 { |
|
1769 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastGenre, id); |
|
1770 metaDataModified = (aPodcastTable != NULL); |
|
1771 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1772 } |
|
1773 |
|
1774 // update the composer field |
|
1775 if (UpdateCategoryFieldL(EMPXComposer, aMedia, KMPXMediaMusicComposer, composerId, |
|
1776 aDrive, aItemChangedMessages, id)) |
|
1777 { |
|
1778 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastComposer, id); |
|
1779 metaDataModified = (aPodcastTable != NULL); |
|
1780 visibleChange = CMPXDbActiveTask::EAllVisible; |
|
1781 } |
|
1782 |
|
1783 #if defined (__MTP_PROTOCOL_SUPPORT) |
|
1784 // Set Mod bit to ETrue if metadata has been updated and caller hasn't explicitly |
|
1785 // set/reset it |
|
1786 if (aPodcastTable && |
|
1787 !aMedia.IsSupported(KMPXMediaGeneralModified) && |
|
1788 metaDataModified) |
|
1789 { |
|
1790 MPXDbCommonUtil::AppendValueL(aFields, aValues, KMCPodcastMod, 1); |
|
1791 MPX_DEBUG1(" Modified[1]"); |
|
1792 } |
|
1793 #endif |
|
1794 |
|
1795 if (aItemChangedMessages) |
|
1796 { |
|
1797 if (aFields.Count()) |
|
1798 { |
|
1799 aItemChangedMessages->AppendL(*episodeChangedMessage); |
|
1800 } |
|
1801 CleanupStack::PopAndDestroy(episodeChangedMessage); |
|
1802 } |
|
1803 |
|
1804 return visibleChange; |
|
1805 } |
|
1806 |
|
1807 // ---------------------------------------------------------------------------- |
|
1808 // CMPXDbMusic::UpdateCategoryFieldL |
|
1809 // ---------------------------------------------------------------------------- |
|
1810 // |
|
1811 TBool CMPXDbPodcast::UpdateCategoryFieldL( |
|
1812 TMPXGeneralCategory aCategory, |
|
1813 const CMPXMedia& aMedia, |
|
1814 const TMPXAttribute& aAttribute, |
|
1815 TUint32 aOldId, |
|
1816 TInt aDriveId, |
|
1817 CMPXMessageArray* aItemChangedMessages, |
|
1818 TUint32& aItemId) |
|
1819 { |
|
1820 MPX_FUNC("CMPXDbPodcast::UpdateCategoryFieldL"); |
|
1821 |
|
1822 TBool updated(EFalse); |
|
1823 |
|
1824 // update category table and add category Id to the podcast table |
|
1825 if (!aOldId || aMedia.IsSupported(aAttribute)) |
|
1826 { |
|
1827 if (aMedia.IsSupported(aAttribute)) |
|
1828 { |
|
1829 HBufC* name = aMedia.ValueText(aAttribute).AllocLC(); |
|
1830 name->Des().Trim(); |
|
1831 |
|
1832 // only genre is not case sensitive |
|
1833 aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, name->Left(KMCMaxTextLen), |
|
1834 (aCategory != EMPXGenre)); |
|
1835 if (!aOldId || (aOldId != aItemId)) |
|
1836 { |
|
1837 // only add if the ID changed, |
|
1838 // otherwise the song was updated but the artist name was not |
|
1839 |
|
1840 // ignore the return value |
|
1841 iObserver.AddCategoryItemL(aCategory, name->Left(KMCMaxTextLen), aDriveId, |
|
1842 aItemChangedMessages); |
|
1843 updated = ETrue; |
|
1844 } |
|
1845 |
|
1846 CleanupStack::PopAndDestroy(name); |
|
1847 } |
|
1848 else |
|
1849 { |
|
1850 // only genre is not case sensitive |
|
1851 aItemId = MPXDbCommonUtil::GenerateUniqueIdL(iDbManager.Fs(), aCategory, KNullDesC, |
|
1852 (aCategory != EMPXGenre)); |
|
1853 if (!aOldId || (aOldId != aItemId)) |
|
1854 { |
|
1855 // ignore the return value |
|
1856 iObserver.AddCategoryItemL(aCategory, KNullDesC, aDriveId, aItemChangedMessages); |
|
1857 updated = ETrue; |
|
1858 } |
|
1859 } |
|
1860 |
|
1861 if (aOldId && (aOldId != aItemId)) |
|
1862 { |
|
1863 iObserver.DeleteEpisodeForCategoryL(aCategory, aOldId, aDriveId, aItemChangedMessages); |
|
1864 updated = ETrue; |
|
1865 } |
|
1866 } |
|
1867 |
|
1868 return updated; |
|
1869 } |
|
1870 |
|
1871 // ---------------------------------------------------------------------------- |
|
1872 // Read episode detail info from DB into media object |
|
1873 // ---------------------------------------------------------------------------- |
|
1874 // |
|
1875 void CMPXDbPodcast::UpdateMediaL( |
|
1876 RSqlStatement& aPodcastTable, |
|
1877 const TArray<TMPXAttribute>& aAttrs, |
|
1878 CMPXMedia& aMedia) |
|
1879 { |
|
1880 MPX_FUNC("CMPXDbPodcast::UpdateMediaL"); |
|
1881 |
|
1882 TInt count(aAttrs.Count()); |
|
1883 for (TInt i = 0; i < count; ++i) |
|
1884 { |
|
1885 switch (aAttrs[i].ContentId()) |
|
1886 { |
|
1887 case KMPXMediaIdGeneral: |
|
1888 { |
|
1889 UpdateMediaGeneralL(aPodcastTable, aAttrs[i].AttributeId(), aMedia); |
|
1890 break; |
|
1891 } |
|
1892 case KMPXMediaIdMusic: |
|
1893 { |
|
1894 UpdateMediaMusicL(aPodcastTable, aAttrs[i].AttributeId(), aMedia); |
|
1895 break; |
|
1896 } |
|
1897 case KMPXMediaIdDrm: |
|
1898 { |
|
1899 // DRM is set by drm helper |
|
1900 break; |
|
1901 } |
|
1902 case KMPXMediaIdAudio: |
|
1903 { |
|
1904 UpdateMediaAudioL(aPodcastTable, aAttrs[i].AttributeId(), aMedia); |
|
1905 break; |
|
1906 } |
|
1907 case KMPXMediaIdPodcast: |
|
1908 { |
|
1909 UpdateMediaPodcastL(aPodcastTable, aAttrs[i].AttributeId(), aMedia); |
|
1910 break; |
|
1911 } |
|
1912 default: |
|
1913 // Do not leave. If this plugin doesn't support |
|
1914 // the content id they want, just return what we have |
|
1915 break; |
|
1916 } // end switch |
|
1917 } // end for |
|
1918 } |
|
1919 |
|
1920 // ---------------------------------------------------------------------------- |
|
1921 // Set all the attributes in CMPXMedia corresponding to KMPXMediaIdGeneral |
|
1922 // ---------------------------------------------------------------------------- |
|
1923 // |
|
1924 void CMPXDbPodcast::UpdateMediaGeneralL( |
|
1925 RSqlStatement& aPodcastTable, |
|
1926 TUint aAttrId, |
|
1927 CMPXMedia& aMedia) |
|
1928 { |
|
1929 MPX_FUNC("CMPXDbPodcast::UpdateMediaGeneralL"); |
|
1930 |
|
1931 aMedia.SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem); |
|
1932 aMedia.SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, EMPXPodcast); |
|
1933 |
|
1934 // FIX ME, temporary always fetch item ID |
|
1935 //if (aAttrId & EMPXMediaGeneralId) |
|
1936 if (!aMedia.IsSupported(KMPXMediaGeneralId)) |
|
1937 { |
|
1938 TUint32 episodeId(aPodcastTable.ColumnInt64(EPodcastUniqueId)); |
|
1939 aMedia.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, episodeId); |
|
1940 MPX_DEBUG2(" EpisodeId[%d]", episodeId); |
|
1941 } |
|
1942 // FIX ME temporary always fetch URI |
|
1943 //if (aAttrId & EMPXMediaGeneralUri) |
|
1944 if (!aMedia.IsSupported(KMPXMediaGeneralUri)) |
|
1945 { |
|
1946 HBufC* uri = ConstructUriL(aPodcastTable); |
|
1947 CleanupStack::PushL(uri); |
|
1948 aMedia.SetTextValueL(KMPXMediaGeneralUri, *uri); |
|
1949 |
|
1950 MPX_DEBUG2(" Uri[%S]", uri); |
|
1951 CleanupStack::PopAndDestroy(uri); |
|
1952 } |
|
1953 if (aAttrId & EMPXMediaGeneralDrive) |
|
1954 { |
|
1955 TDriveUnit driveUnit; |
|
1956 if (aMedia.IsSupported(KMPXMediaGeneralUri)) |
|
1957 { |
|
1958 driveUnit = aMedia.ValueText(KMPXMediaGeneralUri); |
|
1959 } |
|
1960 else |
|
1961 { |
|
1962 driveUnit = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), |
|
1963 aPodcastTable.ColumnInt64(EPodcastVolumeId)); |
|
1964 } |
|
1965 |
|
1966 TPtrC driveName(driveUnit.Name()); |
|
1967 aMedia.SetTextValueL(KMPXMediaGeneralDrive, driveName); |
|
1968 MPX_DEBUG2(" Drive[%S]", &driveName); |
|
1969 } |
|
1970 if (aAttrId & EMPXMediaGeneralSize) |
|
1971 { |
|
1972 // to-do: store this in the DB |
|
1973 HBufC* uri = ConstructUriL(aPodcastTable); |
|
1974 CleanupStack::PushL(uri); |
|
1975 aMedia.SetTextValueL(KMPXMediaGeneralUri, *uri); |
|
1976 |
|
1977 MPX_DEBUG2(" Uri[%S]", uri); |
|
1978 |
|
1979 TEntry entry; |
|
1980 RFs fs; |
|
1981 User::LeaveIfError(fs.Connect()); |
|
1982 CleanupClosePushL(fs); |
|
1983 fs.Entry(*uri, entry); |
|
1984 aMedia.SetTObjectValueL<TInt>( |
|
1985 TMPXAttribute(KMPXMediaIdGeneral, EMPXMediaGeneralSize), |
|
1986 entry.iSize); |
|
1987 |
|
1988 MPX_DEBUG2(" Size[%d]", entry.iSize); |
|
1989 |
|
1990 CleanupStack::PopAndDestroy(&fs); |
|
1991 CleanupStack::PopAndDestroy(uri); |
|
1992 } |
|
1993 if (aAttrId & EMPXMediaGeneralDuration) |
|
1994 { |
|
1995 TInt32 duration(aPodcastTable.ColumnInt(EPodcastDuration)); |
|
1996 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralDuration, duration); |
|
1997 MPX_DEBUG2(" Duration[%d]", duration); |
|
1998 } |
|
1999 if ((aAttrId & EMPXMediaGeneralTitle) && !aMedia.IsSupported(KMPXMediaGeneralTitle)) |
|
2000 { |
|
2001 TPtrC title(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastTitle)); |
|
2002 aMedia.SetTextValueL(KMPXMediaGeneralTitle, title); |
|
2003 MPX_DEBUG2(" Title[%S]", &title); |
|
2004 } |
|
2005 if (aAttrId & EMPXMediaGeneralDate) |
|
2006 { |
|
2007 const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastTimeAdded)); |
|
2008 if(dateStr.Compare(KNullDesC) != 0) |
|
2009 { |
|
2010 TTime dateTime(MPXDbCommonUtil::DesToTTimeL(dateStr)); |
|
2011 aMedia.SetTObjectValueL<TInt64>(KMPXMediaGeneralDate, dateTime.Int64()); |
|
2012 } |
|
2013 MPX_DEBUG2(" Date[%S]", &dateStr); |
|
2014 } |
|
2015 if (aAttrId & EMPXMediaGeneralComment) |
|
2016 { |
|
2017 TPtrC comment(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastComment)); |
|
2018 aMedia.SetTextValueL(KMPXMediaGeneralComment, comment); |
|
2019 MPX_DEBUG2(" Comment[%S]", &comment); |
|
2020 } |
|
2021 if (aAttrId & EMPXMediaGeneralMimeType) |
|
2022 { |
|
2023 TPtrC mimeType(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastMimeType)); |
|
2024 aMedia.SetTextValueL(KMPXMediaGeneralMimeType, mimeType); |
|
2025 MPX_DEBUG2(" MimeType[%S]", &mimeType); |
|
2026 } |
|
2027 if (aAttrId & EMPXMediaGeneralSynchronized) |
|
2028 { |
|
2029 TInt sync(aPodcastTable.ColumnInt(EPodcastSync)); |
|
2030 aMedia.SetTObjectValueL<TBool>(KMPXMediaGeneralSynchronized, sync); |
|
2031 MPX_DEBUG2(" Synchronized[%d]", sync); |
|
2032 } |
|
2033 if (aAttrId & EMPXMediaGeneralDeleted) |
|
2034 { |
|
2035 TInt del(aPodcastTable.ColumnInt(EPodcastDeleted)); |
|
2036 aMedia.SetTObjectValueL<TBool>(KMPXMediaGeneralDeleted, del); |
|
2037 MPX_DEBUG2(" Deleted[%d]", del); |
|
2038 } |
|
2039 if (aAttrId & EMPXMediaGeneralModified) |
|
2040 { |
|
2041 TInt mod(aPodcastTable.ColumnInt(EPodcastModified)); |
|
2042 aMedia.SetTObjectValueL<TBool>(KMPXMediaGeneralModified, mod); |
|
2043 MPX_DEBUG2(" Modified[%d]", mod); |
|
2044 } |
|
2045 if (aAttrId & EMPXMediaGeneralCount) |
|
2046 { |
|
2047 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralCount, 1); |
|
2048 } |
|
2049 if (aAttrId & EMPXMediaGeneralCollectionId) |
|
2050 { |
|
2051 aMedia.SetTObjectValueL<TUid>(KMPXMediaGeneralCollectionId , |
|
2052 TUid::Uid(KDBPluginUid)); |
|
2053 } |
|
2054 if (aAttrId & EMPXMediaGeneralCopyright) |
|
2055 { |
|
2056 TPtrC copyright(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastCopyright)); |
|
2057 aMedia.SetTextValueL(KMPXMediaGeneralCopyright, copyright); |
|
2058 MPX_DEBUG2(" Copyright[%S]", ©right); |
|
2059 } |
|
2060 if (aAttrId & EMPXMediaGeneralFlags) |
|
2061 { |
|
2062 TUint32 dbFlags(aPodcastTable.ColumnInt64(EPodcastDbFlag)); |
|
2063 TDriveUnit driveUnit; |
|
2064 if (aMedia.IsSupported(KMPXMediaGeneralUri)) |
|
2065 { |
|
2066 TParsePtrC parse( aMedia.ValueText(KMPXMediaGeneralUri) ); |
|
2067 if( parse.DrivePresent() ) |
|
2068 { |
|
2069 driveUnit = parse.Drive(); |
|
2070 } |
|
2071 else |
|
2072 { |
|
2073 driveUnit = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), |
|
2074 aPodcastTable.ColumnInt64(EPodcastVolumeId)); |
|
2075 } |
|
2076 } |
|
2077 else |
|
2078 { |
|
2079 driveUnit = MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), |
|
2080 aPodcastTable.ColumnInt64(EPodcastVolumeId)); |
|
2081 } |
|
2082 |
|
2083 TInt driveId = driveUnit & KMPXMediaGeneralFlagsDriveInfo; // 5 bits |
|
2084 aMedia.SetTObjectValueL<TUint>(KMPXMediaGeneralFlags, dbFlags | driveId); |
|
2085 |
|
2086 MPX_DEBUG2(" GeneralFlags[%b]", dbFlags | driveId); |
|
2087 MPX_DEBUG2(" DriveId[%u]", driveId); |
|
2088 } |
|
2089 if (aAttrId & EMPXMediaGeneralLastPlaybackPosition) |
|
2090 { |
|
2091 TInt32 lastPlaybackPosition(aPodcastTable.ColumnInt(EPodcastLastPlayPosition)); |
|
2092 aMedia.SetTObjectValueL<TInt32>(KMPXMediaGeneralLastPlaybackPosition, |
|
2093 lastPlaybackPosition); |
|
2094 MPX_DEBUG2(" LastPlayPosition[%d]", lastPlaybackPosition); |
|
2095 } |
|
2096 if (aAttrId & EMPXMediaGeneralPlayCount) |
|
2097 { |
|
2098 TUint32 playcount(aPodcastTable.ColumnInt(EPodcastPlayCount)); |
|
2099 aMedia.SetTObjectValueL<TInt>(KMPXMediaGeneralPlayCount, playcount); |
|
2100 MPX_DEBUG2(" PlayCount[%d]", playcount); |
|
2101 } |
|
2102 } |
|
2103 |
|
2104 // ---------------------------------------------------------------------------- |
|
2105 // Set all the attributes in CMPXMedia corresponding to KMPXMediaIdMusic |
|
2106 // ---------------------------------------------------------------------------- |
|
2107 // |
|
2108 void CMPXDbPodcast::UpdateMediaMusicL( |
|
2109 RSqlStatement& aPodcastTable, |
|
2110 TUint aAttrId, |
|
2111 CMPXMedia& aMedia) |
|
2112 { |
|
2113 MPX_FUNC("CMPXDbPodcast::UpdateMediaMusicL"); |
|
2114 |
|
2115 if (aAttrId & EMPXMediaMusicAlbumArtFileName) |
|
2116 { |
|
2117 TPtrC art(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastArt)); |
|
2118 aMedia.SetTextValueL(KMPXMediaMusicAlbumArtFileName, art); |
|
2119 MPX_DEBUG2(" Album Art File Name[%S]", &art); |
|
2120 } |
|
2121 if (aAttrId & EMPXMediaMusicArtist) |
|
2122 { |
|
2123 TPtrC artist(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastArtistName)); |
|
2124 aMedia.SetTextValueL(KMPXMediaMusicArtist, artist); |
|
2125 MPX_DEBUG2(" Artist[%S]", &artist); |
|
2126 } |
|
2127 if (aAttrId & EMPXMediaMusicAlbum) |
|
2128 { |
|
2129 TPtrC album(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastAlbumName)); |
|
2130 aMedia.SetTextValueL(KMPXMediaMusicAlbum, album); |
|
2131 MPX_DEBUG2(" Album[%S]", &album); |
|
2132 } |
|
2133 if (aAttrId & EMPXMediaMusicYear) |
|
2134 { |
|
2135 const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastReleaseDate)); |
|
2136 if(dateStr.Compare(KNullDesC) != 0) |
|
2137 { |
|
2138 TTime dateTime(MPXDbCommonUtil::DesToTTimeL(dateStr)); |
|
2139 aMedia.SetTObjectValueL<TInt64>(KMPXMediaMusicYear, dateTime.Int64()); |
|
2140 MPX_DEBUG2(" Year[%d]", dateTime.Int64()); |
|
2141 } |
|
2142 MPX_DEBUG2(" ReleaseDate[%S]", &dateStr); |
|
2143 } |
|
2144 if (aAttrId & EMPXMediaMusicAlbumTrack) |
|
2145 { |
|
2146 TInt32 track(aPodcastTable.ColumnInt(EPodcastAlbumTrack)); |
|
2147 HBufC* hbuf = HBufC::NewLC(KMCIntegerLen); |
|
2148 if (track != KMaxTInt) |
|
2149 { |
|
2150 hbuf->Des().AppendFormat(_L("%d"), track); |
|
2151 } |
|
2152 aMedia.SetTextValueL(KMPXMediaMusicAlbumTrack, *hbuf); |
|
2153 MPX_DEBUG3(" Album Track[%S][%d]", hbuf, track); |
|
2154 CleanupStack::PopAndDestroy(hbuf); |
|
2155 } |
|
2156 if (aAttrId & EMPXMediaMusicGenre) |
|
2157 { |
|
2158 TPtrC genre(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastGenreName)); |
|
2159 aMedia.SetTextValueL(KMPXMediaMusicGenre, genre); |
|
2160 MPX_DEBUG2(" Music Genre[%S]", &genre); |
|
2161 } |
|
2162 if (aAttrId & EMPXMediaMusicComposer) |
|
2163 { |
|
2164 TPtrC composer(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastComposerName)); |
|
2165 aMedia.SetTextValueL(KMPXMediaMusicComposer, composer); |
|
2166 MPX_DEBUG2(" Music Composer[%S]", &composer); |
|
2167 } |
|
2168 if (aAttrId & EMPXMediaMusicRating) |
|
2169 { |
|
2170 TUint32 rating(aPodcastTable.ColumnInt(EPodcastRating)); |
|
2171 aMedia.SetTObjectValueL<TUint32>(KMPXMediaMusicRating, rating); |
|
2172 MPX_DEBUG2(" Music Rating[%d]", rating); |
|
2173 } |
|
2174 if (aAttrId & EMPXMediaMusicURL) |
|
2175 { |
|
2176 TPtrC url(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastUrl)); |
|
2177 aMedia.SetTextValueL(KMPXMediaMusicURL, url); |
|
2178 MPX_DEBUG2(" Music URL[%S]", &url); |
|
2179 } |
|
2180 if (aAttrId & EMPXMediaMusicOriginalAlbumArtFileName) |
|
2181 { |
|
2182 // Always set original album art to be file path |
|
2183 // Maybe add a new column to db for future if services like rhapsody pushes jpgs to us |
|
2184 if (aMedia.IsSupported(KMPXMediaGeneralUri)) |
|
2185 { |
|
2186 const TDesC& uri(aMedia.ValueText(KMPXMediaGeneralUri)); |
|
2187 aMedia.SetTextValueL(KMPXMediaMusicOriginalAlbumArtFileName, uri); |
|
2188 MPX_DEBUG2(" Music Original Album Art FullPath[%S]", &uri); |
|
2189 } |
|
2190 else |
|
2191 { |
|
2192 HBufC* fullPath = ConstructUriL(aPodcastTable); |
|
2193 CleanupStack::PushL(fullPath); |
|
2194 aMedia.SetTextValueL(KMPXMediaMusicOriginalAlbumArtFileName, *fullPath); |
|
2195 MPX_DEBUG2(" Music Original Album Art FullPath[%S]", fullPath); |
|
2196 CleanupStack::PopAndDestroy(fullPath); |
|
2197 } |
|
2198 |
|
2199 } |
|
2200 } |
|
2201 |
|
2202 // ---------------------------------------------------------------------------- |
|
2203 // Set all the attributes in CMPXMedia corresponding to KMPXMediaIdAudio |
|
2204 // ---------------------------------------------------------------------------- |
|
2205 // |
|
2206 void CMPXDbPodcast::UpdateMediaAudioL( |
|
2207 RSqlStatement& aPodcastTable, |
|
2208 TUint aAttrId, |
|
2209 CMPXMedia& aMedia) |
|
2210 { |
|
2211 MPX_FUNC("CMPXDbPodcast::UpdateMediaAudioL"); |
|
2212 |
|
2213 if (aAttrId & EMPXMediaAudioBitrate) |
|
2214 { |
|
2215 TUint32 bitrate(aPodcastTable.ColumnInt(EPodcastBitRate)); |
|
2216 aMedia.SetTObjectValueL<TUint32>(KMPXMediaAudioBitrate, bitrate); |
|
2217 MPX_DEBUG2(" Bitrate[%d]", bitrate); |
|
2218 } |
|
2219 if (aAttrId & EMPXMediaAudioSamplerate) |
|
2220 { |
|
2221 TUint32 samplerate(aPodcastTable.ColumnInt(EPodcastSampleRate)); |
|
2222 aMedia.SetTObjectValueL<TUint32>(KMPXMediaAudioSamplerate, samplerate); |
|
2223 MPX_DEBUG2(" SampleRate[%d]", samplerate); |
|
2224 } |
|
2225 if (aAttrId & EMPXMediaAudioNumberOfChannels) |
|
2226 { |
|
2227 TUint32 numchannels(aPodcastTable.ColumnInt(EPodcastNumChannels)); |
|
2228 aMedia.SetTObjectValueL<TUint32>(KMPXMediaAudioNumberOfChannels, numchannels); |
|
2229 MPX_DEBUG2(" Num of Channels[%d]", numchannels); |
|
2230 } |
|
2231 if (aAttrId & EMPXMediaAudioCodec) |
|
2232 { |
|
2233 TUint32 codec(aPodcastTable.ColumnInt(EPodcastCodec)); |
|
2234 aMedia.SetTObjectValueL<TUint32>(KMPXMediaAudioAudioCodec, codec); |
|
2235 MPX_DEBUG2(" Audio Codec[%d]", codec); |
|
2236 } |
|
2237 } |
|
2238 |
|
2239 // ---------------------------------------------------------------------------- |
|
2240 // Set all the attributes in CMPXMedia corresponding to KMPXMediaIdPodcast |
|
2241 // ---------------------------------------------------------------------------- |
|
2242 // |
|
2243 void CMPXDbPodcast::UpdateMediaPodcastL( |
|
2244 RSqlStatement& aPodcastTable, |
|
2245 TUint aAttrId, |
|
2246 CMPXMedia& aMedia) |
|
2247 { |
|
2248 MPX_FUNC("CMPXDbPodcast::UpdateMediaPodcastL"); |
|
2249 |
|
2250 // This episode is currently being played so the playback |
|
2251 // flag needs to be toggled |
|
2252 if (aAttrId & EMPXMediaPodcastSetIsPlayingTrue) |
|
2253 { |
|
2254 SetIsPlayingL(aMedia.ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId), ETrue); |
|
2255 } |
|
2256 |
|
2257 if (aAttrId & EMPXMediaPodcastCategory) |
|
2258 { |
|
2259 TPtrC genre(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastGenreName)); |
|
2260 aMedia.SetTextValueL(KMPXMediaPodcastCategory, genre); |
|
2261 MPX_DEBUG2(" PodcastCategory[%S]", &genre); |
|
2262 } |
|
2263 if (aAttrId & EMPXMediaPodcastPubDate) |
|
2264 { |
|
2265 const TDesC& dateStr(MPXDbCommonUtil::GetColumnTextL(aPodcastTable, EPodcastPublishDate)); |
|
2266 if(dateStr.Compare(KNullDesC) != 0) |
|
2267 { |
|
2268 TTime dateTime(MPXDbCommonUtil::DesToTTimeL(dateStr)); |
|
2269 aMedia.SetTObjectValueL<TInt64>(KMPXMediaPodcastPubDate, dateTime.Int64()); |
|
2270 } |
|
2271 MPX_DEBUG2(" Publish Date[%S]", &dateStr); |
|
2272 } |
|
2273 if (aAttrId & EMPXMediaPodcastIsPlaying) |
|
2274 { |
|
2275 TInt isPlaying(aPodcastTable.ColumnInt(EPodcastIsPlaying)); |
|
2276 aMedia.SetTObjectValueL<TBool>(KMPXMediaPodcastIsPlaying, isPlaying); |
|
2277 MPX_DEBUG2(" IsPlaying[%d]", isPlaying); |
|
2278 } |
|
2279 |
|
2280 TInt lastPlayPos(0); |
|
2281 if (aMedia.IsSupported(KMPXMediaGeneralLastPlaybackPosition)) |
|
2282 { |
|
2283 lastPlayPos = aMedia.ValueTObjectL<TInt>(KMPXMediaGeneralLastPlaybackPosition); |
|
2284 } |
|
2285 |
|
2286 TUint32 playCount(0); |
|
2287 if (aMedia.IsSupported(KMPXMediaGeneralPlayCount)) |
|
2288 { |
|
2289 playCount = aMedia.ValueTObjectL<TUint32>(KMPXMediaGeneralPlayCount); |
|
2290 } |
|
2291 |
|
2292 // playcount is incremented after an episode is played to completion |
|
2293 if ((lastPlayPos != 0) && (playCount == 0)) |
|
2294 { |
|
2295 aMedia.SetTObjectValueL(KMPXMediaPodcastCategoryGroup, EMPXPartlyPlayed); |
|
2296 MPX_DEBUG1( "CMPXDbPodcast::DoSetMediaPodcastL() item is partly played" ); |
|
2297 } |
|
2298 else if ((lastPlayPos == 0) && (playCount == 0)) |
|
2299 { |
|
2300 aMedia.SetTObjectValueL(KMPXMediaPodcastCategoryGroup, EMPXNew); |
|
2301 } |
|
2302 else |
|
2303 { |
|
2304 aMedia.SetTObjectValueL(KMPXMediaPodcastCategoryGroup, EMPXCompletelyPlayed); |
|
2305 } |
|
2306 |
|
2307 aMedia.SetTObjectValueL(KMPXMediaPodcastType, EMPXPodcastItem); |
|
2308 } |
|
2309 |
|
2310 // ---------------------------------------------------------------------------- |
|
2311 // Validate podcast file |
|
2312 // ---------------------------------------------------------------------------- |
|
2313 // |
|
2314 TMCDrmType CMPXDbPodcast::DRMTypeL( |
|
2315 const TDesC& aFile) |
|
2316 { |
|
2317 MPX_FUNC("CMPXDbPodcast::DRMTypeL"); |
|
2318 |
|
2319 TMCDrmType drm = EMCDrmNone; |
|
2320 TInt pos(0); |
|
2321 TParsePtrC fullEntry(aFile); |
|
2322 TPtrC theExt = fullEntry.Ext(); |
|
2323 |
|
2324 if (iExtensionsDrm->Find(theExt,pos) == 0) |
|
2325 { |
|
2326 drm = MPXDbCommonUtil::GetDRMTypeL(aFile); |
|
2327 } |
|
2328 |
|
2329 return drm; |
|
2330 } |
|
2331 |
|
2332 // ---------------------------------------------------------------------------- |
|
2333 // Generate viewing columns for podcast table from attributes |
|
2334 // ---------------------------------------------------------------------------- |
|
2335 // |
|
2336 HBufC* CMPXDbPodcast::GeneratePodcastMatchingCriteriaLC( |
|
2337 TUint32 aGeneralId, |
|
2338 TUint32 aContainerId, |
|
2339 TMPXGeneralType aType, |
|
2340 TMPXPodcastType aPodcastType, |
|
2341 const CMPXMedia& aCriteria) |
|
2342 { |
|
2343 MPX_FUNC("CMPXDbPodcast::GeneratePodcastMatchingCriteriaLC"); |
|
2344 |
|
2345 const TArray<TMPXAttribute> criteria = aCriteria.Attributes(); |
|
2346 TInt criteriaCount(criteria.Count()); |
|
2347 |
|
2348 CDesCArrayFlat* sqlCriteria = new (ELeave) CDesCArrayFlat(criteriaCount); |
|
2349 CleanupStack::PushL(sqlCriteria); |
|
2350 |
|
2351 // If EMPXMediaGeneralDeleted is not defined, always unset the deleted bit for matching |
|
2352 if (!aCriteria.IsSupported(KMPXMediaGeneralDeleted)) |
|
2353 { |
|
2354 sqlCriteria->AppendL(KCriterionPodcastNotDeleted); |
|
2355 } |
|
2356 |
|
2357 TBool volumeAdded(EFalse); |
|
2358 for (TInt i = 0; i < criteriaCount; ++i) |
|
2359 { |
|
2360 const TMPXAttribute& criterion = criteria[i]; |
|
2361 |
|
2362 if (criterion == KMPXMediaGeneralId) |
|
2363 { |
|
2364 TInt category(MPX_ITEM_CATEGORY(aGeneralId)); |
|
2365 |
|
2366 // Set the type if no type is specified |
|
2367 if (aType == EMPXNoType) |
|
2368 { |
|
2369 aType = (category == EMPXCollection) ? EMPXItem : EMPXGroup; |
|
2370 } |
|
2371 |
|
2372 TPtrC ptr; |
|
2373 if ((aType == EMPXItem) && (category == EMPXCollection)) |
|
2374 { |
|
2375 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2376 KCriterionPodcastUniqueId, aGeneralId); |
|
2377 } |
|
2378 else if ((aType == EMPXGroup) && (category == EMPXArtist)) |
|
2379 { |
|
2380 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2381 KCriterionPodcastAuthor, aGeneralId); |
|
2382 } |
|
2383 else if ((aType == EMPXGroup) && (category == EMPXAlbum)) |
|
2384 { |
|
2385 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2386 KCriterionPodcastAlbum, aGeneralId); |
|
2387 } |
|
2388 else if ((aType == EMPXGroup) && (category == EMPXGenre)) |
|
2389 { |
|
2390 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2391 KCriterionPodcastGenre, aGeneralId); |
|
2392 } |
|
2393 else if ((aType == EMPXGroup) && (category == EMPXComposer)) |
|
2394 { |
|
2395 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2396 KCriterionPodcastComposer, aGeneralId); |
|
2397 } |
|
2398 else if ((aPodcastType == EMPXPodcastGroup) && (category == EMPXTitle)) |
|
2399 { |
|
2400 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2401 KCriterionPodcastAlbum, aGeneralId); |
|
2402 } |
|
2403 else if ((aType == EMPXGroup) && (category == EMPXNoCategory)) |
|
2404 { |
|
2405 HBufC* sqlCriterion = GeneratePublishDateCategoryCriteriaL(aGeneralId & 0x00FFFFFF); |
|
2406 sqlCriteria->AppendL(*sqlCriterion); |
|
2407 CleanupStack::PopAndDestroy(sqlCriterion); |
|
2408 } |
|
2409 else |
|
2410 { |
|
2411 User::Leave(KErrNotSupported); |
|
2412 } |
|
2413 } |
|
2414 else if (criterion == KMPXMediaGeneralContainerId) |
|
2415 { |
|
2416 TInt containerCategory(MPX_ITEM_CATEGORY(aContainerId)); |
|
2417 |
|
2418 if ((aType == EMPXGroup) && (containerCategory == EMPXArtist)) |
|
2419 { |
|
2420 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2421 KCriterionPodcastAuthor, aContainerId); |
|
2422 } |
|
2423 else if ((aType == EMPXGroup) && (containerCategory == EMPXAlbum)) |
|
2424 { |
|
2425 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, |
|
2426 KCriterionPodcastAlbum, aContainerId); |
|
2427 } |
|
2428 else |
|
2429 { |
|
2430 //User::Leave(KErrNotSupported); |
|
2431 } |
|
2432 } |
|
2433 else if (criterion == KMPXMediaGeneralTitle) |
|
2434 { |
|
2435 HBufC* title = MPXDbCommonUtil::ProcessPatternCharsLC( |
|
2436 aCriteria.ValueText(KMPXMediaGeneralTitle)); |
|
2437 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastTitle, *title); |
|
2438 CleanupStack::PopAndDestroy(title); |
|
2439 } |
|
2440 else if (criterion == KMPXMediaGeneralUri) |
|
2441 { |
|
2442 const TDesC& uri(aCriteria.ValueText(KMPXMediaGeneralUri)); |
|
2443 |
|
2444 // Only set the criteria if Uri is not null Des. a URI has to match to location and volume |
|
2445 // columns together. |
|
2446 if (uri != KNullDesC) |
|
2447 { |
|
2448 if (!volumeAdded) |
|
2449 { |
|
2450 TDriveUnit driveUnit(uri); |
|
2451 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastVolume, |
|
2452 MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), driveUnit)); |
|
2453 volumeAdded = ETrue; |
|
2454 } |
|
2455 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastUri, |
|
2456 uri.Mid(KMCPathStartPos)); |
|
2457 } |
|
2458 |
|
2459 } |
|
2460 else if (criterion == KMPXMediaGeneralDrive) |
|
2461 { |
|
2462 if (!volumeAdded) |
|
2463 { |
|
2464 // validate the drive letter, TDriveUnit panics if given drive isn't between |
|
2465 // 'A' to 'Z' |
|
2466 TDriveUnit driveUnit(aCriteria.ValueText(KMPXMediaGeneralDrive)); |
|
2467 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastVolume, |
|
2468 MPXDbCommonUtil::GetVolIdMatchDriveIdL(iDbManager.Fs(), driveUnit)); |
|
2469 volumeAdded = ETrue; |
|
2470 } |
|
2471 } |
|
2472 else if (criterion == KMPXMediaGeneralSynchronized) |
|
2473 { |
|
2474 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastSynchronized, |
|
2475 aCriteria.ValueTObjectL<TBool>(KMPXMediaGeneralSynchronized)); |
|
2476 } |
|
2477 else if (criterion == KMPXMediaGeneralDeleted) |
|
2478 { |
|
2479 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastDeleted, |
|
2480 aCriteria.ValueTObjectL<TBool>(KMPXMediaGeneralDeleted)); |
|
2481 } |
|
2482 else if (criterion == KMPXMediaGeneralModified) |
|
2483 { |
|
2484 MPXDbCommonUtil::AddSqlCriterionL(*sqlCriteria, KCriterionPodcastModified, |
|
2485 aCriteria.ValueTObjectL<TBool>(KMPXMediaGeneralModified)); |
|
2486 } |
|
2487 else |
|
2488 { |
|
2489 // to-do: provide searching ability on the rest of the fields |
|
2490 } |
|
2491 } |
|
2492 |
|
2493 // construct the final criteria string |
|
2494 HBufC* criteriaStr = MPXDbCommonUtil::StringFromArrayLC(*sqlCriteria, KMCAndKeyword); |
|
2495 |
|
2496 CleanupStack::Pop(criteriaStr); |
|
2497 CleanupStack::PopAndDestroy(sqlCriteria); |
|
2498 CleanupStack::PushL(criteriaStr); |
|
2499 |
|
2500 return criteriaStr; |
|
2501 } |
|
2502 |
|
2503 // ---------------------------------------------------------------------------- |
|
2504 // CMPXDbPodcast::GeneratePublishDateCategoryCriteriaL |
|
2505 // ---------------------------------------------------------------------------- |
|
2506 // |
|
2507 HBufC* CMPXDbPodcast::GeneratePublishDateCategoryCriteriaL( |
|
2508 const TUint& aPublishDateCategoryID) |
|
2509 { |
|
2510 MPX_FUNC("CMPXDbPodcast::GeneratePublishDateCategoryCriteriaL"); |
|
2511 |
|
2512 HBufC* criteriaBuffer(NULL); |
|
2513 |
|
2514 HBufC* now = MPXDbCommonUtil::CurrentDateDesLC(); |
|
2515 |
|
2516 switch (aPublishDateCategoryID + KPublishTodayPlaylistUID) |
|
2517 { |
|
2518 case KPublishTodayPlaylistUID: |
|
2519 { |
|
2520 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateToday(), |
|
2521 *now, *now); |
|
2522 break; |
|
2523 } |
|
2524 case KPublishYesterdayPlaylistUID: |
|
2525 { |
|
2526 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateYesterday(), |
|
2527 *now, *now); |
|
2528 break; |
|
2529 } |
|
2530 case KPublishThisWeekPlaylistUID: |
|
2531 { |
|
2532 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
2533 dayNo++; // shifted by 1 day to get correct results |
|
2534 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateBetween(), |
|
2535 *now, dayNo,*now, 1); |
|
2536 break; |
|
2537 } |
|
2538 case KPublishLastWeekPlaylistUID: |
|
2539 { |
|
2540 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
2541 dayNo++; // shifted by 1 day to get correct results |
|
2542 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateBetween(), |
|
2543 *now, dayNo + 7, *now, dayNo); |
|
2544 break; |
|
2545 } |
|
2546 case KPublish2WeeksAgoPlaylistUID: |
|
2547 { |
|
2548 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
2549 dayNo++; // shifted by 1 day to get correct results |
|
2550 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateBetween(), |
|
2551 *now, dayNo + 14, *now, dayNo + 7); |
|
2552 break; |
|
2553 } |
|
2554 case KPublish3WeeksAgoPlaylistUID: |
|
2555 { |
|
2556 TInt dayNo(MPXDbUtil::DayNoInWeek()); |
|
2557 dayNo++; // shifted by 1 day to get correct results |
|
2558 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateBetween(), |
|
2559 *now, dayNo + 21, *now, dayNo + 14); |
|
2560 break; |
|
2561 } |
|
2562 case KPublishLastMonthPlaylistUID: |
|
2563 { |
|
2564 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateLastMonth(), |
|
2565 *now, *now); |
|
2566 break; |
|
2567 } |
|
2568 case KPublishEarlierPlaylistUID: |
|
2569 { |
|
2570 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateEarlier(), |
|
2571 *now); |
|
2572 break; |
|
2573 } |
|
2574 case KPublishUnknownPlaylistUID: |
|
2575 { |
|
2576 criteriaBuffer = MPXDbCommonUtil::SqlCriterionLC(KCriterionPodcastPublishDateUnknown(), |
|
2577 *now); |
|
2578 break; |
|
2579 } |
|
2580 default: |
|
2581 { |
|
2582 User::Leave(KErrArgument); |
|
2583 } |
|
2584 } |
|
2585 |
|
2586 CleanupStack::Pop(criteriaBuffer); |
|
2587 CleanupStack::PopAndDestroy(now); |
|
2588 CleanupStack::PushL(criteriaBuffer); |
|
2589 |
|
2590 TPtrC ptr(criteriaBuffer->Left(248)); |
|
2591 MPX_DEBUG2("CriteriaBuffer: %S", &ptr); |
|
2592 |
|
2593 return criteriaBuffer; |
|
2594 } |
|
2595 |
|
2596 // ---------------------------------------------------------------------------- |
|
2597 // CMPXDbPodcast::ConstructUriL |
|
2598 // ---------------------------------------------------------------------------- |
|
2599 // |
|
2600 HBufC* CMPXDbPodcast::ConstructUriL( |
|
2601 RSqlStatement& aRecordset) |
|
2602 { |
|
2603 MPX_FUNC("CMPXDbPodcast::ConstructUriL"); |
|
2604 |
|
2605 return MPXDbCommonUtil::CreateFullPathL( |
|
2606 MPXDbCommonUtil::GetDriveIdMatchVolIdL(iDbManager.Fs(), aRecordset.ColumnInt64(EPodcastVolumeId)), |
|
2607 MPXDbCommonUtil::GetColumnTextL(aRecordset, EPodcastLocation)); |
|
2608 } |
|
2609 |
|
2610 // ---------------------------------------------------------------------------- |
|
2611 // CMPXDbPodcast::EpisodeExistsL |
|
2612 // ---------------------------------------------------------------------------- |
|
2613 // |
|
2614 TBool CMPXDbPodcast::EpisodeExistsL( |
|
2615 TUint32 aEpisodeId) |
|
2616 { |
|
2617 MPX_FUNC("CMPXDbPodcast::EpisodeExistsL"); |
|
2618 |
|
2619 RSqlStatement recordset(iDbManager.ExecuteSelectQueryL(KQueryPodcastVolume, aEpisodeId)); |
|
2620 TBool found = (recordset.Next() == KSqlAtRow); |
|
2621 recordset.Close(); |
|
2622 |
|
2623 return found; |
|
2624 } |
|
2625 |
|
2626 // ---------------------------------------------------------------------------- |
|
2627 // CMPXDbPodcast::ExtraFieldsRequired |
|
2628 // ---------------------------------------------------------------------------- |
|
2629 // |
|
2630 TBool CMPXDbPodcast::ExtraFieldsRequired( |
|
2631 const TArray<TMPXAttribute>& aAttrs) |
|
2632 { |
|
2633 MPX_FUNC("CMPXDbPodcast::ExtraFieldsRequired"); |
|
2634 |
|
2635 TBool extraRequired(EFalse); |
|
2636 TInt count(aAttrs.Count()); |
|
2637 for (TInt i = 0; i < count; ++i) |
|
2638 { |
|
2639 TUint attributeId(aAttrs[i].AttributeId()); |
|
2640 |
|
2641 if ((KMPXMediaIdMusic == aAttrs[i].ContentId()) && |
|
2642 ((attributeId & EMPXMediaMusicArtist) || |
|
2643 (attributeId & EMPXMediaMusicAlbum) || |
|
2644 (attributeId & EMPXMediaMusicGenre) || |
|
2645 (attributeId & EMPXMediaMusicComposer))) |
|
2646 { |
|
2647 // fields from category tables are required |
|
2648 extraRequired = ETrue; |
|
2649 break; |
|
2650 } |
|
2651 } |
|
2652 |
|
2653 return extraRequired; |
|
2654 } |
|
2655 |
|
2656 // ---------------------------------------------------------------------------- |
|
2657 // CMPXDbPodcast::ProcessPublishDateCategoryL |
|
2658 // ---------------------------------------------------------------------------- |
|
2659 // |
|
2660 void CMPXDbPodcast::ProcessPublishDateCategoryL( |
|
2661 const TMPXItemId& aPublishDateCategoryId, |
|
2662 CMPXMediaArray& aMediaArray) |
|
2663 { |
|
2664 MPX_FUNC("CMPXDbPodcast::ProcessPublishDateCategoryL"); |
|
2665 |
|
2666 TInt count(aMediaArray.Count()); |
|
2667 if ((aPublishDateCategoryId.iId2 > 0) && (count > 0)) |
|
2668 { |
|
2669 // last item within category, append category ID to aid in removal of |
|
2670 // all episodes within a Publish Date View category |
|
2671 aMediaArray[count - 1]->SetTObjectValueL<TMPXItemId>(KMPXMediaPodcastPubDateCategoryId, |
|
2672 aPublishDateCategoryId); |
|
2673 } |
|
2674 } |
|
2675 |
|
2676 // ---------------------------------------------------------------------------- |
|
2677 // CMPXDbPodcast::GetPlayingItemL |
|
2678 // ---------------------------------------------------------------------------- |
|
2679 // |
|
2680 TInt CMPXDbPodcast::GetPlayingItemL( |
|
2681 CMPXMediaArray& aMediaArray) |
|
2682 { |
|
2683 MPX_FUNC("CMPXDbPodcast::GetPlayingItemL"); |
|
2684 |
|
2685 TInt index(KErrNotFound); |
|
2686 TInt count(aMediaArray.Count()); |
|
2687 for (TInt i = 0; i < count; ++i) |
|
2688 { |
|
2689 CMPXMedia* media = aMediaArray[i]; |
|
2690 if (media->IsSupported(KMPXMediaPodcastIsPlaying) && |
|
2691 media->ValueTObjectL<TBool>(KMPXMediaPodcastIsPlaying)) |
|
2692 { |
|
2693 index = i; |
|
2694 break; |
|
2695 } |
|
2696 } |
|
2697 |
|
2698 return index; |
|
2699 } |
|
2700 |
|
2701 // ---------------------------------------------------------------------------- |
|
2702 // CMPXDbPodcast::CreateTableL |
|
2703 // ---------------------------------------------------------------------------- |
|
2704 // |
|
2705 void CMPXDbPodcast::CreateTableL( |
|
2706 RSqlDatabase& aDatabase, |
|
2707 TBool /* aCorruptTable */) |
|
2708 { |
|
2709 MPX_FUNC("CMPXDbPodcast::CreateTableL"); |
|
2710 |
|
2711 // Create the table |
|
2712 User::LeaveIfError(aDatabase.Exec(KPodcastCreateTable)); |
|
2713 } |
|
2714 |
|
2715 // ---------------------------------------------------------------------------- |
|
2716 // CMPXDbPodcast::DropTableL |
|
2717 // ---------------------------------------------------------------------------- |
|
2718 // |
|
2719 void CMPXDbPodcast::DropTableL( |
|
2720 RSqlDatabase& aDatabase) |
|
2721 { |
|
2722 MPX_FUNC("CMPXDbPodcast::DropTableL"); |
|
2723 User::LeaveIfError(aDatabase.Exec(KPodcastDropTable)); |
|
2724 } |
|
2725 |
|
2726 // ---------------------------------------------------------------------------- |
|
2727 // CMPXDbPodcast::CheckTableL |
|
2728 // ---------------------------------------------------------------------------- |
|
2729 // |
|
2730 TBool CMPXDbPodcast::CheckTableL( |
|
2731 RSqlDatabase& aDatabase) |
|
2732 { |
|
2733 MPX_FUNC("CMPXDbPodcast::CheckTableL"); |
|
2734 return DoCheckTable(aDatabase, KPodcastCheckTable); |
|
2735 } |
|
2736 |
|
2737 // End of file |