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