|
1 /* |
|
2 * Copyright (c) 2002-2007 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 the License "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: Offers interface to Epg database* |
|
15 */ |
|
16 |
|
17 |
|
18 |
|
19 |
|
20 #include <badesca.h> // CDesCArrayFlat |
|
21 #include <s32file.h> // CFileStore & CPermanentFileStore |
|
22 #include <bautils.h> // file helpers |
|
23 #include <eikenv.h> |
|
24 #include <sysutil.h> // SysUtil |
|
25 #include <centralrepository.h> |
|
26 |
|
27 #include "IptvLiveDataStructures.h" // CleanupResetAndDestroyPushL |
|
28 #include "CIptvMediaContent.h" |
|
29 #include "CIptvEpgCategory.h" |
|
30 #include "CIptvEpgContent.h" |
|
31 #include "CIptvUtil.h" |
|
32 #include "IptvDebug.h" |
|
33 |
|
34 #include "CIptvServer.h" |
|
35 #include "CIptvService.h" |
|
36 #include "CIptvEpgSession.h" |
|
37 #include "CIptvVodContentCategoryBriefDetails.h" |
|
38 #include "CIptvVodContentContentBriefDetails.h" |
|
39 #include "CIptvVodContentContentFullDetails.h" |
|
40 #include "CIptvMyVideosGlobalFileId.h" |
|
41 #include "CIptvEpgDb.h" |
|
42 #include "IptvServer.pan" |
|
43 #include "CIptvServiceManager.h" |
|
44 |
|
45 _LIT( KSqlAll, "*" ); |
|
46 _LIT( KHyp, "'" ); |
|
47 _LIT( KSqlSelect, "SELECT " ); |
|
48 _LIT( KSqlDot, ", " ); |
|
49 _LIT( KSqlFrom, " FROM " ); |
|
50 _LIT( KSqlWhere, " WHERE " ); |
|
51 _LIT( KSqlIs, " = " ); |
|
52 _LIT( KSqlAnd, " AND " ); |
|
53 _LIT( KSqlNot, " <> " ); |
|
54 _LIT( KSqlOr, " OR " ); |
|
55 _LIT( KSqlOrderBy, " ORDER BY " ); |
|
56 _LIT( KIptvTmp, ".tmp" ); |
|
57 _LIT( KEmptyString, "" ); |
|
58 |
|
59 const TInt KIptvDbVersion( 9 ); |
|
60 |
|
61 const TUint32 KIptvRootParent( 0xFFFFFFF ); |
|
62 const TInt KMaxCountOfFullDetails( 1 ); |
|
63 const TInt KMaxCountOfParentCategories( 1 ); |
|
64 const TInt KIptvFileId( 0 ); |
|
65 const TInt KIptvDrive( 0 ); |
|
66 const TInt KValueNotSet( -1 ); |
|
67 |
|
68 const TInt KIptvEpgManagerFreeSpace = 512000; // 500 KB |
|
69 |
|
70 const TInt KParentalControlOff( 0 ); |
|
71 |
|
72 const TIptvContentId KIptvInvalidContentId( |
|
73 static_cast<TIptvContentId>( KErrNotFound ) ); |
|
74 |
|
75 // ======== MEMBER FUNCTIONS ======== |
|
76 |
|
77 // -------------------------------------------------------------------------- |
|
78 // CIptvEpgDb::CIptvEpgDb |
|
79 // C++ default constructor can NOT contain any code, that |
|
80 // might leave. |
|
81 // -------------------------------------------------------------------------- |
|
82 // |
|
83 CIptvEpgDb::CIptvEpgDb( |
|
84 const TUint32& aServiceId, |
|
85 CIptvServer& aServer ) : |
|
86 iTmpDbOpen( EFalse ), |
|
87 iServiceId( aServiceId ), |
|
88 iServer( aServer ), |
|
89 iParentalControl( KParentalControlOff ) |
|
90 { |
|
91 } |
|
92 |
|
93 // -------------------------------------------------------------------------- |
|
94 // CIptvEpgDb::ConstructL |
|
95 // Second phase construction. Leaves, if RFs session cannot be created. |
|
96 // -------------------------------------------------------------------------- |
|
97 // |
|
98 void CIptvEpgDb::ConstructL( const TFileName& aEpgFile ) |
|
99 { |
|
100 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ConstructL" ); |
|
101 |
|
102 User::LeaveIfError( iFsSession.Connect() ); |
|
103 iEpgFile = aEpgFile; |
|
104 |
|
105 MakeSqlStrings(); |
|
106 TBool created = EFalse; |
|
107 CreateDbL( iEpgFile, created ); |
|
108 OpenDatabaseL( iEpgDb, iEpgFile ); |
|
109 |
|
110 // If new database created -> Set service information |
|
111 if ( created ) |
|
112 { |
|
113 TTime a( TInt64( 0 ) ); |
|
114 SetServiceInformationL( iEpgDb, a, a ); |
|
115 CreateRootCategoryL( iEpgDb ); |
|
116 created = EFalse; |
|
117 } |
|
118 |
|
119 // Read versio information from database |
|
120 iEpgDb.Compact(); |
|
121 TInt version = 0; |
|
122 version = GetVersionL(); |
|
123 if ( version != KIptvDbVersion ) |
|
124 { |
|
125 iEpgDb.Close(); |
|
126 // Delete old database. |
|
127 CFileMan* fileMan = CFileMan::NewL( iFsSession ); |
|
128 CleanupStack::PushL( fileMan ); |
|
129 fileMan->Delete( iEpgFile ); |
|
130 CleanupStack::PopAndDestroy( fileMan ); |
|
131 |
|
132 // Create new database with current version of database tables. |
|
133 CreateDbL( iEpgFile, created ); |
|
134 OpenDatabaseL( iEpgDb, iEpgFile ); |
|
135 |
|
136 // If new database created -> Set service information |
|
137 if ( created ) |
|
138 { |
|
139 TTime a( TInt64( 0 ) ); |
|
140 SetServiceInformationL( iEpgDb, a, a ); |
|
141 CreateRootCategoryL( iEpgDb ); |
|
142 } |
|
143 } |
|
144 |
|
145 TRAPD( ret, iCenRepSession = CRepository::NewL( KIptvCenRepUid ) ); |
|
146 |
|
147 if ( ret == KErrNone && iCenRepSession ) |
|
148 { |
|
149 // Register CenRep change notifier. |
|
150 iCenRepNotifyHandler = CCenRepNotifyHandler::NewL( |
|
151 *this, |
|
152 *iCenRepSession, |
|
153 CCenRepNotifyHandler::EIntKey, |
|
154 KIptvCenRepParentControlKey ); |
|
155 iCenRepNotifyHandler->StartListeningL(); |
|
156 |
|
157 // Read settings from CenRep. |
|
158 ReadCenRepData(); |
|
159 } |
|
160 } |
|
161 |
|
162 // -------------------------------------------------------------------------- |
|
163 // CIptvEpgDb::GetVersionL() |
|
164 // |
|
165 // Get database version |
|
166 // -------------------------------------------------------------------------- |
|
167 // |
|
168 TInt CIptvEpgDb::GetVersionL() |
|
169 { |
|
170 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetVersionL" ); |
|
171 |
|
172 TInt version = 0; |
|
173 |
|
174 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
175 TPtr16 sqlPtr = sql->Des(); |
|
176 |
|
177 sqlPtr.Append( KSqlSelect ); |
|
178 sqlPtr.Append( KSqlAll ); |
|
179 sqlPtr.Append( KSqlFrom ); |
|
180 sqlPtr.Append( KIptvEpgServiceTable ); |
|
181 |
|
182 RDbView view; |
|
183 TBool found = EFalse; |
|
184 TInt error = view.Prepare( |
|
185 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
186 |
|
187 CleanupStack::PopAndDestroy( sql ); |
|
188 |
|
189 if ( error == KErrNone ) |
|
190 { |
|
191 TInt count = view.ColCount(); |
|
192 if ( count > 0 ) |
|
193 { |
|
194 for ( TInt i = 1; i <= count; i++ ) |
|
195 { |
|
196 TDbCol col = view.ColDef( i ); |
|
197 if ( col.iName.Compare( KIptvEpgServiceVersion ) == 0 ) |
|
198 { |
|
199 found = ETrue; |
|
200 } |
|
201 } |
|
202 } |
|
203 } |
|
204 |
|
205 if ( found ) |
|
206 { |
|
207 view.EvaluateAll(); |
|
208 view.FirstL(); |
|
209 CDbColSet* colSet = view.ColSetL(); |
|
210 CleanupStack::PushL( colSet ); |
|
211 TInt versionCol = colSet->ColNo( KIptvEpgServiceVersion ); |
|
212 CleanupStack::PopAndDestroy( colSet ); |
|
213 |
|
214 TRAPD( getError, view.GetL() ); |
|
215 if ( getError != KErrNone ) |
|
216 { |
|
217 view.Close(); |
|
218 } |
|
219 |
|
220 version = view.ColUint32( versionCol ); |
|
221 } |
|
222 |
|
223 view.Close(); |
|
224 return version; |
|
225 } |
|
226 |
|
227 // -------------------------------------------------------------------------- |
|
228 // CIptvEpgDb::OpenDatabaseL() |
|
229 // |
|
230 // Open database |
|
231 // -------------------------------------------------------------------------- |
|
232 // |
|
233 void CIptvEpgDb::OpenDatabaseL( RDbNamedDatabase& aDb, const TDesC& aFile ) |
|
234 { |
|
235 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::OpenDatabaseL" ); |
|
236 |
|
237 TInt error = aDb.Open( iFsSession, aFile ); |
|
238 if ( error != KErrNone ) |
|
239 { |
|
240 if ( error != KErrNoMemory && |
|
241 error != KErrLocked && |
|
242 error != KErrDisMounted && |
|
243 error != KErrDiskFull && |
|
244 error != KErrNotReady ) |
|
245 { |
|
246 // Delete the database file. Cannot recover. |
|
247 CFileMan* fileMan = CFileMan::NewL( iFsSession ); |
|
248 CleanupStack::PushL( fileMan ); |
|
249 fileMan->Delete( aFile ); |
|
250 CleanupStack::PopAndDestroy( fileMan ); |
|
251 User::Leave( error ); |
|
252 } |
|
253 else |
|
254 { |
|
255 User::Leave( error ); |
|
256 } |
|
257 } |
|
258 } |
|
259 |
|
260 // -------------------------------------------------------------------------- |
|
261 // CIptvEpgDb::NewL |
|
262 // Two-phased constructor. |
|
263 // -------------------------------------------------------------------------- |
|
264 // |
|
265 CIptvEpgDb* CIptvEpgDb::NewL( |
|
266 const TFileName& aEpgFile, |
|
267 const TUint32& aServiceId, |
|
268 CIptvServer& aServer ) |
|
269 { |
|
270 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::NewL" ); |
|
271 |
|
272 CIptvEpgDb* self = new ( ELeave ) CIptvEpgDb( aServiceId, aServer ); |
|
273 CleanupStack::PushL( self ); |
|
274 self->ConstructL( aEpgFile ); |
|
275 CleanupStack::Pop( self ); |
|
276 |
|
277 return self; |
|
278 } |
|
279 |
|
280 // -------------------------------------------------------------------------- |
|
281 // CIptvEpgDb::~CIptvEpgDb() |
|
282 // Destructor |
|
283 // -------------------------------------------------------------------------- |
|
284 // |
|
285 CIptvEpgDb::~CIptvEpgDb() |
|
286 { |
|
287 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::~CIptvEpgDb" ); |
|
288 |
|
289 iEpgDb.Close(); |
|
290 if ( iDeleteDatabaseFiles ) |
|
291 { |
|
292 TRAP_IGNORE( DeleteDatabaseL() ) |
|
293 } |
|
294 |
|
295 if ( iTmpDbOpen ) |
|
296 { |
|
297 iTmpDb.Close(); |
|
298 } |
|
299 |
|
300 iFsSession.Close(); |
|
301 |
|
302 if ( iCenRepNotifyHandler ) |
|
303 { |
|
304 iCenRepNotifyHandler->StopListening(); |
|
305 delete iCenRepNotifyHandler; |
|
306 } |
|
307 |
|
308 delete iCenRepSession; |
|
309 } |
|
310 |
|
311 // -------------------------------------------------------------------------- |
|
312 // CIptvEpgDb::CreateDbL() |
|
313 // |
|
314 // Create a new database. |
|
315 // -------------------------------------------------------------------------- |
|
316 // |
|
317 void CIptvEpgDb::CreateDbL( const TDesC& aFile, TBool& aCreated ) |
|
318 { |
|
319 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateDbL" ); |
|
320 |
|
321 if ( !BaflUtils::FileExists( iFsSession, aFile ) ) |
|
322 { |
|
323 // Before creating any new databases, check that there is enough disk space. |
|
324 TBool checkResult = EFalse; |
|
325 TRAPD( |
|
326 checkError, checkResult = SysUtil::DiskSpaceBelowCriticalLevelL( |
|
327 &iFsSession, KIptvEpgManagerFreeSpace, EDriveC ) ); |
|
328 if ( checkError != KErrNone || checkResult ) |
|
329 { |
|
330 // Not enough space on disk, return immediately and do not create databases. |
|
331 User::Leave( KErrDiskFull ); |
|
332 } |
|
333 |
|
334 TRAPD( error, |
|
335 { |
|
336 RDbNamedDatabase database; |
|
337 User::LeaveIfError( database.Create( iFsSession, aFile ) ); |
|
338 CleanupClosePushL( database ); |
|
339 |
|
340 CreateCategoryTableL( database ); |
|
341 CreateCategoryIndexL( database ); |
|
342 |
|
343 CreateContentTableL( database ); |
|
344 CreateContentIndexL( database ); |
|
345 |
|
346 CreateCategoryContentTableL( database ); |
|
347 CreateCategoryContentIndexL( database ); |
|
348 |
|
349 CreateServiceTableL( database ); |
|
350 CreateContentAccessTableL( database ); |
|
351 CleanupStack::PopAndDestroy(); // database |
|
352 aCreated = ETrue; |
|
353 } ); |
|
354 |
|
355 if ( error != KErrNone ) |
|
356 { |
|
357 // Delete the database file. Cannot recover. |
|
358 CFileMan* fileMan = CFileMan::NewL( iFsSession ); |
|
359 CleanupStack::PushL( fileMan ); |
|
360 fileMan->Delete( aFile ); |
|
361 CleanupStack::PopAndDestroy( fileMan ); |
|
362 IPTVLOGSTRING_LOW_LEVEL( |
|
363 "CIptvEpgDb::CreateDbL --- PANIC --- Failed to create epg database" ); |
|
364 User::Panic( KIptvEpgDb, EFailedToCreateEpgDatabase ); |
|
365 } |
|
366 } |
|
367 } |
|
368 |
|
369 // -------------------------------------------------------------------------- |
|
370 // CIptvEpgDb::CreateRootCategoryL() |
|
371 // -------------------------------------------------------------------------- |
|
372 // |
|
373 void CIptvEpgDb::CreateRootCategoryL( RDbNamedDatabase& aDb ) const |
|
374 { |
|
375 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateRootCategoryL" ); |
|
376 |
|
377 CIptvEpgCategory* root = CIptvEpgCategory::NewL(); |
|
378 root->iName = KEmptyString; |
|
379 root->iParentKey = KIptvRootParent; |
|
380 CleanupStack::PushL( root ); |
|
381 TUint32 key; |
|
382 AddCategoryL( aDb, *root, key ); |
|
383 if ( key != KIptvVodContentCategoryRootId ) |
|
384 { |
|
385 IPTVLOGSTRING_LOW_LEVEL( |
|
386 "CIptvEpgDb::CreateRootCategoryL --- PANIC --- Failed to create root category" ); |
|
387 User::Panic( KIptvEpgDb, EIptvFailedToCreateRootCategory ); |
|
388 } |
|
389 |
|
390 CleanupStack::PopAndDestroy( root ); |
|
391 } |
|
392 |
|
393 // -------------------------------------------------------------------------- |
|
394 // CIptvEpgDb::CreateContentAccessTableL() |
|
395 // |
|
396 // Creates ContentAccess table. Leaves, if the table cannot be created. |
|
397 // -------------------------------------------------------------------------- |
|
398 // |
|
399 TInt CIptvEpgDb::CreateContentAccessTableL( |
|
400 RDbNamedDatabase& aDatabase ) const |
|
401 { |
|
402 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateContentAccessTableL" ); |
|
403 |
|
404 // Content key |
|
405 TDbCol contentKeyCol( |
|
406 KIptvCAContentKey, EDbColUint32 ); |
|
407 |
|
408 // Content URL |
|
409 TDbCol contentUrlCol( |
|
410 KIptvCAContentUrl, EDbColLongText, KIptvCAContentUrlLength ); |
|
411 |
|
412 // Download type |
|
413 TDbCol dlTypeCol( KIptvCADlType, EDbColUint32 ); |
|
414 |
|
415 // Language |
|
416 TDbCol languageCol( KIptvCALanguage, EDbColText, KIptvCALanguageLength ); |
|
417 |
|
418 // Price |
|
419 TDbCol priceCol( KIptvCAPrice, EDbColText, KIptvCAPriceLength ); |
|
420 |
|
421 // Purchase type |
|
422 TDbCol purchaceTypeCol( KIptvCAPurchaseType, EDbColUint32 ); |
|
423 |
|
424 // Purchase URL |
|
425 TDbCol purchaseUrlCol( |
|
426 KIptvCAPurchaseUrl, EDbColLongText, KIptvCAPurchaseUrlLength ); |
|
427 |
|
428 // Last play position |
|
429 TDbCol lastPlayPositionCol( KIptvCALastPlayPosition, EDbColUint32 ); |
|
430 |
|
431 // Mime type |
|
432 TDbCol mimeTypeCol( KIptvCAMimeType, EDbColText, KIptvCAMimeTypeLength ); |
|
433 |
|
434 // FileSize |
|
435 TDbCol fileSizeCol( KIptvCAFileSize, EDbColUint32 ); |
|
436 |
|
437 // Duration |
|
438 TDbCol durationCol( KIptvCADuration, EDbColUint32 ); |
|
439 |
|
440 // File id |
|
441 TDbCol fileIdCol( KIptvCAFileId, EDbColUint32 ); |
|
442 |
|
443 // Drive id |
|
444 TDbCol driveIdCol( KIptvCADriveId, EDbColUint32 ); |
|
445 |
|
446 // Index |
|
447 TDbCol indexCol( KIptvCAIndex, EDbColUint32 ); |
|
448 |
|
449 // Expression |
|
450 TDbCol expressionCol( KIptvCAExpression, EDbColUint32 ); |
|
451 |
|
452 CDbColSet* colSet = CDbColSet::NewLC(); |
|
453 colSet->AddL( contentKeyCol ); |
|
454 colSet->AddL( contentUrlCol ); |
|
455 colSet->AddL( dlTypeCol ); |
|
456 colSet->AddL( languageCol ); |
|
457 colSet->AddL( priceCol ); |
|
458 colSet->AddL( purchaceTypeCol ); |
|
459 colSet->AddL( purchaseUrlCol ); |
|
460 colSet->AddL( lastPlayPositionCol ); |
|
461 colSet->AddL( mimeTypeCol ); |
|
462 colSet->AddL( fileSizeCol ); |
|
463 colSet->AddL( durationCol ); |
|
464 colSet->AddL( fileIdCol ); |
|
465 colSet->AddL( driveIdCol ); |
|
466 colSet->AddL( indexCol ); |
|
467 colSet->AddL( expressionCol ); |
|
468 |
|
469 TInt error = aDatabase.CreateTable( KIptvCATable, *colSet ); |
|
470 CleanupStack::PopAndDestroy( colSet ); |
|
471 |
|
472 return error; |
|
473 } |
|
474 |
|
475 // -------------------------------------------------------------------------- |
|
476 // CIptvEpgDb::CreateServiceTableL() |
|
477 // |
|
478 // Creates Service table. Leaves, if the table cannot be created. |
|
479 // -------------------------------------------------------------------------- |
|
480 // |
|
481 TInt CIptvEpgDb::CreateServiceTableL( RDbNamedDatabase& aDatabase ) const |
|
482 { |
|
483 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateServiceTableL" ); |
|
484 |
|
485 // Last update key |
|
486 TDbCol lastUpdateKeyCol( KIptvEpgServiceLastUpdate, EDbColDateTime ); |
|
487 |
|
488 // Next update |
|
489 TDbCol nextUpdateKeyCol( KIptvEpgServiceNextUpdate, EDbColDateTime ); |
|
490 |
|
491 // ETag |
|
492 TDbCol eTagCol( KIptvEpgServiceETag, EDbColText, KIptvEpgDbLastModifiedMaxLength ); |
|
493 |
|
494 // LastModifiedSince |
|
495 TDbCol lastModifiedSinceCol(KIptvEpgServiceLastModifiedSince, EDbColText, KIptvEpgDbLastModifiedMaxLength); |
|
496 |
|
497 // Hash string from service XML file |
|
498 TDbCol xmlFileHashCol( KIptvEpgServiceXmlFileHash, EDbColText, KIptvEpgDbXmlFileHashMaxLength ); |
|
499 |
|
500 // Version |
|
501 TDbCol versionKeyCol( KIptvEpgServiceVersion, EDbColUint32 ); |
|
502 |
|
503 CDbColSet* colSet = CDbColSet::NewLC(); |
|
504 colSet->AddL( lastUpdateKeyCol ); |
|
505 colSet->AddL( nextUpdateKeyCol ); |
|
506 colSet->AddL( eTagCol ); |
|
507 colSet->AddL( lastModifiedSinceCol ); |
|
508 colSet->AddL( xmlFileHashCol ); |
|
509 colSet->AddL( versionKeyCol ); |
|
510 |
|
511 TInt error = aDatabase.CreateTable( KIptvEpgServiceTable, *colSet ); |
|
512 CleanupStack::PopAndDestroy( colSet ); |
|
513 return error; |
|
514 } |
|
515 |
|
516 // -------------------------------------------------------------------------- |
|
517 // CIptvEpgDb::CreateCategoryContentTableL() |
|
518 // |
|
519 // Creates CategoryContent table. Leaves, if the table cannot be created. |
|
520 // -------------------------------------------------------------------------- |
|
521 // |
|
522 void CIptvEpgDb::CreateCategoryContentTableL( |
|
523 RDbNamedDatabase& aDatabase ) const |
|
524 { |
|
525 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateCategoryContentTableL" ); |
|
526 |
|
527 // Category key |
|
528 TDbCol categoryKeyCol( KIptvEpgCategoryContentCategoryKeyCol, EDbColUint32 ); |
|
529 |
|
530 // Content key |
|
531 TDbCol contentKeyCol( KIptvEpgCategoryContentContentKeyCol, EDbColUint32 ); |
|
532 |
|
533 CDbColSet* colSet = CDbColSet::NewLC(); |
|
534 colSet->AddL( categoryKeyCol ); |
|
535 colSet->AddL( contentKeyCol ); |
|
536 |
|
537 TInt error = aDatabase.CreateTable( KIptvEpgCategoryContentTable, *colSet ); |
|
538 if ( error != KErrNone ) |
|
539 { |
|
540 IPTVLOGSTRING2_LOW_LEVEL( |
|
541 "CIptvEpgDb::CreateCategoryContentTableL error = %d", error ); |
|
542 } |
|
543 |
|
544 CleanupStack::PopAndDestroy( colSet ); |
|
545 } |
|
546 |
|
547 // -------------------------------------------------------------------------- |
|
548 // CIptvEpgDb::CreateContentTableL() |
|
549 // |
|
550 // Creates Content table. Leaves, if the table cannot be created. |
|
551 // -------------------------------------------------------------------------- |
|
552 // |
|
553 TInt CIptvEpgDb::CreateContentTableL( RDbNamedDatabase& aDatabase ) const |
|
554 { |
|
555 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateContentTableL" ); |
|
556 |
|
557 // Key |
|
558 TDbCol keyCol( KIptvEpgContentDbKeyCol, EDbColUint32 ); |
|
559 keyCol.iAttributes = TDbCol::EAutoIncrement; |
|
560 |
|
561 // Id |
|
562 TDbCol idCol( KIptvEpgContentDbIdCol, EDbColText, KIptvIdMaxLength ); |
|
563 |
|
564 // Name |
|
565 TDbCol nameCol( |
|
566 KIptvEpgContentDbNameCol, EDbColText, KIptvEpgContentNameMaxLength ); |
|
567 |
|
568 // File Id |
|
569 TDbCol fileIdCol( |
|
570 KIptvEpgContentDbFileIdCol, EDbColUint32 ); |
|
571 |
|
572 // Drive |
|
573 TDbCol driveCol( KIptvEpgContentDbDriveIdCol, EDbColUint32 ); |
|
574 |
|
575 // Preview file id |
|
576 TDbCol pFileIdCol( KIptvEpgContentDbPreviewFileIdCol, EDbColUint32 ); |
|
577 |
|
578 // Preview drive id |
|
579 TDbCol pDriveId( KIptvEpgContentDbPreviewDriveIdCol, EDbColUint32 ); |
|
580 |
|
581 // Content protection |
|
582 TDbCol contentProtectionCol( |
|
583 KIptvEpgContentDbContentProtectionCol, EDbColUint32 ); |
|
584 |
|
585 // Icon file Id |
|
586 TDbCol iconFileIdCol( KIptvEpgContentDbIconFileIdCol, EDbColUint32 ); |
|
587 |
|
588 // IsIconFilePathUrl |
|
589 TDbCol isIconFilePathUrlCol( |
|
590 KIptvEpgContentDbIsIconFilePathUrlCol, EDbColUint32 ); |
|
591 |
|
592 // Icon file path (full path + filename) |
|
593 TDbCol iconFilePathCol( |
|
594 KIptvEpgContentDbIconFilePathCol, |
|
595 EDbColText, |
|
596 KIptvEpgContentIconFilePathMaxLength ); |
|
597 |
|
598 // Content file Id |
|
599 TDbCol contentFileIdCol( |
|
600 KIptvEpgContentDbContentFileIdCol, EDbColUint32 ); |
|
601 |
|
602 // Description |
|
603 TDbCol descriptionCol( |
|
604 KIptvEpgContentDbDescriptionCol, |
|
605 EDbColText, |
|
606 KIptvEpgContentDescriptionMaxLength ); |
|
607 |
|
608 // PubDate |
|
609 TDbCol pubDateCol( KIptvEpgContentDbPubDateCol, EDbColDateTime ); |
|
610 |
|
611 // Browser url |
|
612 TDbCol browserUrlCol( |
|
613 KIptvEpgContentDbBrowserUrlCol, |
|
614 EDbColLongText, |
|
615 KIptvEpgContentBrowserUrlMaxLength ); |
|
616 |
|
617 // Order |
|
618 TDbCol orderCol( KIptvEpgContentDbOrderCol, EDbColUint32 ); |
|
619 |
|
620 // Author |
|
621 TDbCol authorCol( |
|
622 KIptvEpgContentDbAuthorCol, |
|
623 EDbColText, |
|
624 KIptvEpgContentAuthorLength ); |
|
625 |
|
626 // Copyright |
|
627 TDbCol copyrightCol( |
|
628 KIptvEpgContentDbCopyrightCol, |
|
629 EDbColText, |
|
630 KIptvEpgContentCopyrightLength ); |
|
631 |
|
632 // Size |
|
633 TDbCol sizeCol( KIptvEpgContentDbSizeCol, EDbColUint32 ); |
|
634 |
|
635 // Duration |
|
636 TDbCol durationCol( KIptvEpgContentDbDurationCol, EDbColUint32 ); |
|
637 |
|
638 // Language |
|
639 TDbCol languageCol( |
|
640 KIptvEpgContentDbLanguageCol, EDbColText, KIptvCALanguageLength ); |
|
641 |
|
642 // RatingAge |
|
643 TDbCol ratingAgeCol( |
|
644 KIptvEpgContentDbRatingAgeCol, EDbColUint16 ); |
|
645 |
|
646 CDbColSet* contentColSet = CDbColSet::NewLC(); |
|
647 contentColSet->AddL( keyCol ); |
|
648 contentColSet->AddL( idCol ); |
|
649 contentColSet->AddL( nameCol ); |
|
650 contentColSet->AddL( fileIdCol ); |
|
651 contentColSet->AddL( driveCol ); |
|
652 contentColSet->AddL( pFileIdCol ); |
|
653 contentColSet->AddL( pDriveId ); |
|
654 contentColSet->AddL( contentProtectionCol ); |
|
655 contentColSet->AddL( iconFileIdCol ); |
|
656 contentColSet->AddL( isIconFilePathUrlCol ); |
|
657 contentColSet->AddL( iconFilePathCol ); |
|
658 contentColSet->AddL( contentFileIdCol ); |
|
659 contentColSet->AddL( descriptionCol ); |
|
660 contentColSet->AddL( pubDateCol ); |
|
661 contentColSet->AddL( browserUrlCol ); |
|
662 contentColSet->AddL( orderCol ); |
|
663 contentColSet->AddL( authorCol ); |
|
664 contentColSet->AddL( copyrightCol ); |
|
665 contentColSet->AddL( sizeCol ); |
|
666 contentColSet->AddL( durationCol ); |
|
667 contentColSet->AddL( languageCol ); |
|
668 contentColSet->AddL( ratingAgeCol ); |
|
669 |
|
670 TInt error = |
|
671 aDatabase.CreateTable( KIptvEpgContentTable, *contentColSet ); |
|
672 CleanupStack::PopAndDestroy( contentColSet ); |
|
673 |
|
674 return error; |
|
675 } |
|
676 |
|
677 // -------------------------------------------------------------------------- |
|
678 // CIptvEpgDb::CreateContentIndexL() |
|
679 // |
|
680 // Creates an index for Content table. |
|
681 // Leaves, if the index cannot be created. |
|
682 // -------------------------------------------------------------------------- |
|
683 // |
|
684 void CIptvEpgDb::CreateContentIndexL( RDbNamedDatabase& aDatabase ) const |
|
685 { |
|
686 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateContentIndexL" ); |
|
687 |
|
688 TDbKeyCol keyCol( KIptvEpgContentDbKeyCol ); |
|
689 CDbKey* index = CDbKey::NewLC(); |
|
690 index->AddL( keyCol ); |
|
691 index->MakeUnique(); |
|
692 User::LeaveIfError( aDatabase.CreateIndex( |
|
693 KIptvEpgContentDbIndexName, KIptvEpgContentTable, *index ) ); |
|
694 CleanupStack::PopAndDestroy( index ); |
|
695 } |
|
696 |
|
697 // -------------------------------------------------------------------------- |
|
698 // CIptvEpgDb::CreateCategoryContentIndexL() |
|
699 // |
|
700 // Creates an index for CategoryContent table. |
|
701 // Leaves, if the index cannot be created. |
|
702 // -------------------------------------------------------------------------- |
|
703 // |
|
704 void CIptvEpgDb::CreateCategoryContentIndexL( |
|
705 RDbNamedDatabase& aDatabase ) const |
|
706 { |
|
707 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateCategoryContentIndexL" ); |
|
708 |
|
709 TDbKeyCol catCol( KIptvEpgCategoryContentCategoryKeyCol ); |
|
710 TDbKeyCol contCol( KIptvEpgCategoryContentContentKeyCol ); |
|
711 |
|
712 CDbKey* index = CDbKey::NewLC(); |
|
713 index->AddL( contCol ); |
|
714 index->AddL( catCol ); |
|
715 index->MakeUnique(); |
|
716 User::LeaveIfError( aDatabase.CreateIndex( |
|
717 KIptvEpgCategoryContentDbIndexName, |
|
718 KIptvEpgCategoryContentTable, *index ) ); |
|
719 CleanupStack::PopAndDestroy( index ); |
|
720 } |
|
721 |
|
722 // -------------------------------------------------------------------------- |
|
723 // CIptvEpgDb::CreateCategoryTableL() |
|
724 // |
|
725 // Creates Category table. Leaves, if the table cannot be created. |
|
726 // -------------------------------------------------------------------------- |
|
727 // |
|
728 TInt CIptvEpgDb::CreateCategoryTableL( RDbNamedDatabase& aDatabase ) const |
|
729 { |
|
730 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateCategoryTableL" ); |
|
731 |
|
732 // Key |
|
733 TDbCol keyCol( KIptvEpgCategoryDbKeyCol, EDbColUint32 ); |
|
734 keyCol.iAttributes = TDbCol::EAutoIncrement; |
|
735 |
|
736 // Parent key |
|
737 TDbCol parentKeyCol( KIptvEpgCategoryDbParentKeyCol, EDbColUint32 ); |
|
738 |
|
739 // Id |
|
740 TDbCol idCol( KIptvEpgCategoryDbIdCol, EDbColText, KIptvIdMaxLength ); |
|
741 |
|
742 // Name |
|
743 TDbCol nameCol( KIptvEpgCategoryDbNameCol, EDbColText, |
|
744 KIptvEpgCategoryNameMaxLength ); |
|
745 |
|
746 // Icon file Id - Obsolete field |
|
747 TDbCol iconFileIdCol( KIptvEpgCategoryDbIconFileIdCol, EDbColUint32 ); |
|
748 |
|
749 // IsIconFilePathUrl - Obsolete field |
|
750 TDbCol isIconFilePathUrlCol( KIptvEpgCategoryDbIsIconFilePathUrlCol, |
|
751 EDbColUint32 ); |
|
752 |
|
753 // Icon file path - Obsolete field |
|
754 TDbCol iconFilePathCol( KIptvEpgCategoryDbIconFilePathCol, EDbColText, |
|
755 KIptvEpgCategoryIconFilePathMaxLength ); |
|
756 |
|
757 // PubDate - Obsolete field |
|
758 TDbCol pubDateCol( KIptvEpgCategoryDbPubDateCol, EDbColDateTime ); |
|
759 |
|
760 // Description |
|
761 TDbCol descriptionCol( KIptvEpgCategoryDbDescriptionCol, EDbColText, |
|
762 KIptvEpgCategoryDescriptionMaxLength ); |
|
763 |
|
764 // Content count |
|
765 TDbCol contentCountCol( KIptvEpgCategoryDbContentCountCol, EDbColUint32 ); |
|
766 |
|
767 CDbColSet* categoryColSet = CDbColSet::NewLC(); |
|
768 categoryColSet->AddL( keyCol ); |
|
769 categoryColSet->AddL( idCol ); |
|
770 categoryColSet->AddL( parentKeyCol ); |
|
771 categoryColSet->AddL( nameCol ); |
|
772 categoryColSet->AddL( iconFileIdCol ); |
|
773 categoryColSet->AddL( isIconFilePathUrlCol ); // Obsolete field |
|
774 categoryColSet->AddL( iconFilePathCol ); // Obsolete field |
|
775 categoryColSet->AddL( pubDateCol ); // Obsolete field |
|
776 categoryColSet->AddL( descriptionCol ); |
|
777 categoryColSet->AddL( contentCountCol ); |
|
778 |
|
779 TInt error = |
|
780 aDatabase.CreateTable( KIptvEpgCategoryTable, *categoryColSet ); |
|
781 CleanupStack::PopAndDestroy( categoryColSet ); |
|
782 |
|
783 return error; |
|
784 } |
|
785 |
|
786 // -------------------------------------------------------------------------- |
|
787 // CIptvEpgDb::CreateCategoryIndexL() |
|
788 // |
|
789 // Creates an index for Category table. Leaves, if the index cannot be |
|
790 // created. |
|
791 // -------------------------------------------------------------------------- |
|
792 // |
|
793 void CIptvEpgDb::CreateCategoryIndexL( RDbNamedDatabase& aDatabase ) const |
|
794 { |
|
795 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateCategoryIndexL" ); |
|
796 |
|
797 TDbKeyCol keyCol( KIptvEpgCategoryDbKeyCol ); |
|
798 CDbKey* index = CDbKey::NewLC(); |
|
799 index->AddL( keyCol ); |
|
800 index->MakeUnique(); |
|
801 User::LeaveIfError( aDatabase.CreateIndex( |
|
802 KIptvEpgCategoryDbIndexName, KIptvEpgCategoryTable, *index ) ); |
|
803 CleanupStack::PopAndDestroy( index ); |
|
804 } |
|
805 |
|
806 // Database insert and update methods |
|
807 // from MIptvEpgPluginManager interface |
|
808 |
|
809 // -------------------------------------------------------------------------- |
|
810 // CIptvEpgDb::AddCategoryL() |
|
811 // |
|
812 // -------------------------------------------------------------------------- |
|
813 // |
|
814 TInt CIptvEpgDb::AddCategoryL( |
|
815 RDbNamedDatabase& aDb, |
|
816 CIptvEpgCategory& aCategory, |
|
817 TUint32& aCategoryKey ) const |
|
818 { |
|
819 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::AddCategoryL" ); |
|
820 |
|
821 RDbView view; |
|
822 TInt error = KErrNone; |
|
823 error = view.Prepare( |
|
824 aDb, TDbQuery( iSqlCategory ), TDbWindow::EUnlimited, |
|
825 RDbView::EInsertOnly ); |
|
826 if ( error == KErrNone ) |
|
827 { |
|
828 view.InsertL(); |
|
829 WriteCategoryToDbL( view, aCategory ); |
|
830 view.PutL(); |
|
831 |
|
832 // Get new category key |
|
833 CDbColSet* colSet = view.ColSetL(); |
|
834 TInt keyColumnNo = colSet->ColNo( KIptvEpgCategoryDbKeyCol ); |
|
835 delete colSet; |
|
836 aCategoryKey = view.ColUint32( keyColumnNo ); |
|
837 view.Close(); |
|
838 } |
|
839 |
|
840 return error; |
|
841 } |
|
842 |
|
843 // -------------------------------------------------------------------------- |
|
844 // CIptvEpgDb::AddCategoryL() |
|
845 // -------------------------------------------------------------------------- |
|
846 // |
|
847 TInt CIptvEpgDb::AddCategoryL( |
|
848 CIptvEpgCategory& aCategory, |
|
849 TUint32& aCategoryKey ) |
|
850 { |
|
851 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::AddCategoryL" ); |
|
852 |
|
853 RDbView view; |
|
854 TInt error = KErrNone; |
|
855 error = view.Prepare( |
|
856 iTmpDb, |
|
857 TDbQuery( iSqlCategory ), |
|
858 TDbWindow::EUnlimited, |
|
859 RDbView::EInsertOnly ); |
|
860 |
|
861 if ( error == KErrNone ) |
|
862 { |
|
863 view.InsertL(); |
|
864 WriteCategoryToDbL( view, aCategory ); |
|
865 view.PutL(); |
|
866 |
|
867 // Get new category key |
|
868 CDbColSet* colSet = view.ColSetL(); |
|
869 TInt keyColumnNo = colSet->ColNo( KIptvEpgCategoryDbKeyCol ); |
|
870 delete colSet; |
|
871 aCategoryKey = view.ColUint32( keyColumnNo ); |
|
872 view.Close(); |
|
873 } |
|
874 |
|
875 return error; |
|
876 } |
|
877 |
|
878 // -------------------------------------------------------------------------- |
|
879 // CIptvEpgDb::WriteCategoryToDbL() |
|
880 // -------------------------------------------------------------------------- |
|
881 // |
|
882 void CIptvEpgDb::WriteCategoryToDbL( |
|
883 RDbView& aView, CIptvEpgCategory& aCategory ) const |
|
884 { |
|
885 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::WriteCategoryToDbL" ); |
|
886 |
|
887 CDbColSet* categoryColSet = aView.ColSetL(); |
|
888 CleanupStack::PushL( categoryColSet ); |
|
889 |
|
890 // Key (is auto-increment) |
|
891 |
|
892 // Parent key |
|
893 aView.SetColL( |
|
894 categoryColSet->ColNo( KIptvEpgCategoryDbParentKeyCol ), |
|
895 aCategory.iParentKey ); |
|
896 |
|
897 // Id |
|
898 aView.SetColL( |
|
899 categoryColSet->ColNo( KIptvEpgCategoryDbIdCol ), |
|
900 aCategory.iId ); |
|
901 |
|
902 // Name |
|
903 aView.SetColL( |
|
904 categoryColSet->ColNo( KIptvEpgCategoryDbNameCol ), |
|
905 aCategory.iName ); |
|
906 |
|
907 // Icon file Id |
|
908 aView.SetColL( |
|
909 categoryColSet->ColNo( KIptvEpgCategoryDbIconFileIdCol ), |
|
910 aCategory.iIconFileId ); // Obsolete field |
|
911 |
|
912 // IsIconFilePathUrl |
|
913 aView.SetColL( |
|
914 categoryColSet->ColNo( KIptvEpgCategoryDbIsIconFilePathUrlCol ), |
|
915 aCategory.iIsIconFilePathUrl ); // Obsolete field |
|
916 |
|
917 // Icon file path |
|
918 aView.SetColL( |
|
919 categoryColSet->ColNo( KIptvEpgCategoryDbIconFilePathCol ), |
|
920 aCategory.iIconFilePath ); // Obsolete field |
|
921 |
|
922 // Pub date |
|
923 aView.SetColL( |
|
924 categoryColSet->ColNo( KIptvEpgCategoryDbPubDateCol ), |
|
925 aCategory.iPubDate ); // Obsolete field |
|
926 |
|
927 // Description |
|
928 aView.SetColL( |
|
929 categoryColSet->ColNo( KIptvEpgCategoryDbDescriptionCol ), |
|
930 aCategory.iDescription ); |
|
931 |
|
932 // Content count |
|
933 aView.SetColL( |
|
934 categoryColSet->ColNo( KIptvEpgCategoryDbContentCountCol ), |
|
935 aCategory.iContentCount ); |
|
936 |
|
937 CleanupStack::PopAndDestroy( categoryColSet ); |
|
938 } |
|
939 |
|
940 // -------------------------------------------------------------------------- |
|
941 // CIptvEpgDb::AddContentL() |
|
942 // -------------------------------------------------------------------------- |
|
943 // |
|
944 TInt CIptvEpgDb::AddContentL( |
|
945 CIptvEpgContent& aContent, |
|
946 RPointerArray<CIptvMediaContent> aMediaContents, |
|
947 TUint32& aContentKey ) |
|
948 { |
|
949 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::AddContentL" ); |
|
950 |
|
951 RDbView view; |
|
952 TInt error = KErrNone; |
|
953 error = view.Prepare( |
|
954 iTmpDb, TDbQuery( iSqlContent ), |
|
955 TDbWindow::EUnlimited, |
|
956 RDbView::EInsertOnly ); |
|
957 if ( error == KErrNone ) |
|
958 { |
|
959 view.InsertL(); |
|
960 WriteContentToDbL( view, aContent, EFalse ); |
|
961 view.PutL(); |
|
962 |
|
963 // Get new content key |
|
964 CDbColSet* colSet = view.ColSetL(); |
|
965 TInt keyColumnNo = colSet->ColNo( KIptvEpgContentDbKeyCol ); |
|
966 delete colSet; |
|
967 aContentKey = view.ColUint32( keyColumnNo ); |
|
968 view.Close(); |
|
969 } |
|
970 |
|
971 // Add media contents |
|
972 TInt count = aMediaContents.Count(); |
|
973 if ( count > 0 ) |
|
974 { |
|
975 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
976 TPtr16 sqlPtr = sql->Des(); |
|
977 |
|
978 sqlPtr.Append( KSqlSelect ); |
|
979 sqlPtr.Append( KSqlAll ); |
|
980 sqlPtr.Append( KSqlFrom ); |
|
981 sqlPtr.Append( KIptvCATable ); |
|
982 |
|
983 RDbView caView; |
|
984 error = caView.Prepare( |
|
985 iTmpDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited, |
|
986 RDbView::EInsertOnly ); |
|
987 |
|
988 CleanupStack::PopAndDestroy( sql ); |
|
989 |
|
990 if ( error == KErrNone ) |
|
991 { |
|
992 for ( TInt i = 0; i < count; i++ ) |
|
993 { |
|
994 caView.InsertL(); |
|
995 WriteContentAccessToDbL( |
|
996 caView, aMediaContents[i], aContentKey, i ); |
|
997 caView.PutL(); |
|
998 } |
|
999 } |
|
1000 caView.Close(); |
|
1001 } |
|
1002 |
|
1003 return error; |
|
1004 } |
|
1005 |
|
1006 // -------------------------------------------------------------------------- |
|
1007 // CIptvEpgDb::WriteContentAccessToDbL() |
|
1008 // -------------------------------------------------------------------------- |
|
1009 // |
|
1010 void CIptvEpgDb::WriteContentAccessToDbL( |
|
1011 RDbView& aView, |
|
1012 const CIptvMediaContent* aMediaContent, |
|
1013 TUint32 aContentKey, |
|
1014 TUint32 aIndex ) const |
|
1015 { |
|
1016 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::WriteContentAccessToDbL" ); |
|
1017 |
|
1018 if ( aMediaContent ) |
|
1019 { |
|
1020 CDbColSet* colSet = aView.ColSetL(); |
|
1021 CleanupStack::PushL( colSet ); |
|
1022 |
|
1023 // Content key |
|
1024 aView.SetColL( colSet->ColNo( KIptvCAContentKey ), aContentKey ); |
|
1025 |
|
1026 // Content URL |
|
1027 RDbColWriteStream writeStream; |
|
1028 writeStream.OpenLC( aView, colSet->ColNo( KIptvCAContentUrl ) ); |
|
1029 writeStream.WriteL( aMediaContent->GetMediaContentUrl() ); |
|
1030 writeStream.Close(); |
|
1031 CleanupStack::Pop(); // writeStream |
|
1032 |
|
1033 // Download type |
|
1034 aView.SetColL( |
|
1035 colSet->ColNo( KIptvCADlType ), |
|
1036 aMediaContent->iDownloadType ); |
|
1037 |
|
1038 // Language |
|
1039 aView.SetColL( |
|
1040 colSet->ColNo( KIptvCALanguage ), |
|
1041 aMediaContent->iLanguage ); |
|
1042 |
|
1043 // Last play position |
|
1044 aView.SetColL( |
|
1045 colSet->ColNo( KIptvCALastPlayPosition ), |
|
1046 aMediaContent->iLastPosition ); |
|
1047 |
|
1048 // Mime type |
|
1049 aView.SetColL( |
|
1050 colSet->ColNo( KIptvCAMimeType ), |
|
1051 aMediaContent->iMimeType ); |
|
1052 |
|
1053 // File size |
|
1054 aView.SetColL( |
|
1055 colSet->ColNo( KIptvCAFileSize ), |
|
1056 aMediaContent->iFileSize ); |
|
1057 |
|
1058 // Duration |
|
1059 aView.SetColL( |
|
1060 colSet->ColNo( KIptvCADuration ), |
|
1061 aMediaContent->iDuration ); |
|
1062 |
|
1063 // File id |
|
1064 aView.SetColL( colSet->ColNo( KIptvCAFileId ), 0 ); |
|
1065 |
|
1066 // Drive id |
|
1067 aView.SetColL( colSet->ColNo( KIptvCADriveId ), 0 ); |
|
1068 |
|
1069 // Index |
|
1070 aView.SetColL( colSet->ColNo( KIptvCAIndex ), aIndex ); |
|
1071 |
|
1072 // Medium |
|
1073 // Not used |
|
1074 |
|
1075 // Is default |
|
1076 // Not used |
|
1077 |
|
1078 // Expression |
|
1079 aView.SetColL( |
|
1080 colSet->ColNo( KIptvCAExpression ), |
|
1081 aMediaContent->iExpression ); |
|
1082 |
|
1083 // Price |
|
1084 // Not in media content |
|
1085 |
|
1086 // Purchase type |
|
1087 // Not in mediacontent |
|
1088 |
|
1089 // Purchase URL |
|
1090 // Not in media content |
|
1091 |
|
1092 // Last play position |
|
1093 // Not in media content |
|
1094 |
|
1095 CleanupStack::PopAndDestroy( colSet ); |
|
1096 } |
|
1097 } |
|
1098 |
|
1099 // -------------------------------------------------------------------------- |
|
1100 // CIptvEpgDb::WriteContentToDbL() |
|
1101 // -------------------------------------------------------------------------- |
|
1102 // |
|
1103 void CIptvEpgDb::WriteContentToDbL( |
|
1104 RDbView& aView, CIptvEpgContent& aContent, TBool aLeave ) const |
|
1105 { |
|
1106 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::WriteContentToDbL" ); |
|
1107 |
|
1108 CDbColSet* colSet = aView.ColSetL(); |
|
1109 CleanupStack::PushL( colSet ); |
|
1110 |
|
1111 // Key (is auto-increment) |
|
1112 |
|
1113 if ( !aLeave ) |
|
1114 { |
|
1115 // File Id |
|
1116 aView.SetColL( |
|
1117 colSet->ColNo( KIptvEpgContentDbFileIdCol ), |
|
1118 KIptvFileId ); |
|
1119 |
|
1120 // Drive |
|
1121 aView.SetColL( |
|
1122 colSet->ColNo( KIptvEpgContentDbDriveIdCol ), |
|
1123 KIptvDrive ); |
|
1124 } |
|
1125 |
|
1126 // Id |
|
1127 aView.SetColL( |
|
1128 colSet->ColNo( KIptvEpgContentDbIdCol ), |
|
1129 aContent.iId ); |
|
1130 |
|
1131 // Name |
|
1132 aView.SetColL( |
|
1133 colSet->ColNo( KIptvEpgContentDbNameCol ), |
|
1134 aContent.iName ); |
|
1135 |
|
1136 // Content protection |
|
1137 aView.SetColL( |
|
1138 colSet->ColNo( KIptvEpgContentDbContentProtectionCol ), |
|
1139 aContent.iContentProtection ); |
|
1140 |
|
1141 // Icon file Id |
|
1142 aView.SetColL( |
|
1143 colSet->ColNo( KIptvEpgContentDbIconFileIdCol ), |
|
1144 aContent.iIconFileId ); |
|
1145 |
|
1146 // Is icon file path URL |
|
1147 aView.SetColL( |
|
1148 colSet->ColNo( KIptvEpgContentDbIsIconFilePathUrlCol ), |
|
1149 aContent.iIsIconFilePathUrl ); |
|
1150 |
|
1151 // Icon file path |
|
1152 aView.SetColL( |
|
1153 colSet->ColNo( KIptvEpgContentDbIconFilePathCol ), |
|
1154 aContent.iIconFilePath ); |
|
1155 |
|
1156 // Content file Id |
|
1157 aView.SetColL( |
|
1158 colSet->ColNo( KIptvEpgContentDbContentFileIdCol ), |
|
1159 aContent.iContentFileId ); |
|
1160 |
|
1161 // Description |
|
1162 aView.SetColL( |
|
1163 colSet->ColNo( KIptvEpgContentDbDescriptionCol ), |
|
1164 aContent.iDescription ); |
|
1165 |
|
1166 // Pub date |
|
1167 aView.SetColL( |
|
1168 colSet->ColNo( KIptvEpgContentDbPubDateCol ), |
|
1169 aContent.iPubDate ); |
|
1170 |
|
1171 // Browser url |
|
1172 RDbColWriteStream writeStream; |
|
1173 writeStream.OpenLC( |
|
1174 aView, colSet->ColNo( KIptvEpgContentDbBrowserUrlCol ) ); |
|
1175 writeStream.WriteL( aContent.iBrowserUrl ); |
|
1176 writeStream.Close(); |
|
1177 CleanupStack::Pop( &writeStream ); |
|
1178 |
|
1179 // Order |
|
1180 aView.SetColL( |
|
1181 colSet->ColNo( KIptvEpgContentDbOrderCol ), |
|
1182 aContent.iOrder ); |
|
1183 |
|
1184 // Author |
|
1185 aView.SetColL( |
|
1186 colSet->ColNo( KIptvEpgContentDbAuthorCol ), |
|
1187 aContent.iAuthor ); |
|
1188 |
|
1189 // Copyright |
|
1190 aView.SetColL( |
|
1191 colSet->ColNo( KIptvEpgContentDbCopyrightCol ), |
|
1192 aContent.iCopyright ); |
|
1193 |
|
1194 // Size |
|
1195 aView.SetColL( |
|
1196 colSet->ColNo( KIptvEpgContentDbSizeCol ), |
|
1197 aContent.iSize ); |
|
1198 |
|
1199 // Duration |
|
1200 aView.SetColL( |
|
1201 colSet->ColNo( KIptvEpgContentDbDurationCol ), |
|
1202 aContent.iDuration ); |
|
1203 |
|
1204 // Language |
|
1205 aView.SetColL( |
|
1206 colSet->ColNo( KIptvEpgContentDbLanguageCol ), |
|
1207 aContent.iLanguage ); |
|
1208 |
|
1209 // RatingAge |
|
1210 aView.SetColL( |
|
1211 colSet->ColNo( KIptvEpgContentDbRatingAgeCol ), |
|
1212 aContent.iRatingAge ); |
|
1213 |
|
1214 CleanupStack::PopAndDestroy( colSet ); |
|
1215 } |
|
1216 |
|
1217 // -------------------------------------------------------------------------- |
|
1218 // CIptvEpgDb::IsDownloadedL |
|
1219 // -------------------------------------------------------------------------- |
|
1220 // |
|
1221 TBool CIptvEpgDb::IsDownloadedL( const RDbView& aView ) const |
|
1222 { |
|
1223 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::IsDownloadedL" ); |
|
1224 |
|
1225 CDbColSet* colSet = aView.ColSetL(); |
|
1226 CleanupStack::PushL( colSet ); |
|
1227 TInt fileIdCol = colSet->ColNo( KIptvEpgContentDbFileIdCol ); |
|
1228 TInt driveCol = colSet->ColNo( KIptvEpgContentDbDriveIdCol ); |
|
1229 CleanupStack::PopAndDestroy( colSet ); |
|
1230 |
|
1231 TUint32 fileId = aView.ColUint32( fileIdCol ); |
|
1232 TUint32 drive = aView.ColUint32( driveCol ); |
|
1233 |
|
1234 TBool downloaded = EFalse; |
|
1235 if ( fileId == 0 && drive == 0 ) |
|
1236 { |
|
1237 downloaded = EFalse; |
|
1238 } |
|
1239 else |
|
1240 { |
|
1241 downloaded = ETrue; |
|
1242 } |
|
1243 |
|
1244 return downloaded; |
|
1245 } |
|
1246 |
|
1247 // -------------------------------------------------------------------------- |
|
1248 // CIptvEpgDb::UpdateCategoryIconL |
|
1249 // -------------------------------------------------------------------------- |
|
1250 // |
|
1251 TInt CIptvEpgDb::UpdateCategoryIconL( |
|
1252 TUint32& aCategoryKey, |
|
1253 TUint32& /*aIconFileId*/, |
|
1254 const TDesC& aIconFilePath, |
|
1255 TBool aIsUrl ) |
|
1256 { |
|
1257 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::UpdateCategoryIconL" ); |
|
1258 |
|
1259 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1260 TPtr16 sqlPtr = sql->Des(); |
|
1261 |
|
1262 sqlPtr.Append( KSqlSelect ); |
|
1263 sqlPtr.Append( KIptvEpgCategoryDbKeyCol ); |
|
1264 sqlPtr.Append( KSqlDot ); |
|
1265 sqlPtr.Append( KIptvEpgCategoryDbIconFileIdCol ); |
|
1266 sqlPtr.Append( KSqlDot ); |
|
1267 sqlPtr.Append( KIptvEpgCategoryDbIconFilePathCol ); |
|
1268 sqlPtr.Append( KSqlDot ); |
|
1269 sqlPtr.Append( KIptvEpgCategoryDbIsIconFilePathUrlCol ); |
|
1270 sqlPtr.Append( KSqlFrom ); |
|
1271 sqlPtr.Append( KIptvEpgCategoryTable ); |
|
1272 sqlPtr.Append( KSqlWhere ); |
|
1273 sqlPtr.Append( KIptvEpgCategoryDbKeyCol ); |
|
1274 sqlPtr.Append( KSqlIs ); |
|
1275 sqlPtr.AppendNum( TInt64( aCategoryKey ) ); |
|
1276 |
|
1277 RDbView view; |
|
1278 TInt error = KErrNone; |
|
1279 error = view.Prepare( iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1280 |
|
1281 CleanupStack::PopAndDestroy( sql ); |
|
1282 |
|
1283 if ( error == KErrNone ) |
|
1284 { |
|
1285 view.EvaluateAll(); |
|
1286 if ( !view.IsEmptyL() ) |
|
1287 { |
|
1288 view.FirstL(); |
|
1289 view.UpdateL(); |
|
1290 |
|
1291 CDbColSet* colSet = view.ColSetL(); |
|
1292 CleanupStack::PushL( colSet ); |
|
1293 view.SetColL( |
|
1294 colSet->ColNo( KIptvEpgCategoryDbIconFilePathCol ), |
|
1295 aIconFilePath ); |
|
1296 view.SetColL( |
|
1297 colSet->ColNo( KIptvEpgCategoryDbIsIconFilePathUrlCol ), |
|
1298 aIsUrl ); |
|
1299 CleanupStack::PopAndDestroy( colSet ); |
|
1300 view.PutL(); |
|
1301 } |
|
1302 else |
|
1303 { |
|
1304 error = KErrNotFound; |
|
1305 } |
|
1306 } |
|
1307 |
|
1308 view.Close(); |
|
1309 |
|
1310 return error; |
|
1311 } |
|
1312 |
|
1313 // -------------------------------------------------------------------------- |
|
1314 // CIptvEpgDb::UpdateContentIconL |
|
1315 // -------------------------------------------------------------------------- |
|
1316 // |
|
1317 TInt CIptvEpgDb::UpdateContentIconL( |
|
1318 TUint32& aContentKey, |
|
1319 TUint32& /*aIconFileId*/, |
|
1320 const TDesC& aIconFilePath, |
|
1321 TBool aIsUrl ) |
|
1322 { |
|
1323 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::UpdateContentIconL" ); |
|
1324 |
|
1325 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1326 TPtr16 sqlPtr = sql->Des(); |
|
1327 |
|
1328 sqlPtr.Append( KSqlSelect ); |
|
1329 sqlPtr.Append( KIptvEpgContentDbKeyCol ); |
|
1330 sqlPtr.Append( KSqlDot ); |
|
1331 sqlPtr.Append( KIptvEpgContentDbIconFileIdCol ); |
|
1332 sqlPtr.Append( KSqlDot ); |
|
1333 sqlPtr.Append( KIptvEpgContentDbIconFilePathCol ); |
|
1334 sqlPtr.Append( KSqlDot ); |
|
1335 sqlPtr.Append( KIptvEpgContentDbIsIconFilePathUrlCol ); |
|
1336 sqlPtr.Append( KSqlFrom ); |
|
1337 sqlPtr.Append( KIptvEpgContentTable ); |
|
1338 sqlPtr.Append( KSqlWhere ); |
|
1339 sqlPtr.Append( KIptvEpgContentDbKeyCol ); |
|
1340 sqlPtr.Append( KSqlIs ); |
|
1341 sqlPtr.AppendNum( TInt64( aContentKey ) ); |
|
1342 |
|
1343 RDbView view; |
|
1344 TInt error = KErrNone; |
|
1345 error = view.Prepare( iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1346 |
|
1347 CleanupStack::PopAndDestroy( sql ); |
|
1348 |
|
1349 if ( error == KErrNone ) |
|
1350 { |
|
1351 view.EvaluateAll(); |
|
1352 if ( !view.IsEmptyL() ) |
|
1353 { |
|
1354 view.FirstL(); |
|
1355 view.UpdateL(); |
|
1356 |
|
1357 CDbColSet* colSet = view.ColSetL(); |
|
1358 CleanupStack::PushL( colSet ); |
|
1359 view.SetColL( |
|
1360 colSet->ColNo( KIptvEpgContentDbIconFilePathCol ), |
|
1361 aIconFilePath ); |
|
1362 view.SetColL( colSet->ColNo( |
|
1363 KIptvEpgContentDbIsIconFilePathUrlCol ), aIsUrl ); |
|
1364 CleanupStack::PopAndDestroy( colSet ); |
|
1365 view.PutL(); |
|
1366 } |
|
1367 else |
|
1368 { |
|
1369 error = KErrNotFound; |
|
1370 } |
|
1371 } |
|
1372 |
|
1373 view.Close(); |
|
1374 |
|
1375 return error; |
|
1376 } |
|
1377 |
|
1378 // -------------------------------------------------------------------------- |
|
1379 // CIptvEpgDb::AddRelationL() |
|
1380 // -------------------------------------------------------------------------- |
|
1381 // |
|
1382 TInt CIptvEpgDb::AddRelationL( TUint32& aCategoryKey, TUint32& aContentKey ) |
|
1383 { |
|
1384 IPTVLOGSTRING3_LOW_LEVEL( |
|
1385 "CIptvEpgDb::AddRelationL --- Add relation from category %d to content %d", |
|
1386 aCategoryKey, aContentKey ); |
|
1387 |
|
1388 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1389 TPtr16 sqlPtr = sql->Des(); |
|
1390 |
|
1391 sqlPtr.Append( KSqlSelect ); |
|
1392 sqlPtr.Append( KIptvEpgCategoryContentCategoryKeyCol ); |
|
1393 sqlPtr.Append( KSqlDot ); |
|
1394 sqlPtr.Append( KIptvEpgCategoryContentContentKeyCol ); |
|
1395 sqlPtr.Append( KSqlFrom ); |
|
1396 sqlPtr.Append( KIptvEpgCategoryContentTable ); |
|
1397 |
|
1398 RDbView view; |
|
1399 TInt error = KErrNone; |
|
1400 error = view.Prepare( |
|
1401 iTmpDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited, RDbView::EInsertOnly ); |
|
1402 |
|
1403 CleanupStack::PopAndDestroy( sql ); |
|
1404 |
|
1405 if ( error == KErrNone ) |
|
1406 { |
|
1407 view.InsertL(); |
|
1408 |
|
1409 CDbColSet* colSet = view.ColSetL(); |
|
1410 CleanupStack::PushL( colSet ); |
|
1411 |
|
1412 // Category |
|
1413 view.SetColL( colSet->ColNo( |
|
1414 KIptvEpgCategoryContentCategoryKeyCol ), aCategoryKey ); |
|
1415 |
|
1416 // Content |
|
1417 view.SetColL( colSet->ColNo( |
|
1418 KIptvEpgCategoryContentContentKeyCol ), aContentKey ); |
|
1419 |
|
1420 CleanupStack::PopAndDestroy( colSet ); |
|
1421 |
|
1422 TRAPD( putError, view.PutL() ); |
|
1423 if ( putError == KErrAlreadyExists ) |
|
1424 { |
|
1425 view.Close(); |
|
1426 } |
|
1427 |
|
1428 view.Close(); |
|
1429 } |
|
1430 else |
|
1431 { |
|
1432 IPTVLOGSTRING2_LOW_LEVEL( "CIptvEpgDb::AddRelationL ERROR = %d", error ); |
|
1433 } |
|
1434 |
|
1435 return error; |
|
1436 } |
|
1437 |
|
1438 // -------------------------------------------------------------------------- |
|
1439 // CIptvEpgDb::MakeSqlStrings() |
|
1440 // -------------------------------------------------------------------------- |
|
1441 // |
|
1442 void CIptvEpgDb::MakeSqlStrings() |
|
1443 { |
|
1444 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::MakeSqlStrings" ); |
|
1445 |
|
1446 // Category |
|
1447 iSqlCategory.Append( KSqlSelect ); |
|
1448 iSqlCategory.Append( KSqlAll ); |
|
1449 iSqlCategory.Append( KSqlFrom ); |
|
1450 iSqlCategory.Append( KIptvEpgCategoryTable ); |
|
1451 |
|
1452 // Content |
|
1453 iSqlContent.Append( KSqlSelect ); |
|
1454 iSqlContent.Append( KSqlAll ); |
|
1455 iSqlContent.Append( KSqlFrom ); |
|
1456 iSqlContent.Append( KIptvEpgContentTable ); |
|
1457 } |
|
1458 |
|
1459 // Query methods for EpgMsgHandler from MIptvVodContent interface |
|
1460 |
|
1461 // -------------------------------------------------------------------------- |
|
1462 // CIptvEpgDb::GetEcgCategoryList() |
|
1463 // -------------------------------------------------------------------------- |
|
1464 // |
|
1465 TInt CIptvEpgDb::GetEcgCategoryListL( |
|
1466 TIptvCategoryId aParentCategoryId, |
|
1467 RPointerArray<CIptvVodContentCategoryBriefDetails>& aCategoryList ) |
|
1468 { |
|
1469 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetEcgCategoryListL" ); |
|
1470 |
|
1471 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1472 TPtr16 sqlPtr = sql->Des(); |
|
1473 sqlPtr.Append( KSqlSelect ); |
|
1474 sqlPtr.Append( KSqlAll ); |
|
1475 sqlPtr.Append( KSqlFrom ); |
|
1476 sqlPtr.Append( KIptvEpgCategoryTable ); |
|
1477 sqlPtr.Append( KSqlWhere ); |
|
1478 sqlPtr.Append( KIptvEpgCategoryDbParentKeyCol ); |
|
1479 sqlPtr.Append( KSqlIs ); |
|
1480 sqlPtr.AppendNum( TInt64( aParentCategoryId ) ); |
|
1481 |
|
1482 RDbView view; |
|
1483 TInt error = view.Prepare( |
|
1484 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1485 |
|
1486 CleanupStack::PopAndDestroy( sql ); |
|
1487 |
|
1488 if ( error == KErrNone ) |
|
1489 { |
|
1490 view.EvaluateAll(); |
|
1491 view.FirstL(); |
|
1492 while ( view.AtRow() ) |
|
1493 { |
|
1494 view.GetL(); |
|
1495 CIptvVodContentCategoryBriefDetails* details = |
|
1496 CIptvVodContentCategoryBriefDetails::NewL(); |
|
1497 CleanupStack::PushL( details ); |
|
1498 ReadCategoryFromDbL( view, *details ); |
|
1499 aCategoryList.Append ( details ); |
|
1500 CleanupStack::Pop( details ); |
|
1501 view.NextL(); |
|
1502 } |
|
1503 } |
|
1504 |
|
1505 view.Close(); |
|
1506 |
|
1507 return error; |
|
1508 } |
|
1509 |
|
1510 // -------------------------------------------------------------------------- |
|
1511 // CIptvEpgDb::GetCategoryDetails() |
|
1512 // -------------------------------------------------------------------------- |
|
1513 // |
|
1514 TInt CIptvEpgDb::GetCategoryDetailsL( |
|
1515 TIptvCategoryId aCategoryId, |
|
1516 CIptvVodContentCategoryBriefDetails& aCategory ) |
|
1517 { |
|
1518 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetCategoryDetailsL" ); |
|
1519 |
|
1520 // aCategoryId = category key |
|
1521 |
|
1522 if( aCategoryId == KIptvRssSearchCategoryId) |
|
1523 { |
|
1524 return KErrNotSupported; |
|
1525 } |
|
1526 |
|
1527 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1528 TPtr16 sqlPtr = sql->Des(); |
|
1529 sqlPtr.Append( iSqlCategory ); |
|
1530 sqlPtr.Append( KSqlWhere ); |
|
1531 sqlPtr.Append( KIptvEpgCategoryDbKeyCol ); |
|
1532 sqlPtr.Append( KSqlIs ); |
|
1533 sqlPtr.AppendNum( TInt64( aCategoryId ) ); |
|
1534 |
|
1535 RDbView view; |
|
1536 TInt error = view.Prepare( |
|
1537 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1538 |
|
1539 CleanupStack::PopAndDestroy( sql ); |
|
1540 |
|
1541 if ( error == KErrNone ) |
|
1542 { |
|
1543 view.EvaluateAll(); |
|
1544 view.FirstL(); |
|
1545 TInt count = view.CountL(); |
|
1546 if ( count > 0 ) |
|
1547 { |
|
1548 if ( count == KMaxCountOfFullDetails ) |
|
1549 { |
|
1550 view.GetL(); |
|
1551 ReadCategoryFromDbL( view, aCategory ); |
|
1552 } |
|
1553 else |
|
1554 { |
|
1555 error = KErrNotSupported; |
|
1556 } |
|
1557 } |
|
1558 } |
|
1559 |
|
1560 view.Close(); |
|
1561 |
|
1562 return error; |
|
1563 } |
|
1564 |
|
1565 // -------------------------------------------------------------------------- |
|
1566 // CIptvEpgDb::ReadCategoryFromDbL() |
|
1567 // -------------------------------------------------------------------------- |
|
1568 // |
|
1569 void CIptvEpgDb::ReadCategoryFromDbL( |
|
1570 const RDbView& aView, |
|
1571 CIptvVodContentCategoryBriefDetails& aCategory ) const |
|
1572 { |
|
1573 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ReadCategoryFromDbL" ); |
|
1574 |
|
1575 CDbColSet* colSet = aView.ColSetL(); |
|
1576 CleanupStack::PushL( colSet ); |
|
1577 TInt keyColumnNo = colSet->ColNo( KIptvEpgContentDbKeyCol ); |
|
1578 TInt nameColumnNo = colSet->ColNo( KIptvEpgCategoryDbNameCol ); |
|
1579 // Obsolete field: |
|
1580 TInt pubDateColumnNo = colSet->ColNo( KIptvEpgCategoryDbPubDateCol ); |
|
1581 // Obsolete field: |
|
1582 TInt thumbnailColumnNo = |
|
1583 colSet->ColNo( KIptvEpgCategoryDbIconFilePathCol ); |
|
1584 TInt contentCountColumnNo = |
|
1585 colSet->ColNo( KIptvEpgCategoryDbContentCountCol ); |
|
1586 |
|
1587 CleanupStack::PopAndDestroy( colSet ); |
|
1588 |
|
1589 // iCategoryId = category key |
|
1590 aCategory.iCategoryId = aView.ColUint32( keyColumnNo ); |
|
1591 |
|
1592 // Name |
|
1593 TPtrC name; |
|
1594 name.Set( aView.ColDes( nameColumnNo ) ); |
|
1595 TInt valueLength = name.Length(); |
|
1596 TInt dataToCopy = Min( valueLength, KIptvEpgCategoryNameMaxLength ); |
|
1597 aCategory.iName.Copy( name.Mid( 0, dataToCopy ) ); |
|
1598 |
|
1599 // pubDate - Obsolete field |
|
1600 aCategory.iPubDate = aView.ColTime( pubDateColumnNo ); |
|
1601 |
|
1602 // Thumbnail path - Obsolete field |
|
1603 TPtrC path; |
|
1604 path.Set( aView.ColDes( thumbnailColumnNo ) ); |
|
1605 valueLength = path.Length(); |
|
1606 dataToCopy = Min( valueLength, KIptvEpgCategoryIconFilePathMaxLength ); |
|
1607 aCategory.iThumbnailPath.Copy( path.Mid( 0, dataToCopy ) ); |
|
1608 |
|
1609 // Content count |
|
1610 aCategory.iContentCount = aView.ColUint32( contentCountColumnNo ); |
|
1611 } |
|
1612 |
|
1613 // -------------------------------------------------------------------------- |
|
1614 // CIptvEpgDb::GetParentCategory() |
|
1615 // -------------------------------------------------------------------------- |
|
1616 // |
|
1617 TInt CIptvEpgDb::GetParentCategoryL( |
|
1618 TIptvCategoryId aCategoryId, |
|
1619 TIptvCategoryId& aParentId ) |
|
1620 { |
|
1621 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetParentCategoryL" ); |
|
1622 |
|
1623 // aCategoryId = category key |
|
1624 |
|
1625 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1626 TPtr16 sqlPtr = sql->Des(); |
|
1627 sqlPtr.Append( KSqlSelect ); |
|
1628 sqlPtr.Append( KIptvEpgCategoryDbKeyCol ); |
|
1629 sqlPtr.Append( KSqlDot ); |
|
1630 sqlPtr.Append( KIptvEpgCategoryDbParentKeyCol ); |
|
1631 sqlPtr.Append( KSqlFrom ); |
|
1632 sqlPtr.Append( KIptvEpgCategoryTable ); |
|
1633 sqlPtr.Append( KSqlWhere ); |
|
1634 sqlPtr.Append( KIptvEpgCategoryDbKeyCol ); |
|
1635 sqlPtr.Append( KSqlIs ); |
|
1636 sqlPtr.AppendNum( TInt64( aCategoryId ) ); |
|
1637 |
|
1638 RDbView view; |
|
1639 TInt error = view.Prepare( |
|
1640 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1641 |
|
1642 CleanupStack::PopAndDestroy( sql ); |
|
1643 |
|
1644 if ( error == KErrNone ) |
|
1645 { |
|
1646 view.EvaluateAll(); |
|
1647 view.FirstL(); |
|
1648 TInt count = view.CountL(); |
|
1649 if ( count == KMaxCountOfParentCategories ) |
|
1650 { |
|
1651 CDbColSet* colSet = view.ColSetL(); |
|
1652 CleanupStack::PushL( colSet ); |
|
1653 TInt parentColumnNo = colSet->ColNo( |
|
1654 KIptvEpgCategoryDbParentKeyCol ); |
|
1655 CleanupStack::PopAndDestroy( colSet ); |
|
1656 view.GetL(); |
|
1657 aParentId = view.ColUint32( parentColumnNo ); |
|
1658 } |
|
1659 else |
|
1660 { |
|
1661 error = KErrNotSupported; |
|
1662 } |
|
1663 } |
|
1664 |
|
1665 view.Close(); |
|
1666 |
|
1667 return error; |
|
1668 } |
|
1669 |
|
1670 // -------------------------------------------------------------------------- |
|
1671 // CIptvEpgDb::GetEcgListL() |
|
1672 // Get all contents in given category in order defined by database originated |
|
1673 // from service provider |
|
1674 // -------------------------------------------------------------------------- |
|
1675 // |
|
1676 TInt CIptvEpgDb::GetEcgListL( |
|
1677 TIptvCategoryId aCategoryId, |
|
1678 const TDesC& aSearchString, |
|
1679 TUint32 aFrom, |
|
1680 TUint32 aAmount, |
|
1681 TUint32& aTotalAmount, |
|
1682 RPointerArray<CIptvVodContentContentBriefDetails>& aEcgList ) |
|
1683 { |
|
1684 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetEcgListL" ); |
|
1685 |
|
1686 RArray<TUint32> contents; |
|
1687 |
|
1688 // aCategoryId = category key |
|
1689 |
|
1690 // First get all contents belonging to given category |
|
1691 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1692 TPtr16 sqlPtr = sql->Des(); |
|
1693 |
|
1694 sqlPtr.Append( KSqlSelect ); |
|
1695 sqlPtr.Append( KIptvEpgCategoryContentCategoryKeyCol ); |
|
1696 sqlPtr.Append( KSqlDot ); |
|
1697 sqlPtr.Append( KIptvEpgCategoryContentContentKeyCol ); |
|
1698 sqlPtr.Append( KSqlFrom ); |
|
1699 sqlPtr.Append( KIptvEpgCategoryContentTable ); |
|
1700 sqlPtr.Append( KSqlWhere ); |
|
1701 sqlPtr.Append( KIptvEpgCategoryContentCategoryKeyCol ); |
|
1702 sqlPtr.Append( KSqlIs ); |
|
1703 sqlPtr.AppendNum( TInt64( aCategoryId ) ); |
|
1704 |
|
1705 RDbView view; |
|
1706 TInt error = view.Prepare( |
|
1707 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1708 if ( error == KErrNone ) |
|
1709 { |
|
1710 view.EvaluateAll(); |
|
1711 |
|
1712 CDbColSet* colSet = view.ColSetL(); |
|
1713 CleanupStack::PushL( colSet ); |
|
1714 TInt contentKeyColumnNo = |
|
1715 colSet->ColNo( KIptvEpgCategoryContentContentKeyCol ); |
|
1716 CleanupStack::PopAndDestroy( colSet ); |
|
1717 |
|
1718 view.FirstL(); |
|
1719 while ( view.AtRow() ) |
|
1720 { |
|
1721 view.GetL(); |
|
1722 TUint32 contentKey = view.ColUint32( contentKeyColumnNo ); |
|
1723 contents.AppendL( contentKey ); |
|
1724 view.NextL(); |
|
1725 } |
|
1726 } |
|
1727 |
|
1728 view.Close(); |
|
1729 |
|
1730 // Add all contents matching search string (if defined) to temporary |
|
1731 // RPointerArray data. |
|
1732 RPointerArray<CIptvVodContentContentBriefDetails> data; |
|
1733 RDbView contentView; |
|
1734 |
|
1735 // Add "order by order field" |
|
1736 sqlPtr.Zero(); |
|
1737 sqlPtr.Append( iSqlContent ); |
|
1738 sqlPtr.Append( KSqlOrderBy ); |
|
1739 sqlPtr.Append( KIptvEpgContentDbOrderCol ); |
|
1740 |
|
1741 error = contentView.Prepare( |
|
1742 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1743 |
|
1744 CleanupStack::PopAndDestroy( sql ); |
|
1745 |
|
1746 if ( error == KErrNone ) |
|
1747 { |
|
1748 CDbColSet* cs = contentView.ColSetL(); |
|
1749 CleanupStack::PushL( cs ); |
|
1750 TInt nameCs = cs->ColNo( KIptvEpgContentDbNameCol ); |
|
1751 TInt keyCs = cs->ColNo( KIptvEpgContentDbKeyCol ); |
|
1752 TInt ageCs = cs->ColNo( KIptvEpgContentDbRatingAgeCol ); |
|
1753 |
|
1754 contentView.EvaluateAll(); |
|
1755 contentView.FirstL(); |
|
1756 while ( contentView.AtRow() ) |
|
1757 { |
|
1758 contentView.GetL(); |
|
1759 |
|
1760 // Check that content is in given category -> |
|
1761 // content key must be found on the contents array. |
|
1762 TUint32 key = contentView.ColUint32( keyCs ); |
|
1763 TInt count = contents.Count(); |
|
1764 TBool inCategory( EFalse ); |
|
1765 for ( TInt i = 0; ( i < count ) && !inCategory; i++ ) |
|
1766 { |
|
1767 if ( key == contents[i] ) |
|
1768 { |
|
1769 inCategory = ETrue; |
|
1770 } |
|
1771 } |
|
1772 |
|
1773 if ( inCategory ) |
|
1774 { |
|
1775 TBool add( EFalse ); |
|
1776 TUint16 ratingAge( contentView.ColUint16( ageCs ) ); |
|
1777 |
|
1778 if ( ( KParentalControlOff == iParentalControl ) || |
|
1779 ( ratingAge < iParentalControl ) ) |
|
1780 { |
|
1781 if ( aSearchString.Compare( KEmptyString ) != 0 ) |
|
1782 { |
|
1783 // Name |
|
1784 TPtrC name; |
|
1785 name.Set( contentView.ColDes( nameCs ) ); |
|
1786 TInt searchStringLength = aSearchString.Length(); |
|
1787 TInt nameLength = name.Length(); |
|
1788 TInt dataToCompare = Min( searchStringLength, nameLength ); |
|
1789 if ( aSearchString.Compare( name.Mid( 0, dataToCompare ) ) == 0 ) |
|
1790 { |
|
1791 add = ETrue; |
|
1792 } |
|
1793 } |
|
1794 else |
|
1795 { |
|
1796 add = ETrue; |
|
1797 } |
|
1798 } |
|
1799 |
|
1800 if ( add ) |
|
1801 { |
|
1802 CIptvVodContentContentBriefDetails* bd = |
|
1803 CIptvVodContentContentBriefDetails::NewL(); |
|
1804 CleanupStack::PushL( bd ); |
|
1805 ReadContentBriefDetailsFromDbL( contentView, *bd ); |
|
1806 data.Append( bd ); |
|
1807 CleanupStack::Pop( bd ); |
|
1808 } |
|
1809 } |
|
1810 |
|
1811 contentView.NextL(); |
|
1812 } |
|
1813 |
|
1814 CleanupStack::PopAndDestroy( cs ); |
|
1815 } |
|
1816 |
|
1817 contentView.Close(); |
|
1818 |
|
1819 TUint32 count = 0; |
|
1820 TUint32 totalAmount = data.Count(); |
|
1821 aTotalAmount = totalAmount; |
|
1822 for ( TUint32 i = 0; i < totalAmount; i++ ) |
|
1823 { |
|
1824 if ( i >= aFrom ) |
|
1825 { |
|
1826 if ( aAmount == 0 || count < aAmount ) |
|
1827 { |
|
1828 count++; |
|
1829 aEcgList.AppendL( data[0] ); |
|
1830 data.Remove( 0 ); |
|
1831 } |
|
1832 } |
|
1833 } |
|
1834 |
|
1835 data.ResetAndDestroy(); |
|
1836 |
|
1837 contents.Close(); |
|
1838 |
|
1839 return error; |
|
1840 } |
|
1841 |
|
1842 // -------------------------------------------------------------------------- |
|
1843 // CIptvEpgDb::ReadContentBriefDetailsFromDbL() |
|
1844 // -------------------------------------------------------------------------- |
|
1845 // |
|
1846 void CIptvEpgDb::ReadContentBriefDetailsFromDbL( |
|
1847 const RDbView& aView, |
|
1848 CIptvVodContentContentBriefDetails& aBriefDetails ) const |
|
1849 { |
|
1850 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ReadContentBriefDetailsFromDbL" ); |
|
1851 |
|
1852 CDbColSet* colSet = aView.ColSetL(); |
|
1853 CleanupStack::PushL( colSet ); |
|
1854 TInt keyColumnNo = colSet->ColNo( KIptvEpgContentDbKeyCol ); |
|
1855 TInt nameColumnNo = colSet->ColNo( KIptvEpgContentDbNameCol ); |
|
1856 TInt iconFilePathColumnNo = colSet->ColNo( KIptvEpgContentDbIconFilePathCol ); |
|
1857 TInt fileIdColumnNo = colSet->ColNo( KIptvEpgContentDbFileIdCol ); |
|
1858 TInt driveColumnNo = colSet->ColNo( KIptvEpgContentDbDriveIdCol ); |
|
1859 TInt pFileIdColumnNo = colSet->ColNo( KIptvEpgContentDbPreviewFileIdCol ); |
|
1860 TInt pDriveIdColumnNo = colSet->ColNo( KIptvEpgContentDbPreviewDriveIdCol ); |
|
1861 TInt pubDateColumnNo = colSet->ColNo( KIptvEpgContentDbPubDateCol ); |
|
1862 TInt browserUrlColumnNo = colSet->ColNo( KIptvEpgContentDbBrowserUrlCol ); |
|
1863 TInt sizeColumnNo = colSet->ColNo( KIptvEpgContentDbSizeCol ); |
|
1864 TInt durationColumnNo = colSet->ColNo( KIptvEpgContentDbDurationCol ); |
|
1865 TInt languageColumnNo = colSet->ColNo( KIptvEpgContentDbLanguageCol ); |
|
1866 TInt ratingAgeColumnNo = colSet->ColNo( KIptvEpgContentDbRatingAgeCol ); |
|
1867 |
|
1868 CleanupStack::PopAndDestroy( colSet ); |
|
1869 |
|
1870 // TIptvContentId |
|
1871 aBriefDetails.iContentId = aView.ColUint32( keyColumnNo ); |
|
1872 |
|
1873 // Name |
|
1874 TPtrC name; |
|
1875 name.Set( aView.ColDes( nameColumnNo ) ); |
|
1876 TInt valueLength = name.Length(); |
|
1877 TInt dataToCopy = Min( valueLength, KIptvEpgContentNameMaxLength ); |
|
1878 aBriefDetails.iName.Copy( name.Mid( 0, dataToCopy ) ); |
|
1879 |
|
1880 // Thumbnail path |
|
1881 TPtrC iconFilePath; |
|
1882 iconFilePath.Set( aView.ColDes( iconFilePathColumnNo ) ); |
|
1883 valueLength = iconFilePath.Length(); |
|
1884 dataToCopy = Min( valueLength, KIptvEpgContentIconFilePathMaxLength ); |
|
1885 aBriefDetails.iThumbnailPath.Copy( iconFilePath.Mid( 0, dataToCopy ) ); |
|
1886 |
|
1887 // Global file id |
|
1888 aBriefDetails.iFileId->iDrive = aView.ColUint32( driveColumnNo ); |
|
1889 aBriefDetails.iFileId->iFileId = aView.ColUint32( fileIdColumnNo ); |
|
1890 |
|
1891 // Preview global file id |
|
1892 aBriefDetails.iPreviewGlobalFileId->iDrive = aView.ColUint32( pDriveIdColumnNo ); |
|
1893 aBriefDetails.iPreviewGlobalFileId->iFileId = aView.ColUint32( pFileIdColumnNo ); |
|
1894 |
|
1895 // pubDate |
|
1896 aBriefDetails.iPubDate = aView.ColTime( pubDateColumnNo ); |
|
1897 |
|
1898 // Browser Url |
|
1899 RDbColReadStream readStream; |
|
1900 readStream.OpenLC( aView, browserUrlColumnNo ); |
|
1901 dataToCopy = |
|
1902 Min( KIptvEpgContentBrowserUrlMaxLength, |
|
1903 aView.ColLength( browserUrlColumnNo ) ); |
|
1904 TBuf<KIptvEpgContentBrowserUrlMaxLength> temp; |
|
1905 readStream.ReadL( temp, dataToCopy ); |
|
1906 aBriefDetails.SetBrowserUrlL( temp ); |
|
1907 readStream.Close(); |
|
1908 CleanupStack::Pop( &readStream ); |
|
1909 |
|
1910 // Size |
|
1911 aBriefDetails.iSize = aView.ColUint32( sizeColumnNo ); |
|
1912 |
|
1913 // Duration |
|
1914 aBriefDetails.iPlaytime = aView.ColUint32( durationColumnNo ); |
|
1915 |
|
1916 // Language |
|
1917 TPtrC language; |
|
1918 language.Set( aView.ColDes( languageColumnNo ) ); |
|
1919 valueLength = language.Length(); |
|
1920 dataToCopy = Min( valueLength, KIptvCALanguageLength ); |
|
1921 aBriefDetails.iLanguage.Copy( language.Mid( 0, dataToCopy ) ); |
|
1922 |
|
1923 // Rating age |
|
1924 aBriefDetails.iRatingAge = aView.ColUint16( ratingAgeColumnNo ); |
|
1925 } |
|
1926 |
|
1927 // -------------------------------------------------------------------------- |
|
1928 // CIptvEpgDb::GetEcgAllListL() |
|
1929 // -------------------------------------------------------------------------- |
|
1930 // |
|
1931 TInt CIptvEpgDb::GetEcgAllListL( |
|
1932 const TDesC& aSearchString, |
|
1933 TUint32 aFrom, |
|
1934 TUint32 aAmount, |
|
1935 TUint32& aTotalAmount, |
|
1936 RPointerArray<CIptvVodContentContentBriefDetails>& aEcgList ) |
|
1937 { |
|
1938 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetEcgAllListL" ); |
|
1939 |
|
1940 // First lets get all contents matching search string (if defined) |
|
1941 // to temporary RPointerArray data. |
|
1942 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
1943 TPtr16 sqlPtr = sql->Des(); |
|
1944 |
|
1945 sqlPtr.Append( iSqlContent ); |
|
1946 sqlPtr.Append( KSqlOrderBy ); |
|
1947 sqlPtr.Append( KIptvEpgContentDbNameCol ); |
|
1948 |
|
1949 RPointerArray<CIptvVodContentContentBriefDetails> data; |
|
1950 RDbView view; |
|
1951 TInt error = view.Prepare( |
|
1952 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
1953 |
|
1954 CleanupStack::PopAndDestroy( sql ); |
|
1955 |
|
1956 if ( error == KErrNone ) |
|
1957 { |
|
1958 CDbColSet* cs = view.ColSetL(); |
|
1959 CleanupStack::PushL( cs ); |
|
1960 TInt nameCs = cs->ColNo( KIptvEpgContentDbNameCol ); |
|
1961 TInt ageCs = cs->ColNo( KIptvEpgContentDbRatingAgeCol ); |
|
1962 |
|
1963 view.EvaluateAll(); |
|
1964 view.FirstL(); |
|
1965 while ( view.AtRow() ) |
|
1966 { |
|
1967 view.GetL(); |
|
1968 TBool add( EFalse ); |
|
1969 TUint16 ratingAge( view.ColUint16( ageCs ) ); |
|
1970 |
|
1971 if ( ( KParentalControlOff == iParentalControl ) || |
|
1972 ( ratingAge < iParentalControl ) ) |
|
1973 { |
|
1974 if ( aSearchString.Compare( KEmptyString ) != 0 ) |
|
1975 { |
|
1976 // Name |
|
1977 TPtrC name; |
|
1978 name.Set( view.ColDes( nameCs ) ); |
|
1979 TInt searchStringLength = aSearchString.Length(); |
|
1980 TInt nameLength = name.Length(); |
|
1981 TInt dataToCompare = Min( searchStringLength, nameLength ); |
|
1982 if ( aSearchString.Compare( name.Mid( 0, dataToCompare ) ) == 0 ) |
|
1983 { |
|
1984 add = ETrue; |
|
1985 } |
|
1986 } |
|
1987 else |
|
1988 { |
|
1989 add = ETrue; |
|
1990 } |
|
1991 } |
|
1992 |
|
1993 if ( add ) |
|
1994 { |
|
1995 CIptvVodContentContentBriefDetails* bd = |
|
1996 CIptvVodContentContentBriefDetails::NewL(); |
|
1997 CleanupStack::PushL( bd ); |
|
1998 ReadContentBriefDetailsFromDbL( view, *bd ); |
|
1999 data.Append( bd ); |
|
2000 CleanupStack::Pop( bd ); |
|
2001 } |
|
2002 view.NextL(); |
|
2003 } |
|
2004 CleanupStack::PopAndDestroy( cs ); |
|
2005 } |
|
2006 |
|
2007 TUint32 count = 0; |
|
2008 TUint32 totalAmount = data.Count(); |
|
2009 aTotalAmount = totalAmount; |
|
2010 for ( TUint32 i = 0; i < totalAmount; i++ ) |
|
2011 { |
|
2012 if ( i >= aFrom ) |
|
2013 { |
|
2014 if ( aAmount == 0 || count < aAmount ) |
|
2015 { |
|
2016 count++; |
|
2017 aEcgList.AppendL( data[0] ); |
|
2018 data.Remove( 0 ); |
|
2019 } |
|
2020 } |
|
2021 } |
|
2022 |
|
2023 data.ResetAndDestroy(); |
|
2024 view.Close(); |
|
2025 |
|
2026 return error; |
|
2027 } |
|
2028 |
|
2029 // -------------------------------------------------------------------------- |
|
2030 // CIptvEpgDb::GetContentDetailsL() |
|
2031 // -------------------------------------------------------------------------- |
|
2032 // |
|
2033 TInt CIptvEpgDb::GetContentDetailsL( |
|
2034 TIptvContentId aContentId, |
|
2035 CIptvVodContentContentFullDetails& aContentFullDetails ) |
|
2036 { |
|
2037 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetContentDetailsL" ); |
|
2038 |
|
2039 // aContentId = content key |
|
2040 |
|
2041 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2042 TPtr16 sqlPtr = sql->Des(); |
|
2043 sqlPtr.Append( iSqlContent ); |
|
2044 sqlPtr.Append( KSqlWhere ); |
|
2045 sqlPtr.Append( KIptvEpgContentDbKeyCol ); |
|
2046 sqlPtr.Append( KSqlIs ); |
|
2047 sqlPtr.AppendNum( TInt64( aContentId ) ); |
|
2048 |
|
2049 RDbView view; |
|
2050 TInt error = view.Prepare( |
|
2051 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2052 |
|
2053 CleanupStack::PopAndDestroy( sql ); |
|
2054 |
|
2055 if ( error == KErrNone ) |
|
2056 { |
|
2057 view.EvaluateAll(); |
|
2058 view.FirstL(); |
|
2059 TInt count = view.CountL(); |
|
2060 if ( count > 0 ) |
|
2061 { |
|
2062 if ( count == KMaxCountOfFullDetails ) |
|
2063 { |
|
2064 view.GetL(); |
|
2065 ReadContentFullDetailsFromDbL( view, aContentFullDetails ); |
|
2066 } |
|
2067 else |
|
2068 { |
|
2069 error = KErrNotSupported; |
|
2070 } |
|
2071 } |
|
2072 } |
|
2073 |
|
2074 view.Close(); |
|
2075 |
|
2076 // Get language from content access objects. Get "full" video's language. |
|
2077 |
|
2078 return error; |
|
2079 } |
|
2080 |
|
2081 // -------------------------------------------------------------------------- |
|
2082 // CIptvEpgDb::ReadContentFullDetailsFromDbL() |
|
2083 // -------------------------------------------------------------------------- |
|
2084 // |
|
2085 void CIptvEpgDb::ReadContentFullDetailsFromDbL( |
|
2086 const RDbView& aView, |
|
2087 CIptvVodContentContentFullDetails& aContentFullDetails ) const |
|
2088 { |
|
2089 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ReadContentFullDetailsFromDbL" ); |
|
2090 |
|
2091 CDbColSet* colSet = aView.ColSetL(); |
|
2092 CleanupStack::PushL( colSet ); |
|
2093 TInt keyColumnNo = colSet->ColNo( KIptvEpgContentDbKeyCol ); |
|
2094 TInt nameColumnNo = colSet->ColNo( KIptvEpgContentDbNameCol ); |
|
2095 TInt iconFilePathColumnNo = colSet->ColNo( KIptvEpgContentDbIconFilePathCol ); |
|
2096 TInt fileIdColumnNo = colSet->ColNo( KIptvEpgContentDbFileIdCol ); |
|
2097 TInt pubDateColumnNo = colSet->ColNo( KIptvEpgContentDbPubDateCol ); |
|
2098 TInt browserUrlColumnNo = colSet->ColNo( KIptvEpgContentDbBrowserUrlCol ); |
|
2099 TInt driveColumnNo = colSet->ColNo( KIptvEpgContentDbDriveIdCol ); |
|
2100 TInt pFileIdColumnNo = colSet->ColNo( KIptvEpgContentDbPreviewFileIdCol ); |
|
2101 TInt pDriveIdColumnNo = colSet->ColNo( KIptvEpgContentDbPreviewDriveIdCol ); |
|
2102 TInt descColumnNo = colSet->ColNo( KIptvEpgContentDbDescriptionCol ); |
|
2103 TInt contentProtectionColumnNo = colSet->ColNo( KIptvEpgContentDbContentProtectionCol ); |
|
2104 TInt authorColNo = colSet->ColNo( KIptvEpgContentDbAuthorCol ); |
|
2105 TInt copyrightColNo = colSet->ColNo( KIptvEpgContentDbCopyrightCol ); |
|
2106 TInt sizeColumnNo = colSet->ColNo( KIptvEpgContentDbSizeCol ); |
|
2107 TInt durationColumnNo = colSet->ColNo( KIptvEpgContentDbDurationCol ); |
|
2108 TInt languageColumnNo = colSet->ColNo( KIptvEpgContentDbLanguageCol ); |
|
2109 TInt ratingAgeColumnNo = colSet->ColNo( KIptvEpgContentDbRatingAgeCol ); |
|
2110 CleanupStack::PopAndDestroy( colSet ); |
|
2111 |
|
2112 // TIptvContentId |
|
2113 aContentFullDetails.iContentId = aView.ColUint32( keyColumnNo ); |
|
2114 |
|
2115 // Name |
|
2116 TPtrC name; |
|
2117 name.Set( aView.ColDes( nameColumnNo ) ); |
|
2118 TInt valueLength = name.Length(); |
|
2119 TInt dataToCopy = Min( valueLength, KIptvEpgContentNameMaxLength ); |
|
2120 aContentFullDetails.iName.Copy( name.Mid( 0, dataToCopy ) ); |
|
2121 |
|
2122 // Thumbnail path |
|
2123 TPtrC iconFilePath; |
|
2124 iconFilePath.Set( aView.ColDes( iconFilePathColumnNo ) ); |
|
2125 valueLength = iconFilePath.Length(); |
|
2126 dataToCopy = Min( valueLength, KIptvEpgContentIconFilePathMaxLength ); |
|
2127 aContentFullDetails.iThumbnailPath.Copy( iconFilePath.Mid( 0, dataToCopy ) ); |
|
2128 |
|
2129 // File id |
|
2130 aContentFullDetails.iFileId->iDrive = aView.ColUint32( driveColumnNo ); |
|
2131 aContentFullDetails.iFileId->iFileId = aView.ColUint32( fileIdColumnNo ); |
|
2132 |
|
2133 // Preview global file id |
|
2134 aContentFullDetails.iPreviewGlobalFileId->iDrive = aView.ColUint32( pDriveIdColumnNo ); |
|
2135 aContentFullDetails.iPreviewGlobalFileId->iFileId = aView.ColUint32( pFileIdColumnNo ); |
|
2136 |
|
2137 // pubDate |
|
2138 aContentFullDetails.iPubDate = aView.ColTime( pubDateColumnNo ); |
|
2139 |
|
2140 // Browser Url |
|
2141 RDbColReadStream readStream; |
|
2142 readStream.OpenLC( aView, browserUrlColumnNo ); |
|
2143 dataToCopy = Min( |
|
2144 KIptvEpgContentBrowserUrlMaxLength, |
|
2145 aView.ColLength( browserUrlColumnNo ) ); |
|
2146 TBuf<KIptvEpgContentBrowserUrlMaxLength> temp; |
|
2147 readStream.ReadL( temp, dataToCopy ); |
|
2148 aContentFullDetails.SetBrowserUrlL( temp ); |
|
2149 readStream.Close(); |
|
2150 CleanupStack::Pop( &readStream ); |
|
2151 |
|
2152 // Description |
|
2153 TPtrC desc; |
|
2154 desc.Set( aView.ColDes( descColumnNo ) ); |
|
2155 valueLength = desc.Length(); |
|
2156 dataToCopy = Min( valueLength, KIptvEpgContentDescriptionMaxLength ); |
|
2157 aContentFullDetails.iDescription.Copy( desc.Mid( 0, dataToCopy ) ); |
|
2158 |
|
2159 // DRM placeholder. |
|
2160 aContentFullDetails.iContentProtection = |
|
2161 aView.ColUint32( contentProtectionColumnNo ); |
|
2162 |
|
2163 // Author |
|
2164 TPtrC author; |
|
2165 author.Set( aView.ColDes( authorColNo ) ); |
|
2166 valueLength = author.Length(); |
|
2167 dataToCopy = Min( valueLength, KIptvEpgContentAuthorLength ); |
|
2168 aContentFullDetails.iAuthor.Copy( author.Mid( 0, dataToCopy ) ); |
|
2169 |
|
2170 // Copyright |
|
2171 TPtrC copyright; |
|
2172 copyright.Set( aView.ColDes( copyrightColNo ) ); |
|
2173 valueLength = copyright.Length(); |
|
2174 dataToCopy = Min( valueLength, KIptvEpgContentCopyrightLength ); |
|
2175 aContentFullDetails.iCopyright.Copy( copyright.Mid( 0, dataToCopy ) ); |
|
2176 |
|
2177 // Size |
|
2178 aContentFullDetails.iSize = aView.ColUint32( sizeColumnNo ); |
|
2179 |
|
2180 // Duration |
|
2181 aContentFullDetails.iPlaytime = aView.ColUint32( durationColumnNo ); |
|
2182 |
|
2183 // Language |
|
2184 TPtrC language; |
|
2185 language.Set( aView.ColDes( languageColumnNo ) ); |
|
2186 valueLength = language.Length(); |
|
2187 dataToCopy = Min( valueLength, KIptvCALanguageLength ); |
|
2188 aContentFullDetails.iLanguage.Copy( language.Mid( 0, dataToCopy ) ); |
|
2189 |
|
2190 // Rating age |
|
2191 aContentFullDetails.iRatingAge = aView.ColUint16( ratingAgeColumnNo ); |
|
2192 } |
|
2193 |
|
2194 // -------------------------------------------------------------------------- |
|
2195 // CIptvEpgDb::GetServiceInformationL() |
|
2196 // -------------------------------------------------------------------------- |
|
2197 // |
|
2198 TInt CIptvEpgDb::GetServiceInformationL( |
|
2199 TTime& aLastUpdate, TTime& aInterval ) |
|
2200 { |
|
2201 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetServiceInformationL" ); |
|
2202 |
|
2203 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2204 TPtr16 sqlPtr = sql->Des(); |
|
2205 |
|
2206 sqlPtr.Append( KSqlSelect ); |
|
2207 sqlPtr.Append( KIptvEpgServiceNextUpdate ); |
|
2208 sqlPtr.Append( KSqlDot ); |
|
2209 sqlPtr.Append( KIptvEpgServiceLastUpdate ); |
|
2210 sqlPtr.Append( KSqlFrom ); |
|
2211 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2212 |
|
2213 RDbView view; |
|
2214 TInt error = view.Prepare( |
|
2215 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2216 |
|
2217 CleanupStack::PopAndDestroy( sql ); |
|
2218 |
|
2219 if ( error == KErrNone ) |
|
2220 { |
|
2221 view.EvaluateAll(); |
|
2222 view.FirstL(); |
|
2223 TInt count = view.CountL(); |
|
2224 if ( count > 0 ) |
|
2225 { |
|
2226 CDbColSet* colSet = view.ColSetL(); |
|
2227 CleanupStack::PushL( colSet ); |
|
2228 TInt nextUpdateColumnNo = colSet->ColNo( KIptvEpgServiceNextUpdate ); |
|
2229 TInt lastUpdateColumnNo = colSet->ColNo( KIptvEpgServiceLastUpdate ); |
|
2230 CleanupStack::PopAndDestroy( colSet ); |
|
2231 |
|
2232 view.GetL(); |
|
2233 aLastUpdate = view.ColTime( lastUpdateColumnNo ); |
|
2234 aInterval = view.ColTime( nextUpdateColumnNo ); |
|
2235 } |
|
2236 else |
|
2237 { |
|
2238 error = KIptvErrorGetUpdateInformationLNotFound; |
|
2239 } |
|
2240 } |
|
2241 |
|
2242 view.Close(); |
|
2243 |
|
2244 return error; |
|
2245 } |
|
2246 |
|
2247 // -------------------------------------------------------------------------- |
|
2248 // CIptvEpgDb::SetServiceInformationL() |
|
2249 // -------------------------------------------------------------------------- |
|
2250 // |
|
2251 TInt CIptvEpgDb::SetServiceInformationL( |
|
2252 RDbNamedDatabase& aDb, |
|
2253 const TTime& aLastUpdate, |
|
2254 const TTime& aInterval) const |
|
2255 { |
|
2256 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::SetServiceInformationL" ); |
|
2257 |
|
2258 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2259 TPtr16 sqlPtr = sql->Des(); |
|
2260 sqlPtr.Append( KSqlSelect ); |
|
2261 sqlPtr.Append( KSqlAll ); |
|
2262 sqlPtr.Append( KSqlFrom ); |
|
2263 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2264 |
|
2265 RDbView view; |
|
2266 TInt error = view.Prepare( |
|
2267 aDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited, RDbView::EInsertOnly ); |
|
2268 |
|
2269 CleanupStack::PopAndDestroy( sql ); |
|
2270 |
|
2271 if ( error == KErrNone ) |
|
2272 { |
|
2273 view.InsertL(); |
|
2274 CDbColSet* categoryColSet = view.ColSetL(); |
|
2275 CleanupStack::PushL( categoryColSet ); |
|
2276 |
|
2277 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceLastUpdate ), aLastUpdate ); |
|
2278 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceNextUpdate ), aInterval ); |
|
2279 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceETag ), KIptvEmptyDes ); |
|
2280 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceLastModifiedSince ), KIptvEmptyDes ); |
|
2281 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceXmlFileHash ), KIptvEmptyDes ); |
|
2282 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceVersion ), KIptvDbVersion ); |
|
2283 view.PutL(); |
|
2284 CleanupStack::PopAndDestroy( categoryColSet ); |
|
2285 } |
|
2286 |
|
2287 view.Close(); |
|
2288 |
|
2289 return error; |
|
2290 } |
|
2291 |
|
2292 // -------------------------------------------------------------------------- |
|
2293 // CIptvEpgDb::UpdateServiceInformationL() |
|
2294 // -------------------------------------------------------------------------- |
|
2295 // |
|
2296 TInt CIptvEpgDb::UpdateServiceInformationL( |
|
2297 const TTime& aLastUpdate, |
|
2298 const TTime& aInterval ) |
|
2299 { |
|
2300 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::UpdateServiceInformationL" ); |
|
2301 |
|
2302 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2303 TPtr16 sqlPtr = sql->Des(); |
|
2304 sqlPtr.Append( KSqlSelect ); |
|
2305 sqlPtr.Append( KIptvEpgServiceNextUpdate ); |
|
2306 sqlPtr.Append( KSqlDot ); |
|
2307 sqlPtr.Append( KIptvEpgServiceLastUpdate ); |
|
2308 sqlPtr.Append( KSqlFrom ); |
|
2309 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2310 |
|
2311 RDbView view; |
|
2312 TInt error = KErrNone; |
|
2313 error = view.Prepare( iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2314 |
|
2315 CleanupStack::PopAndDestroy( sql ); |
|
2316 |
|
2317 if ( error == KErrNone ) |
|
2318 { |
|
2319 view.EvaluateAll(); |
|
2320 view.FirstL(); |
|
2321 view.UpdateL(); |
|
2322 |
|
2323 CDbColSet* categoryColSet = view.ColSetL(); |
|
2324 CleanupStack::PushL( categoryColSet ); |
|
2325 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceLastUpdate ), aLastUpdate ); |
|
2326 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceNextUpdate ), aInterval ); |
|
2327 view.PutL(); |
|
2328 CleanupStack::PopAndDestroy( categoryColSet ); |
|
2329 } |
|
2330 |
|
2331 view.Close(); |
|
2332 |
|
2333 return error; |
|
2334 } |
|
2335 |
|
2336 // -------------------------------------------------------------------------- |
|
2337 // CIptvEpgDb::GetServiceETagAndLastmodifiedSinceL() |
|
2338 // -------------------------------------------------------------------------- |
|
2339 // |
|
2340 TInt CIptvEpgDb::GetServiceETagAndLastmodifiedSinceL( |
|
2341 TDes& aETag, |
|
2342 TDes& aLastModifiedSince ) |
|
2343 { |
|
2344 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetServiceETagAndLastmodifiedSinceL" ); |
|
2345 |
|
2346 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2347 TPtr16 sqlPtr = sql->Des(); |
|
2348 |
|
2349 sqlPtr.Append( KSqlSelect ); |
|
2350 sqlPtr.Append( KIptvEpgServiceETag ); |
|
2351 sqlPtr.Append( KSqlDot ); |
|
2352 sqlPtr.Append( KIptvEpgServiceLastModifiedSince ); |
|
2353 sqlPtr.Append( KSqlFrom ); |
|
2354 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2355 |
|
2356 RDbView view; |
|
2357 TInt error = view.Prepare( |
|
2358 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2359 |
|
2360 CleanupStack::PopAndDestroy( sql ); |
|
2361 |
|
2362 if ( error == KErrNone ) |
|
2363 { |
|
2364 view.EvaluateAll(); |
|
2365 view.FirstL(); |
|
2366 TInt count = view.CountL(); |
|
2367 if ( count > 0 ) |
|
2368 { |
|
2369 CDbColSet* colSet = view.ColSetL(); |
|
2370 CleanupStack::PushL( colSet ); |
|
2371 TInt eTagColumnNo = colSet->ColNo( KIptvEpgServiceETag ); |
|
2372 TInt lastModifiedSinceColumnNo = colSet->ColNo( KIptvEpgServiceLastModifiedSince ); |
|
2373 CleanupStack::PopAndDestroy( colSet ); |
|
2374 |
|
2375 view.GetL(); |
|
2376 aETag.Copy( view.ColDes( eTagColumnNo ) ); |
|
2377 aLastModifiedSince.Copy( view.ColDes( lastModifiedSinceColumnNo ) ); |
|
2378 } |
|
2379 else |
|
2380 { |
|
2381 IPTVLOGSTRING2_LOW_LEVEL( "CIptvEpgDb:: Failed to get last modified since info: %d.", error ); |
|
2382 error = KIptvErrorGetUpdateInformationLNotFound; |
|
2383 } |
|
2384 } |
|
2385 |
|
2386 view.Close(); |
|
2387 |
|
2388 return error; |
|
2389 } |
|
2390 |
|
2391 // -------------------------------------------------------------------------- |
|
2392 // CIptvEpgDb::UpdateServiceETagAndLastModifiedSinceL() |
|
2393 // -------------------------------------------------------------------------- |
|
2394 // |
|
2395 TInt CIptvEpgDb::UpdateServiceETagAndLastModifiedSinceL( |
|
2396 const TDesC& aETag, |
|
2397 const TDesC& aLastModifiedSince ) |
|
2398 { |
|
2399 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::UpdateServiceETagAndLastModifiedSinceL" ); |
|
2400 |
|
2401 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2402 TPtr16 sqlPtr = sql->Des(); |
|
2403 sqlPtr.Append( KSqlSelect ); |
|
2404 sqlPtr.Append( KIptvEpgServiceETag ); |
|
2405 sqlPtr.Append( KSqlDot ); |
|
2406 sqlPtr.Append( KIptvEpgServiceLastModifiedSince ); |
|
2407 sqlPtr.Append( KSqlFrom ); |
|
2408 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2409 |
|
2410 RDbView view; |
|
2411 TInt error = KErrNone; |
|
2412 error = view.Prepare( iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2413 |
|
2414 CleanupStack::PopAndDestroy( sql ); |
|
2415 |
|
2416 if ( error == KErrNone ) |
|
2417 { |
|
2418 view.EvaluateAll(); |
|
2419 view.FirstL(); |
|
2420 view.UpdateL(); |
|
2421 |
|
2422 CDbColSet* categoryColSet = view.ColSetL(); |
|
2423 CleanupStack::PushL( categoryColSet ); |
|
2424 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceETag ), aETag ); |
|
2425 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceLastModifiedSince ), aLastModifiedSince ); |
|
2426 view.PutL(); |
|
2427 CleanupStack::PopAndDestroy( categoryColSet ); |
|
2428 } |
|
2429 |
|
2430 view.Close(); |
|
2431 |
|
2432 return error; |
|
2433 } |
|
2434 |
|
2435 // -------------------------------------------------------------------------- |
|
2436 // CIptvEpgDb::GetServiceXmlFileHashL() |
|
2437 // -------------------------------------------------------------------------- |
|
2438 // |
|
2439 TInt CIptvEpgDb::GetServiceXmlFileHashL( |
|
2440 TDes& aHash) |
|
2441 { |
|
2442 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetServiceXmlFileHashL" ); |
|
2443 |
|
2444 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2445 TPtr16 sqlPtr = sql->Des(); |
|
2446 |
|
2447 sqlPtr.Append( KSqlSelect ); |
|
2448 sqlPtr.Append( KIptvEpgServiceXmlFileHash ); |
|
2449 sqlPtr.Append( KSqlFrom ); |
|
2450 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2451 |
|
2452 RDbView view; |
|
2453 TInt error = view.Prepare( |
|
2454 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2455 |
|
2456 CleanupStack::PopAndDestroy( sql ); |
|
2457 |
|
2458 if ( error == KErrNone ) |
|
2459 { |
|
2460 view.EvaluateAll(); |
|
2461 view.FirstL(); |
|
2462 TInt count = view.CountL(); |
|
2463 if ( count > 0 ) |
|
2464 { |
|
2465 CDbColSet* colSet = view.ColSetL(); |
|
2466 CleanupStack::PushL( colSet ); |
|
2467 TInt aXmlFileHashColumnNo = colSet->ColNo( KIptvEpgServiceXmlFileHash ); |
|
2468 CleanupStack::PopAndDestroy( colSet ); |
|
2469 |
|
2470 view.GetL(); |
|
2471 aHash.Copy( view.ColDes( aXmlFileHashColumnNo ) ); |
|
2472 } |
|
2473 else |
|
2474 { |
|
2475 error = KIptvErrorGetUpdateInformationLNotFound; |
|
2476 } |
|
2477 } |
|
2478 |
|
2479 view.Close(); |
|
2480 |
|
2481 return error; |
|
2482 } |
|
2483 |
|
2484 // -------------------------------------------------------------------------- |
|
2485 // CIptvEpgDb::UpdateServiceXmlFileHashL() |
|
2486 // -------------------------------------------------------------------------- |
|
2487 // |
|
2488 TInt CIptvEpgDb::UpdateServiceXmlFileHashL( |
|
2489 const TDesC& aHash) |
|
2490 { |
|
2491 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::UpdateServiceXmlFileHashL" ); |
|
2492 |
|
2493 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2494 TPtr16 sqlPtr = sql->Des(); |
|
2495 sqlPtr.Append( KSqlSelect ); |
|
2496 sqlPtr.Append( KIptvEpgServiceXmlFileHash ); |
|
2497 sqlPtr.Append( KSqlFrom ); |
|
2498 sqlPtr.Append( KIptvEpgServiceTable ); |
|
2499 |
|
2500 RDbView view; |
|
2501 TInt error = KErrNone; |
|
2502 error = view.Prepare( iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2503 |
|
2504 CleanupStack::PopAndDestroy( sql ); |
|
2505 |
|
2506 if ( error == KErrNone ) |
|
2507 { |
|
2508 view.EvaluateAll(); |
|
2509 view.FirstL(); |
|
2510 view.UpdateL(); |
|
2511 |
|
2512 CDbColSet* categoryColSet = view.ColSetL(); |
|
2513 CleanupStack::PushL( categoryColSet ); |
|
2514 view.SetColL( categoryColSet->ColNo( KIptvEpgServiceXmlFileHash ), aHash ); |
|
2515 view.PutL(); |
|
2516 CleanupStack::PopAndDestroy( categoryColSet ); |
|
2517 } |
|
2518 |
|
2519 view.Close(); |
|
2520 |
|
2521 return error; |
|
2522 } |
|
2523 |
|
2524 // -------------------------------------------------------------------------- |
|
2525 // CIptvEpgDb::ResetGlobalId() |
|
2526 // -------------------------------------------------------------------------- |
|
2527 // |
|
2528 TInt CIptvEpgDb::ResetGlobalId( CIptvMyVideosGlobalFileId& aId ) |
|
2529 { |
|
2530 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ResetGlobalId" ); |
|
2531 |
|
2532 TInt error( KErrNone ); |
|
2533 |
|
2534 TRAPD( err, ResetGlobalIdL( aId, error ) ); |
|
2535 |
|
2536 if ( KErrNone != err ) |
|
2537 { |
|
2538 IPTVLOGSTRING2_LOW_LEVEL( |
|
2539 "CIptvEpgDb::ResetGlobalId, failed: %d", err ); |
|
2540 error = err; |
|
2541 } |
|
2542 |
|
2543 return error; |
|
2544 } |
|
2545 |
|
2546 // -------------------------------------------------------------------------- |
|
2547 // CIptvEpgDb::ResetGlobalIdL() |
|
2548 // -------------------------------------------------------------------------- |
|
2549 // |
|
2550 void CIptvEpgDb::ResetGlobalIdL( |
|
2551 CIptvMyVideosGlobalFileId& aId, |
|
2552 TInt& aError ) |
|
2553 { |
|
2554 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ResetGlobalIdL" ); |
|
2555 |
|
2556 // Find content access object with given GFID -> reset GFID -> |
|
2557 // check content access "parent" -> reset parent's GFID which is same as |
|
2558 // given global file id (parameter) |
|
2559 |
|
2560 TInt key = KErrNotFound; |
|
2561 |
|
2562 // Reset global file id from content access |
|
2563 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2564 TPtr16 sqlPtr = sql->Des(); |
|
2565 |
|
2566 sqlPtr.Append( KSqlSelect ); |
|
2567 sqlPtr.Append( KSqlAll ); |
|
2568 sqlPtr.Append( KSqlFrom ); |
|
2569 sqlPtr.Append( KIptvCATable ); |
|
2570 sqlPtr.Append( KSqlWhere ); |
|
2571 sqlPtr.Append( KIptvCAFileId ); |
|
2572 sqlPtr.Append( KSqlIs ); |
|
2573 sqlPtr.AppendNum( TInt64( aId.iFileId ) ); |
|
2574 sqlPtr.Append( KSqlAnd ); |
|
2575 sqlPtr.Append( KIptvCADriveId ); |
|
2576 sqlPtr.Append( KSqlIs ); |
|
2577 sqlPtr.AppendNum( TInt64( aId.iDrive ) ); |
|
2578 |
|
2579 RDbView view; |
|
2580 aError = view.Prepare( |
|
2581 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2582 if ( aError == KErrNone ) |
|
2583 { |
|
2584 view.EvaluateAll(); |
|
2585 view.FirstL(); |
|
2586 TInt count = view.CountL(); |
|
2587 if ( count > 0 ) |
|
2588 { |
|
2589 view.UpdateL(); |
|
2590 CDbColSet* cs = view.ColSetL(); |
|
2591 CleanupStack::PushL( cs ); |
|
2592 view.SetColL( cs->ColNo( KIptvCAFileId ), KIptvFileId ); |
|
2593 view.SetColL( cs->ColNo( KIptvCADriveId ), KIptvDrive ); |
|
2594 view.PutL(); |
|
2595 |
|
2596 // Get content key |
|
2597 TInt keyCol = cs->ColNo( KIptvCAContentKey ); |
|
2598 key = view.ColUint32( keyCol ); |
|
2599 CleanupStack::PopAndDestroy( cs ); |
|
2600 } |
|
2601 } |
|
2602 |
|
2603 view.Close(); |
|
2604 |
|
2605 // Check content access "parent" |
|
2606 // -> reset parent's GFID which is same as given global file id (parameter) |
|
2607 |
|
2608 if ( key != KErrNotFound ) |
|
2609 { |
|
2610 sqlPtr.Zero(); |
|
2611 sqlPtr.Append( KSqlSelect ); |
|
2612 sqlPtr.Append( KSqlAll ); |
|
2613 sqlPtr.Append( KSqlFrom ); |
|
2614 sqlPtr.Append( KIptvEpgContentTable ); |
|
2615 sqlPtr.Append( KSqlWhere ); |
|
2616 sqlPtr.Append( KIptvEpgContentDbKeyCol ); |
|
2617 sqlPtr.Append( KSqlIs ); |
|
2618 sqlPtr.AppendNum( TInt64( key ) ); |
|
2619 |
|
2620 aError = view.Prepare( |
|
2621 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2622 if ( aError == KErrNone ) |
|
2623 { |
|
2624 view.EvaluateAll(); |
|
2625 view.FirstL(); |
|
2626 view.GetL(); |
|
2627 TInt count = view.CountL(); |
|
2628 if ( count > 0 ) |
|
2629 { |
|
2630 // Get global file id |
|
2631 CDbColSet* colSet = view.ColSetL(); |
|
2632 |
|
2633 TInt fileId = view.ColUint32( |
|
2634 colSet->ColNo( KIptvEpgContentDbFileIdCol ) ); |
|
2635 TInt driveId = view.ColUint32( |
|
2636 colSet->ColNo( KIptvEpgContentDbDriveIdCol ) ); |
|
2637 |
|
2638 // Get preview global file id |
|
2639 TInt pFileId = view.ColUint32( |
|
2640 colSet->ColNo( KIptvEpgContentDbPreviewFileIdCol ) ); |
|
2641 TInt pDriveId = view.ColUint32( |
|
2642 colSet->ColNo( KIptvEpgContentDbPreviewDriveIdCol ) ); |
|
2643 |
|
2644 delete colSet; |
|
2645 |
|
2646 view.UpdateL(); |
|
2647 CDbColSet* c = view.ColSetL(); |
|
2648 CleanupStack::PushL( c ); |
|
2649 |
|
2650 if ( fileId == aId.iFileId && driveId == aId.iDrive ) |
|
2651 { |
|
2652 view.SetColL( c->ColNo( |
|
2653 KIptvEpgContentDbFileIdCol ), |
|
2654 KIptvFileId ); |
|
2655 view.SetColL( c->ColNo( |
|
2656 KIptvEpgContentDbDriveIdCol ), |
|
2657 KIptvDrive ); |
|
2658 } |
|
2659 if ( pFileId == aId.iFileId && pDriveId == aId.iDrive ) |
|
2660 { |
|
2661 view.SetColL( c->ColNo( |
|
2662 KIptvEpgContentDbPreviewFileIdCol ), KIptvFileId ); |
|
2663 view.SetColL( c->ColNo( |
|
2664 KIptvEpgContentDbPreviewDriveIdCol ), KIptvDrive ); |
|
2665 } |
|
2666 |
|
2667 view.PutL(); |
|
2668 CleanupStack::PopAndDestroy( c ); |
|
2669 } |
|
2670 } |
|
2671 view.Close(); |
|
2672 } |
|
2673 |
|
2674 CleanupStack::PopAndDestroy( sql ); |
|
2675 } |
|
2676 |
|
2677 // -------------------------------------------------------------------------- |
|
2678 // CIptvEpgDb::SetGlobalId() |
|
2679 // -------------------------------------------------------------------------- |
|
2680 // |
|
2681 TInt CIptvEpgDb::SetGlobalId( |
|
2682 TUint32 aContentKey, |
|
2683 CIptvMyVideosGlobalFileId& aId, |
|
2684 TUint32 aIndex ) |
|
2685 { |
|
2686 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::SetGlobalId" ); |
|
2687 |
|
2688 TInt error( KErrNone ); |
|
2689 |
|
2690 TRAPD( err, SetGlobalIdL( aContentKey, aId, aIndex, error ) ); |
|
2691 |
|
2692 if ( KErrNone != err ) |
|
2693 { |
|
2694 IPTVLOGSTRING2_LOW_LEVEL( |
|
2695 "CIptvEpgDb::SetGlobalId, failed: %d", err ); |
|
2696 error = err; |
|
2697 } |
|
2698 |
|
2699 return error; |
|
2700 } |
|
2701 |
|
2702 // -------------------------------------------------------------------------- |
|
2703 // CIptvEpgDb::SetGlobalIdL() |
|
2704 // -------------------------------------------------------------------------- |
|
2705 // |
|
2706 void CIptvEpgDb::SetGlobalIdL( |
|
2707 TUint32 aContentKey, |
|
2708 CIptvMyVideosGlobalFileId& aId, |
|
2709 TUint32 aIndex, |
|
2710 TInt& aError ) |
|
2711 { |
|
2712 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::SetGlobalIdL" ); |
|
2713 |
|
2714 // Set global file id first to content access object. |
|
2715 // If content access is "full" or "preview" version, |
|
2716 // set global file id also to main content object. |
|
2717 |
|
2718 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
2719 TPtr16 sqlPtr = sql->Des(); |
|
2720 sqlPtr.Append( KSqlSelect ); |
|
2721 sqlPtr.Append( KSqlAll ); |
|
2722 sqlPtr.Append( KSqlFrom ); |
|
2723 sqlPtr.Append( KIptvCATable ); |
|
2724 sqlPtr.Append( KSqlWhere ); |
|
2725 sqlPtr.Append( KIptvCAContentKey ); |
|
2726 sqlPtr.Append( KSqlIs ); |
|
2727 sqlPtr.AppendNum( TInt64( aContentKey ) ); |
|
2728 sqlPtr.Append( KSqlAnd ); |
|
2729 sqlPtr.Append( KIptvCAIndex ); |
|
2730 sqlPtr.Append( KSqlIs ); |
|
2731 sqlPtr.AppendNum( TInt64( aIndex ) ); |
|
2732 |
|
2733 TInt expression( KValueNotSet ); |
|
2734 RDbView view; |
|
2735 aError = view.Prepare( |
|
2736 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2737 if ( aError == KErrNone ) |
|
2738 { |
|
2739 view.EvaluateAll(); |
|
2740 view.FirstL(); |
|
2741 TInt count = view.CountL(); |
|
2742 if ( count > 0 ) |
|
2743 { |
|
2744 view.UpdateL(); |
|
2745 CDbColSet* cs = view.ColSetL(); |
|
2746 CleanupStack::PushL( cs ); |
|
2747 view.SetColL( cs->ColNo( KIptvCAFileId ), aId.iFileId ); |
|
2748 view.SetColL( cs->ColNo( KIptvCADriveId ), aId.iDrive ); |
|
2749 view.PutL(); |
|
2750 |
|
2751 // Get expression |
|
2752 TInt expCol = cs->ColNo( KIptvCAExpression ); |
|
2753 expression = view.ColUint32( expCol ); |
|
2754 CleanupStack::PopAndDestroy( cs ); |
|
2755 } |
|
2756 else |
|
2757 { |
|
2758 IPTVLOGSTRING2_LOW_LEVEL( |
|
2759 "CIptvEpgDb::SetGlobalIdL NO CONTENT ACCESS FOUND WITH ID %d", |
|
2760 aContentKey ); |
|
2761 } |
|
2762 } |
|
2763 |
|
2764 view.Close(); |
|
2765 |
|
2766 if ( ( expression == CIptvMediaContent::EFull ) || |
|
2767 ( expression == CIptvMediaContent::ESample ) ) |
|
2768 { |
|
2769 sqlPtr.Zero(); |
|
2770 sqlPtr.Append( KSqlSelect ); |
|
2771 sqlPtr.Append( KSqlAll ); |
|
2772 sqlPtr.Append( KSqlFrom ); |
|
2773 sqlPtr.Append( KIptvEpgContentTable ); |
|
2774 sqlPtr.Append( KSqlWhere ); |
|
2775 sqlPtr.Append( KIptvEpgContentDbKeyCol ); |
|
2776 sqlPtr.Append( KSqlIs ); |
|
2777 sqlPtr.AppendNum( TInt64( aContentKey ) ); |
|
2778 |
|
2779 aError = view.Prepare( |
|
2780 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2781 if ( aError == KErrNone ) |
|
2782 { |
|
2783 view.EvaluateAll(); |
|
2784 view.FirstL(); |
|
2785 TInt count = view.CountL(); |
|
2786 if ( count > 0 ) |
|
2787 { |
|
2788 view.UpdateL(); |
|
2789 CDbColSet* c = view.ColSetL(); |
|
2790 CleanupStack::PushL( c ); |
|
2791 |
|
2792 if ( expression == CIptvMediaContent::EFull ) |
|
2793 { |
|
2794 view.SetColL( |
|
2795 c->ColNo( KIptvEpgContentDbFileIdCol ), |
|
2796 aId.iFileId ); |
|
2797 view.SetColL( |
|
2798 c->ColNo( KIptvEpgContentDbDriveIdCol ), |
|
2799 aId.iDrive ); |
|
2800 } |
|
2801 |
|
2802 if ( expression == CIptvMediaContent::ESample ) |
|
2803 { |
|
2804 view.SetColL( |
|
2805 c->ColNo( KIptvEpgContentDbPreviewFileIdCol ), |
|
2806 aId.iFileId ); |
|
2807 view.SetColL( |
|
2808 c->ColNo( KIptvEpgContentDbPreviewDriveIdCol ), |
|
2809 aId.iDrive ); |
|
2810 } |
|
2811 |
|
2812 view.PutL(); |
|
2813 CleanupStack::PopAndDestroy( c ); |
|
2814 } |
|
2815 else |
|
2816 { |
|
2817 IPTVLOGSTRING2_LOW_LEVEL( |
|
2818 "CIptvEpgDb::SetGlobalIdL NO CONTENT FOUND WITH ID %d", aContentKey ); |
|
2819 } |
|
2820 } |
|
2821 |
|
2822 view.Close(); |
|
2823 } |
|
2824 |
|
2825 CleanupStack::PopAndDestroy( sql ); |
|
2826 } |
|
2827 |
|
2828 // Engine 1.1 |
|
2829 |
|
2830 // -------------------------------------------------------------------------- |
|
2831 // Start updating to temporary work database. |
|
2832 // -------------------------------------------------------------------------- |
|
2833 // |
|
2834 void CIptvEpgDb::StartUpdateL() |
|
2835 { |
|
2836 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::StartUpdateL" ); |
|
2837 |
|
2838 // In error case, work database may be left open. |
|
2839 if ( iTmpDbOpen ) |
|
2840 { |
|
2841 iTmpDb.Close(); |
|
2842 iTmpDbOpen = EFalse; |
|
2843 } |
|
2844 |
|
2845 iTmpDbName.Zero(); |
|
2846 iTmpDbName.Copy( iEpgFile ); |
|
2847 iTmpDbName.Append( KIptvTmp ); |
|
2848 IPTVLOGSTRING2_LOW_LEVEL( |
|
2849 "CIptvEpgDb::StartUpdateL -- TMP database is %S", &iTmpDbName ); |
|
2850 |
|
2851 if ( BaflUtils::FileExists( iFsSession, iTmpDbName ) ) |
|
2852 { |
|
2853 CFileMan* fileMan = CFileMan::NewL( iFsSession ); |
|
2854 fileMan->Delete( iTmpDbName ); |
|
2855 delete fileMan; |
|
2856 } |
|
2857 |
|
2858 TBool created = EFalse; |
|
2859 CreateDbL( iTmpDbName, created ); |
|
2860 OpenDatabaseL( iTmpDb, iTmpDbName ); |
|
2861 iTmpDbOpen = ETrue; |
|
2862 |
|
2863 // If new database created -> Set service information |
|
2864 if ( created ) |
|
2865 { |
|
2866 TTime a( TInt64( 0 ) ); |
|
2867 SetServiceInformationL( iTmpDb, a, a ); |
|
2868 CreateRootCategoryL( iTmpDb ); |
|
2869 created = EFalse; |
|
2870 } |
|
2871 } |
|
2872 |
|
2873 // -------------------------------------------------------------------------- |
|
2874 // Replace used database with work database just completed to update. |
|
2875 // -------------------------------------------------------------------------- |
|
2876 // |
|
2877 void CIptvEpgDb::EndUpdateL( CIptvEpgSession& aSession ) |
|
2878 { |
|
2879 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::EndUpdateL() - Enter" ); |
|
2880 |
|
2881 RPointerArray<CIptvMediaContent> contents; |
|
2882 CleanupResetAndDestroyPushL( contents ); |
|
2883 RArray<TUint32> oldContentIds; |
|
2884 CleanupClosePushL( oldContentIds ); |
|
2885 RArray<TUint32> newContentIds; |
|
2886 CleanupClosePushL( newContentIds ); |
|
2887 |
|
2888 // Copy global file ID's from EPG database to temporary array. |
|
2889 GetGlobalFileIdsL( contents ); |
|
2890 |
|
2891 // Close old epg database and delete it. |
|
2892 iEpgDb.Close(); |
|
2893 CFileMan* fileMan = CFileMan::NewL( iFsSession ); |
|
2894 CleanupStack::PushL( fileMan ); |
|
2895 fileMan->Delete( iEpgFile ); |
|
2896 |
|
2897 // Copy global file ID's to temporal DB. |
|
2898 TInt count = contents.Count(); |
|
2899 IPTVLOGSTRING2_LOW_LEVEL( |
|
2900 "CIptvEpgDb::EndUpdateL -- %d items were downloaded before update!", |
|
2901 count ); |
|
2902 for ( TInt i = 0; i < count; i++ ) |
|
2903 { |
|
2904 CopyGlobalFileIdToNewDbL( contents[i], oldContentIds, newContentIds ); |
|
2905 } |
|
2906 |
|
2907 // Rename temporary DB to EPG DB. |
|
2908 iTmpDb.Close(); |
|
2909 iTmpDbOpen = EFalse; |
|
2910 fileMan->Copy( iTmpDbName, iEpgFile ); |
|
2911 fileMan->Delete( iTmpDbName ); |
|
2912 iTmpDbName.Zero(); |
|
2913 OpenDatabaseL( iEpgDb, iEpgFile ); |
|
2914 |
|
2915 |
|
2916 // If everything went ok, update changed Content IDs to others. |
|
2917 if ( ( oldContentIds.Count() > 0 ) && |
|
2918 ( oldContentIds.Count() == newContentIds.Count() ) ) |
|
2919 { |
|
2920 aSession.UpdateChangedContentIdsL( oldContentIds, newContentIds ); |
|
2921 } |
|
2922 |
|
2923 CleanupStack::PopAndDestroy( fileMan ); |
|
2924 CleanupStack::PopAndDestroy( &newContentIds ); |
|
2925 CleanupStack::PopAndDestroy( &oldContentIds ); |
|
2926 CleanupStack::PopAndDestroy(); // contents |
|
2927 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::EndUpdateL() - Exit" ); |
|
2928 } |
|
2929 |
|
2930 // -------------------------------------------------------------------------- |
|
2931 // Finish database update and delete work database if still exists. |
|
2932 // -------------------------------------------------------------------------- |
|
2933 // |
|
2934 void CIptvEpgDb::FinishUpdateL() |
|
2935 { |
|
2936 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::FinishUpdateL" ); |
|
2937 |
|
2938 if ( iTmpDbOpen ) |
|
2939 { |
|
2940 iTmpDb.Close(); |
|
2941 iTmpDbOpen = EFalse; |
|
2942 CFileMan* fileMan = CFileMan::NewL( iFsSession ); |
|
2943 fileMan->Delete( iTmpDbName ); |
|
2944 iTmpDbName.Zero(); |
|
2945 delete fileMan; |
|
2946 } |
|
2947 } |
|
2948 |
|
2949 // -------------------------------------------------------------------------- |
|
2950 // CIptvEpgDb::CopyGlobalFileIdToNewDbL() |
|
2951 // -------------------------------------------------------------------------- |
|
2952 // |
|
2953 void CIptvEpgDb::CopyGlobalFileIdToNewDbL( CIptvMediaContent* aContent, |
|
2954 RArray<TUint32>& aOldContentIds, |
|
2955 RArray<TUint32>& aNewContentIds ) |
|
2956 { |
|
2957 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CopyGlobalFileIdToNewDbL()" ); |
|
2958 IPTVLOGSTRING_LOW_LEVEL( "Copying old global file IDs to new DB from content." ); |
|
2959 |
|
2960 if ( aContent ) |
|
2961 { |
|
2962 aContent->PrintL(); |
|
2963 |
|
2964 HBufC* sql = HBufC::NewLC( |
|
2965 KCustomSqlMaxLength + aContent->GetMediaContentUrl().Length() ); |
|
2966 TPtr16 sqlPtr = sql->Des(); |
|
2967 TUint32 contentKey( KIptvInvalidContentId ); |
|
2968 |
|
2969 sqlPtr.Append( KSqlSelect ); |
|
2970 sqlPtr.Append( KSqlAll ); |
|
2971 sqlPtr.Append( KSqlFrom ); |
|
2972 sqlPtr.Append( KIptvCATable ); |
|
2973 sqlPtr.Append( KSqlWhere ); |
|
2974 sqlPtr.Append( KIptvCAContentUrl ); |
|
2975 sqlPtr.Append( KSqlIs ); |
|
2976 sqlPtr.Append( KHyp ); |
|
2977 sqlPtr.Append( aContent->GetMediaContentUrl() ); |
|
2978 sqlPtr.Append( KHyp ); |
|
2979 |
|
2980 TInt expression( KValueNotSet ); |
|
2981 RDbView view; |
|
2982 TInt error = KErrNone; |
|
2983 error = view.Prepare( |
|
2984 iTmpDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
2985 if ( error == KErrNone ) |
|
2986 { |
|
2987 view.EvaluateAll(); |
|
2988 view.FirstL(); |
|
2989 TInt count = view.CountL(); |
|
2990 if ( count > 0 ) |
|
2991 { |
|
2992 CDbColSet* cs = view.ColSetL(); |
|
2993 CleanupStack::PushL( cs ); |
|
2994 |
|
2995 // Get expression & content key from DB. |
|
2996 view.GetL(); |
|
2997 TInt expCol = cs->ColNo( KIptvCAExpression ); |
|
2998 expression = view.ColUint32( expCol ); |
|
2999 TInt contentCol = cs->ColNo( KIptvCAContentKey ); |
|
3000 contentKey = view.ColUint32( contentCol ); |
|
3001 |
|
3002 // Update global file ID to DB. |
|
3003 view.UpdateL(); |
|
3004 view.SetColL( cs->ColNo( KIptvCAFileId ), aContent->iFileId ); |
|
3005 view.SetColL( cs->ColNo( KIptvCADriveId ), aContent->iDriveId ); |
|
3006 view.PutL(); |
|
3007 |
|
3008 CleanupStack::PopAndDestroy( cs ); |
|
3009 } |
|
3010 } |
|
3011 view.Close(); |
|
3012 |
|
3013 // Store information about Content ID changes. Note that client |
|
3014 // gets also a notification of removed items as new Content ID |
|
3015 // can be KIptvInvalidContentId. |
|
3016 if ( aContent->iContentKey != contentKey ) |
|
3017 { |
|
3018 aOldContentIds.AppendL( aContent->iContentKey ); |
|
3019 aNewContentIds.AppendL( contentKey ); |
|
3020 } |
|
3021 |
|
3022 if ( ( expression == CIptvMediaContent::EFull ) || |
|
3023 ( expression == CIptvMediaContent::ESample ) ) |
|
3024 { |
|
3025 sqlPtr.Zero(); |
|
3026 sqlPtr.Append( KSqlSelect ); |
|
3027 sqlPtr.Append( KSqlAll ); |
|
3028 sqlPtr.Append( KSqlFrom ); |
|
3029 sqlPtr.Append( KIptvEpgContentTable ); |
|
3030 sqlPtr.Append( KSqlWhere ); |
|
3031 sqlPtr.Append( KIptvEpgContentDbKeyCol ); |
|
3032 sqlPtr.Append( KSqlIs ); |
|
3033 sqlPtr.AppendNum( TInt64( contentKey ) ); |
|
3034 |
|
3035 error = view.Prepare( |
|
3036 iTmpDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
3037 |
|
3038 if ( error == KErrNone ) |
|
3039 { |
|
3040 view.EvaluateAll(); |
|
3041 view.FirstL(); |
|
3042 view.UpdateL(); |
|
3043 CDbColSet* colSet = view.ColSetL(); |
|
3044 CleanupStack::PushL( colSet ); |
|
3045 |
|
3046 if ( expression == CIptvMediaContent::EFull ) |
|
3047 { |
|
3048 view.SetColL( |
|
3049 colSet->ColNo( KIptvEpgContentDbFileIdCol ), |
|
3050 aContent->iFileId ); |
|
3051 view.SetColL( |
|
3052 colSet->ColNo( KIptvEpgContentDbDriveIdCol ), |
|
3053 aContent->iDriveId ); |
|
3054 } |
|
3055 |
|
3056 if ( expression == CIptvMediaContent::ESample ) |
|
3057 { |
|
3058 view.SetColL( |
|
3059 colSet->ColNo( KIptvEpgContentDbPreviewFileIdCol ), |
|
3060 aContent->iFileId ); |
|
3061 view.SetColL( |
|
3062 colSet->ColNo( KIptvEpgContentDbPreviewDriveIdCol ), |
|
3063 aContent->iDriveId ); |
|
3064 } |
|
3065 |
|
3066 view.PutL(); |
|
3067 CleanupStack::PopAndDestroy( colSet ); |
|
3068 } |
|
3069 |
|
3070 view.Close(); |
|
3071 } |
|
3072 |
|
3073 CleanupStack::PopAndDestroy( sql ); |
|
3074 } |
|
3075 } |
|
3076 |
|
3077 // -------------------------------------------------------------------------- |
|
3078 // Fetch content access from database. |
|
3079 // -------------------------------------------------------------------------- |
|
3080 // |
|
3081 CIptvMediaContent* CIptvEpgDb::GetContentAccessL( |
|
3082 TUint32 aContentId, TUint32 aIndex ) |
|
3083 { |
|
3084 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetContentAccessL" ); |
|
3085 |
|
3086 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
3087 TPtr16 sqlPtr = sql->Des(); |
|
3088 |
|
3089 sqlPtr.Append( KSqlSelect ); |
|
3090 sqlPtr.Append( KSqlAll ); |
|
3091 sqlPtr.Append( KSqlFrom ); |
|
3092 sqlPtr.Append( KIptvCATable ); |
|
3093 sqlPtr.Append( KSqlWhere ); |
|
3094 sqlPtr.Append( KIptvCAContentKey ); |
|
3095 sqlPtr.Append( KSqlIs ); |
|
3096 sqlPtr.AppendNum( TInt64( aContentId ) ); |
|
3097 sqlPtr.Append( KSqlAnd ); |
|
3098 sqlPtr.Append( KIptvCAIndex ); |
|
3099 sqlPtr.Append( KSqlIs ); |
|
3100 sqlPtr.AppendNum( TInt64( aIndex ) ); |
|
3101 |
|
3102 RDbView view; |
|
3103 CIptvMediaContent* content = NULL; |
|
3104 TInt error = view.Prepare( |
|
3105 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
3106 |
|
3107 CleanupStack::PopAndDestroy( sql ); |
|
3108 |
|
3109 if ( error == KErrNone ) |
|
3110 { |
|
3111 view.EvaluateAll(); |
|
3112 view.FirstL(); |
|
3113 while ( view.AtRow() ) |
|
3114 { |
|
3115 view.GetL(); |
|
3116 content = ReadContentAccessFromDbL( view ); |
|
3117 view.NextL(); |
|
3118 } |
|
3119 } |
|
3120 |
|
3121 view.Close(); |
|
3122 |
|
3123 return content; |
|
3124 } |
|
3125 |
|
3126 // -------------------------------------------------------------------------- |
|
3127 // Fetch content access list from database. |
|
3128 // -------------------------------------------------------------------------- |
|
3129 // |
|
3130 TInt CIptvEpgDb::GetContentAccessListL( |
|
3131 TUint32 aContentId, |
|
3132 RPointerArray<CIptvMediaContent>& aContents ) |
|
3133 { |
|
3134 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetContentAccessListL" ); |
|
3135 |
|
3136 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
3137 TPtr16 sqlPtr = sql->Des(); |
|
3138 |
|
3139 sqlPtr.Append( KSqlSelect ); |
|
3140 sqlPtr.Append( KSqlAll ); |
|
3141 sqlPtr.Append( KSqlFrom ); |
|
3142 sqlPtr.Append( KIptvCATable ); |
|
3143 sqlPtr.Append( KSqlWhere ); |
|
3144 sqlPtr.Append( KIptvCAContentKey ); |
|
3145 sqlPtr.Append( KSqlIs ); |
|
3146 sqlPtr.AppendNum( TInt64( aContentId ) ); |
|
3147 |
|
3148 RDbView view; |
|
3149 TInt error = view.Prepare( |
|
3150 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
3151 |
|
3152 CleanupStack::PopAndDestroy( sql ); |
|
3153 |
|
3154 if ( error == KErrNone ) |
|
3155 { |
|
3156 view.EvaluateAll(); |
|
3157 view.FirstL(); |
|
3158 while ( view.AtRow() ) |
|
3159 { |
|
3160 view.GetL(); |
|
3161 CIptvMediaContent* p = ReadContentAccessFromDbL( view ); |
|
3162 if ( p ) |
|
3163 { |
|
3164 aContents.AppendL( p ); |
|
3165 } |
|
3166 view.NextL(); |
|
3167 } |
|
3168 } |
|
3169 |
|
3170 view.Close(); |
|
3171 |
|
3172 return error; |
|
3173 } |
|
3174 |
|
3175 // -------------------------------------------------------------------------- |
|
3176 // |
|
3177 // -------------------------------------------------------------------------- |
|
3178 // |
|
3179 void CIptvEpgDb::GetGlobalFileIdsL( |
|
3180 RPointerArray<CIptvMediaContent>& aContents ) |
|
3181 { |
|
3182 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetGlobalFileIdsL" ); |
|
3183 |
|
3184 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
3185 TPtr16 sqlPtr = sql->Des(); |
|
3186 sqlPtr.Append( KSqlSelect ); |
|
3187 sqlPtr.Append( KSqlAll ); |
|
3188 sqlPtr.Append( KSqlFrom ); |
|
3189 sqlPtr.Append( KIptvCATable ); |
|
3190 sqlPtr.Append( KSqlWhere ); |
|
3191 sqlPtr.Append( KIptvCAFileId ); |
|
3192 sqlPtr.Append( KSqlNot ); |
|
3193 sqlPtr.AppendNum( TInt64( 0 ) ); |
|
3194 sqlPtr.Append( KSqlOr ); |
|
3195 sqlPtr.Append( KIptvCADriveId ); |
|
3196 sqlPtr.Append( KSqlNot ); |
|
3197 sqlPtr.AppendNum( TInt64( 0 ) ); |
|
3198 |
|
3199 RDbView view; |
|
3200 TInt error = view.Prepare( |
|
3201 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
3202 |
|
3203 CleanupStack::PopAndDestroy( sql ); |
|
3204 |
|
3205 if ( error == KErrNone ) |
|
3206 { |
|
3207 view.EvaluateAll(); |
|
3208 view.FirstL(); |
|
3209 while ( view.AtRow() ) |
|
3210 { |
|
3211 view.GetL(); |
|
3212 CIptvMediaContent* p = ReadContentAccessFromDbL( view ); |
|
3213 if ( p ) |
|
3214 { |
|
3215 aContents.AppendL( p ); |
|
3216 } |
|
3217 view.NextL(); |
|
3218 } |
|
3219 } |
|
3220 |
|
3221 view.Close(); |
|
3222 } |
|
3223 |
|
3224 // -------------------------------------------------------------------------- |
|
3225 // |
|
3226 // -------------------------------------------------------------------------- |
|
3227 // |
|
3228 CIptvMediaContent* CIptvEpgDb::ReadContentAccessFromDbL( |
|
3229 const RDbView& aView ) const |
|
3230 { |
|
3231 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ReadContentAccessFromDbL" ); |
|
3232 |
|
3233 CIptvMediaContent* content = CIptvMediaContent::NewL(); |
|
3234 CleanupStack::PushL( content ); |
|
3235 |
|
3236 CDbColSet* cs = aView.ColSetL(); |
|
3237 CleanupStack::PushL( cs ); |
|
3238 |
|
3239 // Content key |
|
3240 content->iContentKey = aView.ColUint32( cs->ColNo( KIptvCAContentKey ) ); |
|
3241 |
|
3242 // Content URL |
|
3243 RDbColReadStream readStream; |
|
3244 TInt col = cs->ColNo( KIptvCAContentUrl ); |
|
3245 readStream.OpenLC( aView, col ); |
|
3246 TInt dataToCopy = Min( KIptvCAContentUrlLength, aView.ColLength( col ) ); |
|
3247 |
|
3248 HBufC* url = HBufC::NewLC( dataToCopy ); |
|
3249 TPtr16 p = url->Des(); |
|
3250 |
|
3251 readStream.ReadL( p, dataToCopy ); |
|
3252 content->SetMediaContentUrlL( p ); |
|
3253 |
|
3254 CleanupStack::PopAndDestroy( url ); |
|
3255 readStream.Close(); |
|
3256 CleanupStack::Pop( &readStream ); |
|
3257 |
|
3258 // Download type |
|
3259 content->iDownloadType = aView.ColUint32( cs->ColNo( KIptvCADlType ) ); |
|
3260 |
|
3261 // Language |
|
3262 TPtrC lan; |
|
3263 lan.Set( aView.ColDes( cs->ColNo( KIptvCALanguage ) ) ); |
|
3264 dataToCopy = Min( lan.Length(), KIptvCALanguageLength ); |
|
3265 content->iLanguage.Copy( lan.Mid( 0, dataToCopy ) ); |
|
3266 |
|
3267 // Last play position |
|
3268 content->iLastPosition = aView.ColUint32( cs->ColNo( KIptvCALastPlayPosition ) ); |
|
3269 |
|
3270 // Mime type |
|
3271 TPtrC mime; |
|
3272 mime.Set( aView.ColDes( cs->ColNo( KIptvCAMimeType ) ) ); |
|
3273 dataToCopy = Min( mime.Length(), KIptvCAMimeTypeLength ); |
|
3274 content->iMimeType.Copy( mime.Mid( 0, dataToCopy ) ); |
|
3275 |
|
3276 // File size |
|
3277 content->iFileSize = aView.ColUint32( cs->ColNo( KIptvCAFileSize ) ); |
|
3278 |
|
3279 // Duration |
|
3280 content->iDuration = aView.ColUint32( cs->ColNo( KIptvCADuration ) ); |
|
3281 |
|
3282 // File id |
|
3283 content->iFileId = aView.ColUint32( cs->ColNo( KIptvCAFileId ) ); |
|
3284 |
|
3285 // Drive id |
|
3286 content->iDriveId = aView.ColUint32( cs->ColNo( KIptvCADriveId ) ); |
|
3287 |
|
3288 // Index |
|
3289 content->iIndex = aView.ColUint32( cs->ColNo( KIptvCAIndex ) ); |
|
3290 |
|
3291 // Expression |
|
3292 content->iExpression = aView.ColUint32( cs->ColNo( KIptvCAExpression ) ); |
|
3293 |
|
3294 // Price |
|
3295 // Not in media content |
|
3296 |
|
3297 // Purchase type |
|
3298 // Not in mediacontent |
|
3299 |
|
3300 // Purchase URL |
|
3301 // Not in media content |
|
3302 |
|
3303 // Last play position |
|
3304 // Not in media content |
|
3305 |
|
3306 CleanupStack::PopAndDestroy( cs ); |
|
3307 CleanupStack::Pop( content ); |
|
3308 |
|
3309 return content; |
|
3310 } |
|
3311 |
|
3312 // -------------------------------------------------------------------------- |
|
3313 // |
|
3314 // -------------------------------------------------------------------------- |
|
3315 // |
|
3316 TInt CIptvEpgDb::SetLastPositionL( |
|
3317 TUint32 aContentId, TUint32 aIndex, TUint32 aPosition ) |
|
3318 { |
|
3319 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::SetLastPositionL" ); |
|
3320 |
|
3321 HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength ); |
|
3322 TPtr16 sqlPtr = sql->Des(); |
|
3323 |
|
3324 sqlPtr.Append( KSqlSelect ); |
|
3325 sqlPtr.Append( KSqlAll ); |
|
3326 sqlPtr.Append( KSqlFrom ); |
|
3327 sqlPtr.Append( KIptvCATable ); |
|
3328 sqlPtr.Append( KSqlWhere ); |
|
3329 sqlPtr.Append( KIptvCAContentKey ); |
|
3330 sqlPtr.Append( KSqlIs ); |
|
3331 sqlPtr.AppendNum( TInt64( aContentId ) ); |
|
3332 sqlPtr.Append( KSqlAnd ); |
|
3333 sqlPtr.Append( KIptvCAIndex ); |
|
3334 sqlPtr.Append( KSqlIs ); |
|
3335 sqlPtr.AppendNum( TInt64( aIndex ) ); |
|
3336 |
|
3337 RDbView view; |
|
3338 TInt error = view.Prepare( |
|
3339 iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited ); |
|
3340 |
|
3341 CleanupStack::PopAndDestroy( sql ); |
|
3342 |
|
3343 if ( error == KErrNone ) |
|
3344 { |
|
3345 view.EvaluateAll(); |
|
3346 if ( !view.IsEmptyL() ) |
|
3347 { |
|
3348 view.FirstL(); |
|
3349 view.UpdateL(); |
|
3350 |
|
3351 CDbColSet* cs = view.ColSetL(); |
|
3352 CleanupStack::PushL( cs ); |
|
3353 view.SetColL( cs->ColNo( KIptvCALastPlayPosition ), aPosition ); |
|
3354 CleanupStack::PopAndDestroy( cs ); |
|
3355 view.PutL(); |
|
3356 } |
|
3357 } |
|
3358 |
|
3359 view.Close(); |
|
3360 |
|
3361 return error; |
|
3362 } |
|
3363 |
|
3364 // -------------------------------------------------------------------------- |
|
3365 // |
|
3366 // -------------------------------------------------------------------------- |
|
3367 // |
|
3368 TInt CIptvEpgDb::SetMpxIdL( TUint32 aContentId, |
|
3369 TUint32 aCaIndex, |
|
3370 TUint32 aMpxId ) |
|
3371 { |
|
3372 // check the final way to store mpx id. |
|
3373 |
|
3374 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::SetLastPositionL" ); |
|
3375 TInt error(KErrNone); |
|
3376 CIptvMyVideosGlobalFileId* fileId = CIptvMyVideosGlobalFileId::NewL(); |
|
3377 CleanupStack::PushL( fileId ); |
|
3378 |
|
3379 fileId->iFileId = aMpxId; |
|
3380 |
|
3381 SetGlobalIdL( aContentId, *fileId, aCaIndex, error ); |
|
3382 |
|
3383 CleanupStack::PopAndDestroy( fileId ); |
|
3384 |
|
3385 return error; |
|
3386 } |
|
3387 |
|
3388 // -------------------------------------------------------------------------- |
|
3389 // CIptvEpgDb::SetUpdateTimeToServiceManagerL |
|
3390 // -------------------------------------------------------------------------- |
|
3391 // |
|
3392 void CIptvEpgDb::SetUpdateTimeToServiceManagerL( const TTime& aTime ) |
|
3393 { |
|
3394 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::SetUpdateTimeToServiceManagerL" ); |
|
3395 |
|
3396 CIptvService* service = iServer.iServiceManager->GetServiceL( |
|
3397 iServiceId, ETrue /* do open/close */ ); |
|
3398 |
|
3399 if ( service ) |
|
3400 { |
|
3401 CleanupStack::PushL( service ); |
|
3402 service->SetEpgUpdateTimeL( aTime ); |
|
3403 iServer.iServiceManager->UpdateServiceL( *service ); |
|
3404 CleanupStack::PopAndDestroy( service ); |
|
3405 } |
|
3406 } |
|
3407 |
|
3408 // ----------------------------------------------------------------------------- |
|
3409 // CIptvMyVideosManagerImpl::ReadCenRepData() |
|
3410 // CenRep |
|
3411 // ----------------------------------------------------------------------------- |
|
3412 // |
|
3413 void CIptvEpgDb::ReadCenRepData() |
|
3414 { |
|
3415 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ReadCenRepData" ); |
|
3416 |
|
3417 if ( iCenRepSession ) |
|
3418 { |
|
3419 TInt age; |
|
3420 if ( iCenRepSession->Get( KIptvCenRepParentControlKey, age ) != KErrNone ) |
|
3421 { |
|
3422 age = KIptvCenRepParentControlKeyDefault; |
|
3423 } |
|
3424 |
|
3425 iParentalControl = age; |
|
3426 } |
|
3427 } |
|
3428 |
|
3429 // ----------------------------------------------------------------------------- |
|
3430 // CIptvMyVideosManagerImpl::HandleNotifyInt() |
|
3431 // CenRep |
|
3432 // ----------------------------------------------------------------------------- |
|
3433 // |
|
3434 void CIptvEpgDb::HandleNotifyInt( TUint32 aId, TInt aNewValue ) |
|
3435 { |
|
3436 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::HandleNotifyInt" ); |
|
3437 |
|
3438 if ( aId == KIptvCenRepParentControlKey ) |
|
3439 { |
|
3440 iParentalControl = aNewValue; |
|
3441 } |
|
3442 } |
|
3443 |
|
3444 // ----------------------------------------------------------------------------- |
|
3445 // CIptvMyVideosManagerImpl::HandleNotifyGeneric() |
|
3446 // CenRep |
|
3447 // ----------------------------------------------------------------------------- |
|
3448 // |
|
3449 void CIptvEpgDb::HandleNotifyGeneric( TUint32 aId ) |
|
3450 { |
|
3451 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::HandleNotifyGeneric" ); |
|
3452 |
|
3453 if ( aId == NCentralRepositoryConstants::KInvalidNotificationId || |
|
3454 aId == KIptvCenRepParentControlKey ) |
|
3455 { |
|
3456 ReadCenRepData(); |
|
3457 } |
|
3458 } |
|
3459 |
|
3460 // ----------------------------------------------------------------------------- |
|
3461 // CIptvMyVideosManagerImpl::HandleNotifyError() |
|
3462 // CenRep |
|
3463 // ----------------------------------------------------------------------------- |
|
3464 // |
|
3465 void CIptvEpgDb::HandleNotifyError( |
|
3466 TUint32 /*aId*/, TInt /*error*/, CCenRepNotifyHandler* /*aHandler*/ ) |
|
3467 { |
|
3468 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::HandleNotifyError" ); |
|
3469 } |
|
3470 |
|
3471 // --------------------------------------------------------------------------- |
|
3472 // |
|
3473 // --------------------------------------------------------------------------- |
|
3474 // |
|
3475 void CIptvEpgDb::DeleteDatabaseFiles( TBool aDelete ) |
|
3476 { |
|
3477 iDeleteDatabaseFiles = aDelete; |
|
3478 } |
|
3479 |
|
3480 // --------------------------------------------------------------------------- |
|
3481 // |
|
3482 // --------------------------------------------------------------------------- |
|
3483 // |
|
3484 void CIptvEpgDb::DeleteDatabaseL() |
|
3485 { |
|
3486 IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::DeleteDatabaseL" ); |
|
3487 |
|
3488 // Delete database file |
|
3489 TBuf<KIptvMaxPath> path; |
|
3490 CIptvUtil::GetPathL( iFsSession, EIptvPathEcg, path, EDriveC, EFalse ); |
|
3491 path.Append( KIptvEpgDbName ); |
|
3492 |
|
3493 TBuf<KIptvServiceIdMaxLength> service; |
|
3494 service.Num( iServiceId ); |
|
3495 path.Append( service ); |
|
3496 |
|
3497 if ( BaflUtils::FileExists( iFsSession, path ) ) |
|
3498 { |
|
3499 TInt err = BaflUtils::DeleteFile( iFsSession, path ); |
|
3500 IPTVLOGSTRING3_LOW_LEVEL( "CIptvEpgDb::DeleteDatabaseL --> deleted database : %S, err=%d", &path, err ); |
|
3501 } |
|
3502 |
|
3503 // Delete content thumbnails |
|
3504 path.Zero(); |
|
3505 CIptvUtil::GetPathL( iFsSession, EIptvPathEcg, path, EDriveC, EFalse ); |
|
3506 path.Append( service ); |
|
3507 path.Append( _L( "\\" ) ); |
|
3508 |
|
3509 if ( BaflUtils::FolderExists( iFsSession, path ) ) |
|
3510 { |
|
3511 CFileMan* fm = CFileMan::NewL( iFsSession ); |
|
3512 CleanupStack::PushL( fm ); |
|
3513 TInt error = fm->RmDir( path ); |
|
3514 if ( error == KErrNone ) |
|
3515 { |
|
3516 IPTVLOGSTRING2_LOW_LEVEL( "CIptvEpgDb::DeleteDatabaseL --> deleted thumbnail directory : %S", &path ); |
|
3517 } |
|
3518 CleanupStack::PopAndDestroy( fm ); |
|
3519 } |
|
3520 |
|
3521 // Delete service thumbnail |
|
3522 path.Zero(); |
|
3523 CIptvUtil::GetPathL( iFsSession, EIptvPathWritableRoot, path, EDriveC, EFalse ); |
|
3524 path.Append( _L( "srv\\" ) ); |
|
3525 path.Append( service ); |
|
3526 path.Append( _L( ".*" ) ); |
|
3527 |
|
3528 BaflUtils::DeleteFile( iFsSession, path ); |
|
3529 IPTVLOGSTRING2_LOW_LEVEL( "CIptvEpgDb::DeleteDatabaseL --> deleted service thumbnail : %S", &path ); |
|
3530 } |
|
3531 |