|
1 /* |
|
2 * Copyright (c) 2004-2005 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 // INCLUDE FILES |
|
22 #include <e32base.h> |
|
23 #include "IptvDebug.h" |
|
24 #include "CIptvEpgDatabase.h" |
|
25 #include "CIptvEpgLatestEpgAvailable.h" |
|
26 #include "IptvLiveLogger.h" |
|
27 #include "CIptvEpgFileSwapper.h" |
|
28 #include <bautils.h> |
|
29 #include <e32msgqueue.h> // For RMsgQueue |
|
30 |
|
31 #include "CIptvEpgLiveTvCallbackImpl.h" |
|
32 #include "CIptvEpgManagerImpl.h" |
|
33 #include "CIptvEpgChannel.h" |
|
34 #include "CIptvEpgProgram.h" |
|
35 #include "CIptvEpgProgramWithSchedule.h" |
|
36 #include "CIptvEpgSchedule.h" |
|
37 |
|
38 // CONSTANTS |
|
39 |
|
40 // ============================ MEMBER FUNCTIONS =============================== |
|
41 |
|
42 // --------------------------------------------------------- |
|
43 // CIptvEpgLiveTvCallbackImpl::ConstructL |
|
44 // Symbian 2nd phase constructor can leave. |
|
45 // --------------------------------------------------------- |
|
46 // |
|
47 void CIptvEpgLiveTvCallbackImpl::ConstructL() |
|
48 { |
|
49 IPTVLOGSTRING_LOW_LEVEL("CIptvEpgLiveTvCallbackImpl::ConstructL"); |
|
50 } |
|
51 |
|
52 // --------------------------------------------------------- |
|
53 // CIptvEpgLiveTvCallbackImpl::NewL |
|
54 // Two-phased constructor. |
|
55 // Create instance of concrete interface implementation |
|
56 // --------------------------------------------------------- |
|
57 // |
|
58 CIptvEpgLiveTvCallbackImpl* CIptvEpgLiveTvCallbackImpl::NewL( CIptvEpgDatabase& aLiveEpgDb ) |
|
59 { |
|
60 IPTVLOGSTRING_LOW_LEVEL("CIptvEpgLiveTvCallbackImpl::NewL"); |
|
61 |
|
62 CIptvEpgLiveTvCallbackImpl* self = |
|
63 new(ELeave) CIptvEpgLiveTvCallbackImpl( aLiveEpgDb ); |
|
64 CleanupStack::PushL( self ); |
|
65 |
|
66 self->ConstructL(); |
|
67 |
|
68 CleanupStack::Pop( self ); |
|
69 return self; |
|
70 } |
|
71 |
|
72 // --------------------------------------------------------- |
|
73 // CIptvEpgLiveTvCallbackImpl::~CIptvEpgLiveTvCallbackImpl |
|
74 // Destructor |
|
75 // --------------------------------------------------------- |
|
76 // |
|
77 CIptvEpgLiveTvCallbackImpl::~CIptvEpgLiveTvCallbackImpl() |
|
78 { |
|
79 IPTVLOGSTRING_LOW_LEVEL("CIptvEpgLiveTvCallbackImpl::~CIptvEpgLiveTvCallbackImpl"); |
|
80 delete iFileSwapper; |
|
81 iFileSwapper = NULL; |
|
82 } |
|
83 |
|
84 // --------------------------------------------------------- |
|
85 // CIptvEpgLiveTvCallbackImpl::CIptvEpgLiveTvCallbackImpl |
|
86 // C++ default constructor |
|
87 // --------------------------------------------------------- |
|
88 // |
|
89 CIptvEpgLiveTvCallbackImpl::CIptvEpgLiveTvCallbackImpl( CIptvEpgDatabase& aLiveEpgDb ) : |
|
90 iLiveTvEpgDb( aLiveEpgDb ), |
|
91 iPluginRunning( EFalse ) |
|
92 { |
|
93 IPTVLOGSTRING_LOW_LEVEL("CIptvEpgLiveTvCallbackImpl::CIptvEpgLiveTvCallbackImpl"); |
|
94 } |
|
95 |
|
96 // --------------------------------------------------------- |
|
97 // CIptvEpgLiveTvCallbackImpl::SetServiceId |
|
98 // Setter for currently active service |
|
99 // --------------------------------------------------------- |
|
100 // |
|
101 void CIptvEpgLiveTvCallbackImpl::SetServiceId( TUint32 aServiceId ) |
|
102 { |
|
103 iServiceId = aServiceId; |
|
104 } |
|
105 |
|
106 // --------------------------------------------------------- |
|
107 // CIptvEpgLiveTvCallbackImpl::Started |
|
108 // Callback to signalize plugin has been started. |
|
109 // --------------------------------------------------------- |
|
110 // |
|
111 void CIptvEpgLiveTvCallbackImpl::Started() |
|
112 { |
|
113 LIVE_TV_TRACE1( _L("************************") ); |
|
114 LIVE_TV_TRACE1( _L("") ); |
|
115 LIVE_TV_TRACE1( _L("Live TV plugin started") ); |
|
116 LIVE_TV_TRACE1( _L("") ); |
|
117 LIVE_TV_TRACE1( _L("************************") ); |
|
118 iPluginRunning = ETrue; |
|
119 } |
|
120 |
|
121 // --------------------------------------------------------- |
|
122 // CIptvEpgLiveTvCallbackImpl::Finished |
|
123 // Callback to signalize plugin has been finished |
|
124 // --------------------------------------------------------- |
|
125 // |
|
126 void CIptvEpgLiveTvCallbackImpl::Finished( TInt aError ) |
|
127 { |
|
128 LIVE_TV_TRACE1( _L("************************") ); |
|
129 LIVE_TV_TRACE1( _L("") ); |
|
130 LIVE_TV_TRACE1( _L("Live TV plugin finished") ); |
|
131 LIVE_TV_TRACE1( _L("") ); |
|
132 LIVE_TV_TRACE1( _L("************************") ); |
|
133 iPluginRunning = EFalse; |
|
134 TInt error = KErrNone; |
|
135 if ( aError == KErrNone ) |
|
136 { |
|
137 TRAP( error, UpdateChannelOrdersL() ); |
|
138 if ( error != KErrNone ) |
|
139 { |
|
140 LIVE_TV_TRACE2(_L("CIptvEpgLiveTvCallbackImpl::Finished: UpdateChannelOrdersL FAILED: %d"), error); |
|
141 SendMessageToUI( EEPGUpdateCompleted, error ); |
|
142 TRAP( error, HandleFailedEpgUpdateL() ); |
|
143 if ( error != KErrNone ) |
|
144 { |
|
145 LIVE_TV_TRACE2(_L("CIptvEpgLiveTvCallbackImpl::Finished: HandleFailedEpgUpdateL FAILED: %d"), error); |
|
146 } |
|
147 } |
|
148 else |
|
149 { |
|
150 // Start doing file swap... |
|
151 TRAP( error, StartFileSwappingL() ); |
|
152 if ( error != KErrNone ) |
|
153 { |
|
154 LIVE_TV_TRACE2( _L("StartFileSwapping returned %d"), error ); |
|
155 SendMessageToUI( EEPGUpdateCompleted, error ); |
|
156 TRAP( error, HandleFailedEpgUpdateL() ); |
|
157 if ( error != KErrNone ) |
|
158 { |
|
159 LIVE_TV_TRACE2(_L("CIptvEpgLiveTvCallbackImpl::Finished: HandleFailedEpgUpdateL FAILED: %d"), error); |
|
160 } |
|
161 } |
|
162 } |
|
163 |
|
164 } |
|
165 else // Something wrong with epg update -> destroy all the work done |
|
166 { |
|
167 TRAP( error, HandleFailedEpgUpdateL() ); |
|
168 if ( error != KErrNone ) |
|
169 { |
|
170 LIVE_TV_TRACE2( _L("HandleFailedEpgUpdateL caused leave with error %d"), error ); |
|
171 } |
|
172 // Send note to UI about epg update failure |
|
173 SendMessageToUI( EEPGUpdateCompleted, aError ); |
|
174 } |
|
175 } |
|
176 |
|
177 // --------------------------------------------------------- |
|
178 // CIptvEpgLiveTvCallbackImpl::HandleFailedEpgUpdateL |
|
179 // |
|
180 // --------------------------------------------------------- |
|
181 // |
|
182 void CIptvEpgLiveTvCallbackImpl::HandleFailedEpgUpdateL() |
|
183 { |
|
184 delete iFileSwapper; |
|
185 iFileSwapper = NULL; |
|
186 RFs fs; |
|
187 User::LeaveIfError( fs.Connect() ); |
|
188 CleanupClosePushL( fs ); |
|
189 // First of all try to delete all content from |
|
190 // \videocenter\tmp\live\<serviceId> |
|
191 TFileName tmpFolder; |
|
192 CIptvUtil::GetPathL( fs, EIptvPathTmpLive, iServiceId, tmpFolder, EFalse ); |
|
193 TInt error = KErrNone; |
|
194 error = BaflUtils::DeleteFile( fs, tmpFolder, CFileMan::ERecurse ); |
|
195 if ( error != KErrNone ) |
|
196 { |
|
197 LIVE_TV_TRACE2( _L("BaflUtils::DeleteFile returned %d"), error ); |
|
198 } |
|
199 |
|
200 CleanupStack::PopAndDestroy( &fs ); |
|
201 } |
|
202 |
|
203 // --------------------------------------------------------- |
|
204 // CIptvEpgLiveTvCallbackImpl::AddChannel |
|
205 // From MIptvEpgLiveTvCallback interface |
|
206 // --------------------------------------------------------- |
|
207 // |
|
208 void CIptvEpgLiveTvCallbackImpl::AddChannel( CIptvEpgChannel* aChannel ) |
|
209 { |
|
210 if ( aChannel ) |
|
211 { |
|
212 aChannel->SetServiceId( iServiceId ); |
|
213 TUint32 temp; |
|
214 TRAP_IGNORE( iLiveTvEpgDb.InsertOrUpdateChannelL( *aChannel, temp ) ); |
|
215 } |
|
216 } |
|
217 |
|
218 // --------------------------------------------------------- |
|
219 // CIptvEpgLiveTvCallbackImpl::AddProgram |
|
220 // From MIptvEpgLiveTvCallback interface |
|
221 // --------------------------------------------------------- |
|
222 // |
|
223 void CIptvEpgLiveTvCallbackImpl::AddProgram( CIptvEpgProgram* aProgram ) |
|
224 { |
|
225 if ( aProgram ) |
|
226 { |
|
227 aProgram->SetServiceId( iServiceId ); |
|
228 TUint32 temp; |
|
229 TRAP_IGNORE( iLiveTvEpgDb.InsertOrUpdateProgramL( *aProgram, temp ) ); |
|
230 } |
|
231 } |
|
232 |
|
233 // --------------------------------------------------------- |
|
234 // CIptvEpgLiveTvCallbackImpl::AddProgramsWithSchedulesL |
|
235 // From MIptvEpgLiveTvCallback interface |
|
236 // --------------------------------------------------------- |
|
237 // |
|
238 void CIptvEpgLiveTvCallbackImpl::AddProgramsWithSchedules( |
|
239 const RPointerArray<CIptvEpgProgramWithSchedule>& aProgramsWithSchedules ) |
|
240 { |
|
241 LIVE_TV_TRACE1( _L("CIptvEpgLiveTvCallbackImpl::AddProgramsWithSchedules IN") ); |
|
242 TInt error = KErrNone; |
|
243 TRAP( error, iLiveTvEpgDb.AddProgramsWithSchedulesL ( aProgramsWithSchedules ) ); |
|
244 if ( error != KErrNone ) |
|
245 { |
|
246 LIVE_TV_TRACE2( _L("iLiveTvEpgDb->AddProgramsWithSchedulesL caused leave with error %d"), error ); |
|
247 } |
|
248 LIVE_TV_TRACE1( _L("CIptvEpgLiveTvCallbackImpl::AddProgramsWithSchedules OUT") ); |
|
249 } |
|
250 |
|
251 // --------------------------------------------------------- |
|
252 // CIptvEpgLiveTvCallbackImpl::AddProgramWithScheduleL |
|
253 // From MIptvEpgLiveTvCallback interface |
|
254 // --------------------------------------------------------- |
|
255 // |
|
256 void CIptvEpgLiveTvCallbackImpl::AddProgramWithSchedule( |
|
257 CIptvEpgProgramWithSchedule& aProgramWithSchedule ) |
|
258 { |
|
259 LIVE_TV_TRACE1( _L("CIptvEpgLiveTvCallbackImpl::AddProgramWithSchedule IN") ); |
|
260 TUint32 temp; |
|
261 TInt error = KErrNone; |
|
262 TRAP( error, iLiveTvEpgDb.AddProgramWithScheduleL( aProgramWithSchedule, temp ) ); |
|
263 if ( error != KErrNone ) |
|
264 { |
|
265 LIVE_TV_TRACE2( _L("iLiveTvEpgDb->AddProgramWithScheduleL caused leave with error code %d"), error ); |
|
266 } |
|
267 LIVE_TV_TRACE1( _L("CIptvEpgLiveTvCallbackImpl::AddProgramWithSchedule IN") ); |
|
268 } |
|
269 |
|
270 |
|
271 // --------------------------------------------------------- |
|
272 // CIptvEpgLiveTvCallbackImpl::AddScheduleData |
|
273 // From MIptvEpgLiveTvCallback interface |
|
274 // --------------------------------------------------------- |
|
275 // |
|
276 void CIptvEpgLiveTvCallbackImpl::AddScheduleData( CIptvEpgSchedule& aScheduleData ) |
|
277 { |
|
278 aScheduleData.iServiceId = iServiceId; |
|
279 // This function is used when there is actual Smart Vision epg available |
|
280 TRAP_IGNORE( iLiveTvEpgDb.InsertOrUpdateScheduleL( aScheduleData ) ); |
|
281 } |
|
282 |
|
283 void CIptvEpgLiveTvCallbackImpl::EpgDownloadStarted() |
|
284 { |
|
285 // Send notify here |
|
286 } |
|
287 |
|
288 // --------------------------------------------------------- |
|
289 // CIptvEpgLiveTvCallbackImpl::EpgDownloadCompleted |
|
290 // From MIptvEpgLiveTvCallback interface |
|
291 // --------------------------------------------------------- |
|
292 // |
|
293 void CIptvEpgLiveTvCallbackImpl::EpgDownloadCompleted( TInt /*aErrorCode*/ ) |
|
294 { |
|
295 } |
|
296 |
|
297 // --------------------------------------------------------- |
|
298 // CIptvEpgLiveTvCallbackImpl::EpgParsingStarted |
|
299 // From MIptvEpgLiveTvCallback interface |
|
300 // --------------------------------------------------------- |
|
301 // |
|
302 void CIptvEpgLiveTvCallbackImpl::EpgParsingStarted() |
|
303 { |
|
304 } |
|
305 |
|
306 // --------------------------------------------------------- |
|
307 // CIptvEpgLiveTvCallbackImpl::EpgParsingFinished |
|
308 // From MIptvEpgLiveTvCallback interface |
|
309 // --------------------------------------------------------- |
|
310 // |
|
311 void CIptvEpgLiveTvCallbackImpl::EpgParsingFinished( TInt /*aErrorCode*/ ) |
|
312 { |
|
313 } |
|
314 |
|
315 // --------------------------------------------------------- |
|
316 // CIptvEpgLiveTvCallbackImpl::StartFileSwappingL |
|
317 // From MIptvEpgLiveTvCallback interface |
|
318 // --------------------------------------------------------- |
|
319 // |
|
320 void CIptvEpgLiveTvCallbackImpl::StartFileSwappingL() |
|
321 { |
|
322 iUpdateDatabase.Zero(); |
|
323 iDatabaseInUse.Zero(); |
|
324 RFs fs; |
|
325 User::LeaveIfError( fs.Connect() ); |
|
326 CleanupClosePushL( fs ); |
|
327 CIptvUtil::GetPathL( fs, EIptvPathTmpLive, iServiceId, iUpdateDatabase, EFalse ); |
|
328 if ( BaflUtils::PathExists( fs, iUpdateDatabase ) ) |
|
329 { |
|
330 iUpdateDatabase.Append( KLiveTvEPGDatabaseName ); |
|
331 } |
|
332 |
|
333 CIptvUtil::GetPathL( fs, EIptvPathEcgLive, iServiceId, iDatabaseInUse, EFalse ); |
|
334 if ( BaflUtils::PathExists( fs, iDatabaseInUse ) ) |
|
335 { |
|
336 iDatabaseInUse.Append( KLiveTvEPGDatabaseName ); |
|
337 } |
|
338 if ( iFileSwapper ) |
|
339 { |
|
340 delete iFileSwapper; |
|
341 iFileSwapper = NULL; |
|
342 } |
|
343 iFileSwapper = CIptvEpgFileSwapper::NewL( iDatabaseInUse, iUpdateDatabase, *this ); |
|
344 iFileSwapper->SwapFilesL(); |
|
345 CleanupStack::PopAndDestroy( &fs ); // Closes the fs-session |
|
346 } |
|
347 |
|
348 // --------------------------------------------------------- |
|
349 // CIptvEpgLiveTvCallbackImpl::UpdateChannelOrdersL |
|
350 // --------------------------------------------------------- |
|
351 // |
|
352 void CIptvEpgLiveTvCallbackImpl::UpdateChannelOrdersL() |
|
353 { |
|
354 LIVE_TV_TRACE1(_L("CIptvEpgLiveTvCallbackImpl::UpdateChannelOrdersL in")); |
|
355 iUpdateDatabase.Zero(); |
|
356 iDatabaseInUse.Zero(); |
|
357 RFs fs; |
|
358 User::LeaveIfError( fs.Connect() ); |
|
359 CleanupClosePushL( fs ); |
|
360 CIptvUtil::GetPathL( fs, EIptvPathTmpLive, iServiceId, iUpdateDatabase, EFalse ); |
|
361 if ( BaflUtils::PathExists( fs, iUpdateDatabase ) ) |
|
362 { |
|
363 iUpdateDatabase.Append( KLiveTvEPGDatabaseName ); |
|
364 } |
|
365 |
|
366 CIptvUtil::GetPathL( fs, EIptvPathEcgLive, iServiceId, iDatabaseInUse, EFalse ); |
|
367 if ( BaflUtils::PathExists( fs, iDatabaseInUse ) ) |
|
368 { |
|
369 iDatabaseInUse.Append( KLiveTvEPGDatabaseName ); |
|
370 } |
|
371 // Create database objects |
|
372 CIptvEpgDatabase* oldDatabase = CIptvEpgDatabase::NewL( iDatabaseInUse ); |
|
373 CleanupStack::PushL( oldDatabase ); |
|
374 CIptvEpgDatabase* newDatabase = CIptvEpgDatabase::NewL( iUpdateDatabase ); |
|
375 CleanupStack::PushL( newDatabase ); |
|
376 |
|
377 // Get all old database channels |
|
378 RPointerArray<CIptvEpgChannel> oldChannels; |
|
379 CleanupClosePushL( oldChannels ); |
|
380 TRAPD( err, oldDatabase->GetChannelsL( iServiceId, &oldChannels ); ); |
|
381 if ( err != KErrNone ) |
|
382 { |
|
383 LIVE_TV_TRACE2(_L("oldDatabase->GetChannelsL FAILED: %d"), err); |
|
384 oldChannels.ResetAndDestroy(); |
|
385 User::Leave( err ); |
|
386 } |
|
387 // Get all new database channels |
|
388 RPointerArray<CIptvEpgChannel> newChannels; |
|
389 |
|
390 TRAP( err, newDatabase->GetChannelsL( iServiceId, &newChannels ); ); |
|
391 if ( err != KErrNone ) |
|
392 { |
|
393 LIVE_TV_TRACE2(_L("newDatabase->GetChannelsL FAILED: %d"), err); |
|
394 newChannels.ResetAndDestroy(); |
|
395 newChannels.Close(); |
|
396 oldChannels.ResetAndDestroy(); |
|
397 User::Leave( err ); |
|
398 } |
|
399 TInt i( 0 ); |
|
400 TInt j( 0 ); |
|
401 // ok, now compare the channels orders in old and new EPG database |
|
402 if ( oldChannels.Count() == newChannels.Count() ) |
|
403 { |
|
404 // Channel counts are the same, continue |
|
405 // Check that the two databases hold the same channels |
|
406 TBool matchedChannelFound( EFalse ); |
|
407 TBool channelsMatch( ETrue ); |
|
408 for ( i = 0; i < oldChannels.Count() && channelsMatch; i++ ) |
|
409 { |
|
410 matchedChannelFound = EFalse; |
|
411 for ( j = 0; j < newChannels.Count() && !matchedChannelFound; j++ ) |
|
412 { |
|
413 // compare service and channel id's |
|
414 if ( oldChannels[i]->ServiceId() == newChannels[j]->ServiceId() && |
|
415 oldChannels[i]->ChannelId() == newChannels[j]->ChannelId() && |
|
416 oldChannels[i]->ChannelOrder() > 0 ) |
|
417 { |
|
418 matchedChannelFound = ETrue; |
|
419 } |
|
420 } |
|
421 if ( !matchedChannelFound ) |
|
422 { |
|
423 channelsMatch = EFalse; |
|
424 } |
|
425 } |
|
426 if ( channelsMatch ) |
|
427 { |
|
428 // Channels are unchanged, now update the channel orders |
|
429 for ( i = 0; i < oldChannels.Count(); i++ ) |
|
430 { |
|
431 for ( j = 0; j < newChannels.Count(); j++ ) |
|
432 { |
|
433 if ( oldChannels[i]->ServiceId() == newChannels[j]->ServiceId() && |
|
434 oldChannels[i]->ChannelId() == newChannels[j]->ChannelId() ) |
|
435 { |
|
436 TRAP( err, newDatabase->UpdateChannelOrderL( |
|
437 oldChannels[i]->ServiceId(), |
|
438 oldChannels[i]->ChannelId(), |
|
439 oldChannels[i]->ChannelOrder() ); |
|
440 ); |
|
441 if ( err != KErrNone ) |
|
442 { |
|
443 LIVE_TV_TRACE2(_L("newDatbase->UpdateChannelOrderL FAILED: %d"), err); |
|
444 oldChannels.ResetAndDestroy(); |
|
445 newChannels.ResetAndDestroy(); |
|
446 newChannels.Close(); |
|
447 User::Leave( err ); |
|
448 } |
|
449 } |
|
450 } |
|
451 } |
|
452 } |
|
453 else |
|
454 { |
|
455 LIVE_TV_TRACE1(_L("CIptvEpgLiveTvCallbackImpl::UpdateChannelOrdersL: The channel id's don't match, not updating channel orders!")); |
|
456 } |
|
457 } |
|
458 else |
|
459 { |
|
460 // Channel count is different, let's quit |
|
461 LIVE_TV_TRACE3(_L("CIptvEpgLiveTvCallbackImpl::UpdateChannelOrdersL: Channel counts differ, not updating order numbers! oldChannels.Count = %d, newChannels.Count = %d"), oldChannels.Count(), newChannels.Count() ); |
|
462 } |
|
463 newChannels.ResetAndDestroy(); |
|
464 newChannels.Close(); |
|
465 oldChannels.ResetAndDestroy(); |
|
466 CleanupStack::PopAndDestroy( &oldChannels ); |
|
467 CleanupStack::PopAndDestroy( newDatabase ); |
|
468 CleanupStack::PopAndDestroy( oldDatabase ); |
|
469 CleanupStack::PopAndDestroy( &fs ); // Closes the fs-session |
|
470 LIVE_TV_TRACE1(_L("CIptvEpgLiveTvCallbackImpl::UpdateChannelOrdersL out")); |
|
471 } |
|
472 |
|
473 // --------------------------------------------------------- |
|
474 // CIptvEpgLiveTvCallbackImpl::Error |
|
475 // From MIptvEpgLiveTvCallback interface |
|
476 // --------------------------------------------------------- |
|
477 // |
|
478 void CIptvEpgLiveTvCallbackImpl::Error( TInt /*aErrorCode*/ ) |
|
479 { |
|
480 } |
|
481 |
|
482 // --------------------------------------------------------- |
|
483 // CIptvEpgLiveTvCallbackImpl::ChannelUpdated |
|
484 // From MIptvEpgLiveTvCallback interface |
|
485 // --------------------------------------------------------- |
|
486 // |
|
487 void CIptvEpgLiveTvCallbackImpl::ChannelUpdated( TInt64 /*aChannelId*/ ) |
|
488 { |
|
489 } |
|
490 |
|
491 // --------------------------------------------------------- |
|
492 // CIptvEpgLiveTvCallbackImpl::UpdateChannelIcon |
|
493 // From MIptvEpgLiveTvCallback interface |
|
494 // --------------------------------------------------------- |
|
495 // |
|
496 TInt CIptvEpgLiveTvCallbackImpl::UpdateChannelIcon( const TUint32 aServiceId, |
|
497 const TInt64 aChannelId, const TDesC& aIconPath ) |
|
498 { |
|
499 TRAPD( err, iLiveTvEpgDb.UpdateChannelIconPathL( |
|
500 aServiceId, aChannelId, aIconPath ) ); |
|
501 if ( err != KErrNone ) |
|
502 { |
|
503 LIVE_TV_TRACE2(_L("CIptvEpgLiveTvCallbackImpl::UpdateChannelIcon() UpdateChannelIconL FAILED: %d"), err); |
|
504 } |
|
505 return err; |
|
506 } |
|
507 |
|
508 // --------------------------------------------------------- |
|
509 // CIptvEpgLiveTvCallbackImpl::UpdateProgramIcon |
|
510 // From MIptvEpgLiveTvCallback interface |
|
511 // --------------------------------------------------------- |
|
512 // |
|
513 void CIptvEpgLiveTvCallbackImpl::UpdateProgramIcon( TInt64 /*aProgramId*/, TDesC& /*aIconPath*/ ) |
|
514 { |
|
515 } |
|
516 |
|
517 // --------------------------------------------------------- |
|
518 // CIptvEpgLiveTvCallbackImpl::PrintScheduleData |
|
519 // Method to print out to log given schedule data |
|
520 // --------------------------------------------------------- |
|
521 // |
|
522 void CIptvEpgLiveTvCallbackImpl::PrintScheduleData( const CIptvEpgSchedule& aSchedule ) const |
|
523 { |
|
524 LIVE_TV_TRACE1( _L("")); |
|
525 LIVE_TV_TRACE1( _L("Adding schedule:")); |
|
526 LIVE_TV_TRACE1( _L("")); |
|
527 LIVE_TV_TRACE2( _L("aSchedule.iServiceId = %u"), aSchedule.iServiceId ); |
|
528 LIVE_TV_TRACE2( _L("aSchedule.iChannelId = %Li"), aSchedule.iChannelId ); |
|
529 LIVE_TV_TRACE2( _L("aSchedule.iProgramId = %Li"), aSchedule.iProgramId ); |
|
530 TTime start( aSchedule.iStartTime ); |
|
531 TBuf<50> buf; |
|
532 _LIT( KFormat, "%D %M %Y %H %T %S" ); |
|
533 TRAP_IGNORE( start.FormatL( buf, KFormat() ) ); |
|
534 LIVE_TV_TRACE2( _L("aSchedule.iStartTime = %S"), &buf ); |
|
535 TTime end( aSchedule.iEndTime ); |
|
536 buf.Zero(); |
|
537 TRAP_IGNORE( end.FormatL( buf, KFormat() ) ); |
|
538 LIVE_TV_TRACE2( _L("aSchedule.iEndTime = %S"), &buf ); |
|
539 LIVE_TV_TRACE1( _L("")); |
|
540 LIVE_TV_TRACE1( _L("End of program data:")); |
|
541 LIVE_TV_TRACE1( _L("")); |
|
542 } |
|
543 |
|
544 // --------------------------------------------------------- |
|
545 // CIptvEpgLiveTvCallbackImpl::LatestEpgAvailable |
|
546 // From MIptvEpgLiveTvCallback interface |
|
547 // --------------------------------------------------------- |
|
548 // |
|
549 void CIptvEpgLiveTvCallbackImpl::LatestEpgAvailableL( TTime aLatestSchedule ) |
|
550 { |
|
551 CIptvEpgLatestEpgAvailable* latestEpgAvailable = CIptvEpgLatestEpgAvailable::NewL(); |
|
552 CleanupStack::PushL( latestEpgAvailable ); |
|
553 latestEpgAvailable->SetServiceId( iServiceId ); |
|
554 latestEpgAvailable->SetStartTime( aLatestSchedule ); |
|
555 iLiveTvEpgDb.InsertOrUpdateLatestEpgAvailableL( *latestEpgAvailable ); |
|
556 CleanupStack::PopAndDestroy( latestEpgAvailable ); |
|
557 } |
|
558 |
|
559 void CIptvEpgLiveTvCallbackImpl::SetLastModifiedDataL( const TUint32 aServiceId, |
|
560 const TDesC& aETag, |
|
561 const TDesC& aLastModified ) |
|
562 { |
|
563 LIVE_TV_TRACE1( _L("CIptvEpgLiveTvCallbackImpl::SetLastModifiedDataL IN" ) ); |
|
564 iLiveTvEpgDb.SetLastModifiedDataL( aServiceId, aETag, aLastModified ); |
|
565 LIVE_TV_TRACE1( _L("CIptvEpgLiveTvCallbackImpl::SetLastModifiedDataL OUT" ) ); |
|
566 } |
|
567 |
|
568 |
|
569 // --------------------------------------------------------- |
|
570 // CIptvEpgLiveTvCallbackImpl::FileSwapComplete |
|
571 // From MIptvEpgFileSwapObserver |
|
572 // --------------------------------------------------------- |
|
573 // |
|
574 void CIptvEpgLiveTvCallbackImpl::FileSwapComplete( TInt aError ) |
|
575 { |
|
576 delete iFileSwapper; |
|
577 iFileSwapper = NULL; |
|
578 // Send notification to UI about file swap complete. |
|
579 SendMessageToUI( EEPGUpdateCompleted, aError ); |
|
580 } |
|
581 |
|
582 // --------------------------------------------------------- |
|
583 // CIptvEpgLiveTvCallbackImpl::SendMessageToUI |
|
584 // From MIptvEpgFileSwapObserver |
|
585 // --------------------------------------------------------- |
|
586 // |
|
587 void CIptvEpgLiveTvCallbackImpl::SendMessageToUI( TIptvQueueMsg aMessage, TInt aError ) const |
|
588 { |
|
589 RMsgQueue<SIptvQueueEntry> queue; |
|
590 TInt err = queue.OpenGlobal( KIptvUiEPGMsgQueueName ); |
|
591 if ( err == KErrNone ) |
|
592 { |
|
593 SIptvQueueEntry entry; |
|
594 entry.iServiceId = iServiceId; |
|
595 entry.iMsg = aMessage; |
|
596 entry.iErr = aError; |
|
597 err = queue.Send( entry ); |
|
598 if ( err != KErrNone ) |
|
599 { |
|
600 LIVE_TV_TRACE2( _L("CIptvEpgLiveTvCallbackImpl::SendMessageToUI: queue.Send failed with error %d"), err ); |
|
601 } |
|
602 queue.Close(); |
|
603 } |
|
604 } |
|
605 |
|
606 // end of file |