|
1 /* |
|
2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of 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 // INCLUDES |
|
22 #include <eikdoc.h> |
|
23 #include "IptvDebug.h" |
|
24 #include "CIptvIapList.h" |
|
25 #include "CIptvUtil.h" |
|
26 #include <StringLoader.h> |
|
27 #include <AknQueryDialog.h> |
|
28 #include <IptvProvisioningApp.rsg> |
|
29 #include <aknnotewrappers.h> |
|
30 #include <apgcli.h> // RApaLsSession |
|
31 #include <bautils.h> |
|
32 |
|
33 #include "CIptvService.h" |
|
34 #include "CIptvServiceManagementClient.h" |
|
35 #include "CIptvProvisioningProcessor.h" |
|
36 #include "IptvProvisioningAppUi.h" |
|
37 #include "IptvProvisioningApp.h" |
|
38 #include "IptvProvisioningDocument.h" |
|
39 #include "iptvlocalisationliterals.h" |
|
40 #include <videoplayeractivationmessage.h> |
|
41 |
|
42 // CONSTANTS |
|
43 const TUid KUidMpxVideoPlayerApplication = { 0x200159B2 }; |
|
44 const TUid KMessageUid = { 10500 }; |
|
45 |
|
46 // ============================ MEMBER FUNCTIONS ============================== |
|
47 |
|
48 // ---------------------------------------------------------------------------- |
|
49 // CIptvProvisioningAppUi::CIptvProvisioningAppUi() |
|
50 // ---------------------------------------------------------------------------- |
|
51 // |
|
52 CIptvProvisioningAppUi::CIptvProvisioningAppUi() |
|
53 { |
|
54 // None |
|
55 } |
|
56 |
|
57 // ---------------------------------------------------------------------------- |
|
58 // CIptvProvisioningAppUi::ConstructL() |
|
59 // ---------------------------------------------------------------------------- |
|
60 |
|
61 void CIptvProvisioningAppUi::ConstructL() |
|
62 { |
|
63 // Call base classes ConstructL method. |
|
64 BaseConstructL( ENoScreenFurniture | EAknEnableMSK ); |
|
65 |
|
66 StatusPane()->MakeVisible( EFalse ); |
|
67 HideApplicationFromFSW( ETrue ); |
|
68 iEcomSession = REComSession::OpenL(); |
|
69 } |
|
70 |
|
71 // ---------------------------------------------------------------------------- |
|
72 // CIptvProvisioningAppUi::~CIptvProvisioningAppUi() |
|
73 // ---------------------------------------------------------------------------- |
|
74 // |
|
75 CIptvProvisioningAppUi::~CIptvProvisioningAppUi() |
|
76 { |
|
77 iEcomSession.Close(); |
|
78 REComSession::FinalClose(); |
|
79 } |
|
80 |
|
81 // ---------------------------------------------------------------------------- |
|
82 // CIptvProvisioningAppUi::HandleKeyEventL( ) |
|
83 // ---------------------------------------------------------------------------- |
|
84 // |
|
85 TKeyResponse CIptvProvisioningAppUi::HandleKeyEventL( |
|
86 const TKeyEvent& /*aKeyEvent*/, |
|
87 TEventCode /*aType*/ ) |
|
88 { |
|
89 // Do not consume any keyevents in here |
|
90 return EKeyWasNotConsumed; |
|
91 } |
|
92 |
|
93 // ---------------------------------------------------------------------------- |
|
94 // CIptvProvisioningAppUi::HandleCommandL( TInt aCommand) |
|
95 // ---------------------------------------------------------------------------- |
|
96 // |
|
97 void CIptvProvisioningAppUi::HandleCommandL( TInt /*aCommand*/ ) |
|
98 { |
|
99 // Since there is no menubars etc there is no need for the |
|
100 // implementation of this method |
|
101 } |
|
102 |
|
103 // ---------------------------------------------------------------------------- |
|
104 // CIptvProvisioningAppUi::ProcessCommandParametersL( TInt aCommand) |
|
105 // ---------------------------------------------------------------------------- |
|
106 // |
|
107 TBool CIptvProvisioningAppUi::ProcessCommandParametersL( |
|
108 TApaCommand /*aCommand*/, |
|
109 TFileName& /*aDocumentName*/, |
|
110 const TDesC8& /*aTail*/ ) |
|
111 { |
|
112 // Always return ETrue to make CIptvProvisioningDocument's |
|
113 // OpenFileL to be called. |
|
114 return ETrue; |
|
115 } |
|
116 |
|
117 // ---------------------------------------------------------------------------- |
|
118 // CIptvProvisioningAppUi::HandleFileL( TInt aCommand) |
|
119 // ---------------------------------------------------------------------------- |
|
120 // |
|
121 void CIptvProvisioningAppUi::HandleFileL( RFile& aFile ) |
|
122 { |
|
123 IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::HandleFileL"); |
|
124 // Create instance of the processor which takes care of |
|
125 // parsing the content of the xml file. |
|
126 CIptvProvisioningProcessor* processor = CIptvProvisioningProcessor::NewL(); |
|
127 CleanupStack::PushL( processor ); |
|
128 |
|
129 // Ask processor to handle aFile that is opened by the framework. |
|
130 CIptvServices* services = NULL; |
|
131 TInt errorCode = KErrNone; |
|
132 TRAPD( provisioningError, |
|
133 services = processor->ExternalProvisionL( aFile, errorCode ) ); |
|
134 aFile.Close(); |
|
135 |
|
136 // If leave happened, set the error status so that note will be shown. |
|
137 if ( errorCode == KErrNone && provisioningError != KErrNone ) |
|
138 { |
|
139 errorCode = provisioningError; |
|
140 } |
|
141 |
|
142 // Since processor is not needed in here any more, we can destroy |
|
143 // it now |
|
144 CleanupStack::PopAndDestroy( processor ); |
|
145 |
|
146 // If there was something wrong while parsing the provisioning data |
|
147 // just stop things immediatelly. Xml file MUST be constructed in |
|
148 // the way that processor wont get any error messages during parsing. |
|
149 if ( errorCode != KErrNone ) |
|
150 { |
|
151 if ( services ) |
|
152 { |
|
153 delete services; |
|
154 } |
|
155 |
|
156 if ( errorCode == KIptvInvalidServiceType ) |
|
157 { |
|
158 ShowInvalidServiceTypeNoteL(); |
|
159 } |
|
160 else |
|
161 { |
|
162 ShowInvalidDataNoteL(); |
|
163 } |
|
164 |
|
165 User::Exit( 0 ); |
|
166 } |
|
167 |
|
168 if ( services ) |
|
169 { |
|
170 CleanupStack::PushL( services ); |
|
171 HandleServicesAdditionL( services ); |
|
172 CleanupStack::PopAndDestroy( services ); |
|
173 } |
|
174 |
|
175 // Finally close this app since our job here is done |
|
176 User::Exit( 0 ); |
|
177 } |
|
178 |
|
179 // ---------------------------------------------------------------------------- |
|
180 // CIptvProvisioningAppUi::HandleServiceAdditionL() |
|
181 // ---------------------------------------------------------------------------- |
|
182 // |
|
183 void CIptvProvisioningAppUi::HandleServicesAdditionL( CIptvServices* aServices ) |
|
184 { |
|
185 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::HandleServicesAdditionL" ); |
|
186 |
|
187 if ( !aServices ) |
|
188 { |
|
189 IPTVLOGSTRING_LOW_LEVEL( "Leave: NULL argument aServices" ); |
|
190 User::Leave( KErrArgument ); |
|
191 } |
|
192 |
|
193 IPTVLOGSTRING2_LOW_LEVEL( "Received %d services", aServices->Count() ); |
|
194 |
|
195 TInt counter( ( aServices->Count() > KMaxNumberOfServices ) ? |
|
196 KMaxNumberOfServices : aServices->Count() ); |
|
197 CIptvService* service = NULL; |
|
198 TInt32 launchId( KErrNotFound ); |
|
199 TUint32 receivedGgroupId( 0 ); |
|
200 TUint32 lauchGroupId( 0 ); |
|
201 |
|
202 // Create instance of service management client |
|
203 CIptvServiceManagementClient* client = |
|
204 CIptvServiceManagementClient::NewL( *this ); |
|
205 CleanupStack::PushL( client ); |
|
206 |
|
207 // Array for existing group items |
|
208 RArray<TUint32> existingGroupIds; |
|
209 CleanupClosePushL( existingGroupIds ); |
|
210 FindExistingGroupedIdsL( client, existingGroupIds ); |
|
211 |
|
212 // Orginal group items order |
|
213 RArray<TUint32> groupItemsOrder; |
|
214 CleanupClosePushL( groupItemsOrder ); |
|
215 |
|
216 // Add new services |
|
217 for ( TInt i = 0; i < counter; i++ ) |
|
218 { |
|
219 service = aServices->GetServiceL( i ); |
|
220 CleanupStack::PushL( service ); |
|
221 |
|
222 // Check that plugin for service exist and user want's to install |
|
223 // service before proceeding |
|
224 if ( IsServiceValidL( *service ) ) |
|
225 { |
|
226 if ( VerifyServiceGroupL( |
|
227 client, *service, receivedGgroupId, lauchGroupId ) ) |
|
228 { |
|
229 CIptvServices* tempServices = CIptvServices::NewL(); |
|
230 CleanupStack::PushL( tempServices ); |
|
231 TInt err( client->GetServicesL( |
|
232 service->GetProviderId(), *tempServices ) ); |
|
233 |
|
234 // If get services was successful and there |
|
235 // was no service for serviceId found, we can add new |
|
236 // service to the database. |
|
237 if ( err == KErrNone ) |
|
238 { |
|
239 TBool feed( EFalse ); |
|
240 TBool noNote( service->GetGroupId() > 0 && |
|
241 service->GetType() != CIptvService::EServiceGroup ); |
|
242 TRespStatus status( EEmpty ); |
|
243 |
|
244 if ( tempServices->Count() == 0 ) |
|
245 { |
|
246 // Add new service |
|
247 if ( noNote || DoesUserWantToInstallServiceL( *service ) ) |
|
248 { |
|
249 IPTVLOGSTRING_LOW_LEVEL("Calling client->AddServiceL"); |
|
250 |
|
251 // Before adding the service to service list, check if has |
|
252 // any IAPs defined. If doesn't, add some if we are allowed. |
|
253 if ( ( service->GetIapList().Count() == 0 ) && |
|
254 !( service->GetFlags() & CIptvService::EReadOnlyIaps ) ) |
|
255 { |
|
256 CIptvIapList* iapList = CIptvIapList::NewL(); |
|
257 CleanupStack::PushL( iapList ); |
|
258 |
|
259 // Get IAP list for the new service. |
|
260 if ( GetIapListForNewServiceL( client, *iapList ) == KErrNone ) |
|
261 { |
|
262 service->SetIapListL( *iapList ); |
|
263 } |
|
264 |
|
265 CleanupStack::PopAndDestroy( iapList ); |
|
266 } |
|
267 |
|
268 // Send request to add parsed service to the database |
|
269 err = client->AddServiceL( *service, status ); |
|
270 |
|
271 // Save orginal order of services in vcfg |
|
272 if ( noNote && err == KErrNone ) |
|
273 { |
|
274 groupItemsOrder.Append( |
|
275 GetServiceIdByProviderIdL( |
|
276 client, service->GetProviderId() ) ); |
|
277 } |
|
278 |
|
279 // Only vod & vodcast & servicegroup services are not installed to main level. |
|
280 if ( service->GetType() == CIptvService::EVod || |
|
281 service->GetType() == CIptvService::EVodCast || |
|
282 service->GetType() == CIptvService::EServiceGroup ) |
|
283 { |
|
284 feed = ETrue; |
|
285 } |
|
286 |
|
287 // First new added succesfully, store the serviceId for query. |
|
288 if ( err == KErrNone && status == ESucceeded && |
|
289 launchId == KErrNotFound && feed && !noNote ) |
|
290 { |
|
291 launchId = GetServiceIdByProviderIdL( |
|
292 client, service->GetProviderId() ); |
|
293 } |
|
294 } |
|
295 else |
|
296 { |
|
297 err = KErrCancel; |
|
298 } |
|
299 } |
|
300 else if ( tempServices->Count() == 1 ) // Update |
|
301 { |
|
302 if ( noNote || OverwriteExistingServiceL( service->GetName() ) ) |
|
303 { |
|
304 IPTVLOGSTRING_LOW_LEVEL("Calling client->UpdateServiceL"); |
|
305 |
|
306 // Get the service and dig out the auto-increment service-id |
|
307 // from existing service and set it to the one to be updated |
|
308 CIptvService* existingService = tempServices->GetServiceL( 0 ); |
|
309 CleanupStack::PushL( existingService ); |
|
310 |
|
311 const TInt existingId( existingService->GetId() ); |
|
312 service->SetId( existingId ); |
|
313 const TInt existingGroup( existingGroupIds.Find( existingId ) ); |
|
314 if ( existingGroup > KErrNotFound ) |
|
315 { |
|
316 existingGroupIds.Remove( existingGroup ); |
|
317 } |
|
318 |
|
319 // Before updating service, chech if it has any IAPs defined. |
|
320 // If it doesn't, take IAPs from old service if we are allowed. |
|
321 if ( ( service->GetIapList().Count() == 0 ) && |
|
322 !( service->GetFlags() & CIptvService::EReadOnlyIaps ) ) |
|
323 { |
|
324 service->SetIapListL( existingService->GetIapList() ); |
|
325 } |
|
326 |
|
327 err = client->UpdateServiceL( *service, status ); |
|
328 |
|
329 // Save orginal order of services in vcfg |
|
330 if ( noNote && err == KErrNone ) |
|
331 { |
|
332 groupItemsOrder.Append( existingId ); |
|
333 } |
|
334 |
|
335 // Only vod & vodcast services are not installed to main level. |
|
336 if ( service->GetType() == CIptvService::EVod || |
|
337 service->GetType() == CIptvService::EVodCast || |
|
338 service->GetType() == CIptvService::EServiceGroup ) |
|
339 { |
|
340 feed = ETrue; |
|
341 } |
|
342 |
|
343 // First one updated succesfully, store the serviceId for query. |
|
344 if ( err == KErrNone && status == ESucceeded && |
|
345 launchId == KErrNotFound && feed && !noNote ) |
|
346 { |
|
347 IPTVLOGSTRING2_LOW_LEVEL("CIptvProvisioningAppUi::HandleServicesAdditionL update id:%d", existingService->GetId() ); |
|
348 launchId = existingService->GetId(); |
|
349 } |
|
350 |
|
351 CleanupStack::PopAndDestroy( existingService ); |
|
352 } |
|
353 else |
|
354 { |
|
355 err = KErrCancel; |
|
356 } |
|
357 } |
|
358 else |
|
359 { |
|
360 // What if there is two services found from db with |
|
361 // same ProvidedId. |
|
362 // Situation might be that two separate service providers |
|
363 // deliver their provisioning xml files and they have same |
|
364 // ProviderId. This situation should be rather rare case |
|
365 // because ProviderId is usually a url pointing to some |
|
366 // provider specific address. |
|
367 } |
|
368 |
|
369 // Check, everything go right. Currently there is no feedback defined |
|
370 // to be shown for the user was the operation successful or not |
|
371 if ( err == KErrNone && status == ESucceeded ) |
|
372 { |
|
373 // Everything went just fine. If in the future there is a need |
|
374 // to display note to the user about successful operation, |
|
375 // add it here |
|
376 IPTVLOGSTRING_LOW_LEVEL("Add/Update service: err = KErrNone, status = ESucceeded"); |
|
377 if ( !noNote && !feed ) |
|
378 { |
|
379 // Done note shown only if not feed type |
|
380 ShowDoneNoteL( feed ); |
|
381 } |
|
382 } |
|
383 else |
|
384 { |
|
385 // Service was not installed to the service database. If user |
|
386 // needs to be notified about the error situation, do it here. |
|
387 IPTVLOGSTRING3_LOW_LEVEL("Add/Update service: err = %d, status = %d", err, status ); |
|
388 } |
|
389 } |
|
390 |
|
391 CleanupStack::PopAndDestroy( tempServices ); |
|
392 } |
|
393 } |
|
394 |
|
395 CleanupStack::PopAndDestroy( service ); |
|
396 } |
|
397 |
|
398 // Handle grouped items |
|
399 if ( receivedGgroupId > 0 ) |
|
400 { |
|
401 // Update parsed indication of group feed |
|
402 SetGroupReceivedL( client, receivedGgroupId ); |
|
403 // Remove existing non updated group services |
|
404 DeleteExistingGroupedIdsL( client, existingGroupIds, receivedGgroupId ); |
|
405 // Verify and force order of group items |
|
406 ForceOrderOfGroupedServicesL( client, groupItemsOrder ); |
|
407 } |
|
408 |
|
409 CleanupStack::PopAndDestroy( &groupItemsOrder ); |
|
410 CleanupStack::PopAndDestroy( &existingGroupIds ); |
|
411 CleanupStack::PopAndDestroy( client ); |
|
412 |
|
413 // All db modification made. Now show query to open first added feed. |
|
414 if ( launchId > KErrNotFound ) |
|
415 { |
|
416 QueryAddedServiceOpenL( launchId, lauchGroupId ); |
|
417 } |
|
418 } |
|
419 |
|
420 // ----------------------------------------------------------------------------- |
|
421 // CIptvProvisioningAppUi::GetIapListForNewServiceL() |
|
422 // Gathers list of IAPs from other user defined services. |
|
423 // ----------------------------------------------------------------------------- |
|
424 // |
|
425 TInt CIptvProvisioningAppUi::GetIapListForNewServiceL( |
|
426 CIptvServiceManagementClient* aClient, |
|
427 CIptvIapList& aIapList ) const |
|
428 { |
|
429 if ( !aClient ) |
|
430 { |
|
431 IPTVLOGSTRING_LOW_LEVEL( "Leave: NULL argument aClient" ); |
|
432 User::Leave( KErrArgument ); |
|
433 } |
|
434 |
|
435 MIptvServiceManagementClientObserver::TRespStatus respStatus; |
|
436 CDesC8ArraySeg* services = NULL; |
|
437 |
|
438 TInt error = aClient->GetServicesL( 0, |
|
439 CIptvServiceManagementClient::EDisplayOrderAscending, |
|
440 services, |
|
441 respStatus ); |
|
442 |
|
443 if ( error == KErrNone && services ) |
|
444 { |
|
445 CleanupStack::PushL( services ); |
|
446 |
|
447 CIptvService* service = CIptvService::NewL(); |
|
448 CleanupStack::PushL( service ); |
|
449 |
|
450 // Go through all services. |
|
451 for (TInt i = 0; i < services->Count(); i++ ) |
|
452 { |
|
453 service->SetL( services->MdcaPoint(i) ); |
|
454 |
|
455 TUint32 flags = service->GetFlags(); |
|
456 |
|
457 // Only copy IAPs from user modifiable services (not provisioned). |
|
458 if ( ! (flags & CIptvService::EReadOnlyIaps) ) |
|
459 { |
|
460 // Go through all IAPs for this service. |
|
461 for ( TUint8 j = 0; j < service->iIapList->Count(); j++ ) |
|
462 { |
|
463 TIptvIap& existingIap = service->iIapList->IapL( j ); |
|
464 |
|
465 // Check that this IAP is not already on user's list. |
|
466 TBool bFound = EFalse; |
|
467 for ( TUint8 k = 0; k < aIapList.Count(); k++ ) |
|
468 { |
|
469 TIptvIap& userIap = aIapList.IapL( k ); |
|
470 |
|
471 if ( userIap.iId == existingIap.iId ) |
|
472 { |
|
473 bFound = ETrue; |
|
474 break; |
|
475 } |
|
476 } |
|
477 |
|
478 // Add IAP to user's list. |
|
479 if ( ! bFound ) |
|
480 { |
|
481 aIapList.AddIap( existingIap ); |
|
482 } |
|
483 } |
|
484 } |
|
485 } |
|
486 |
|
487 CleanupStack::PopAndDestroy( service ); |
|
488 services->Reset(); |
|
489 CleanupStack::PopAndDestroy( services ); |
|
490 |
|
491 if ( aIapList.Count() > 0 ) |
|
492 { |
|
493 return KErrNone; |
|
494 } |
|
495 } |
|
496 return KErrNotFound; |
|
497 } |
|
498 |
|
499 // --------------------------------------------------------------------------- |
|
500 // CIptvProvisioningAppUi::DoesUserWantToInstallServiceL( CIptvService& ) |
|
501 // --------------------------------------------------------------------------- |
|
502 // |
|
503 TBool CIptvProvisioningAppUi::DoesUserWantToInstallServiceL( |
|
504 CIptvService& aService ) const |
|
505 { |
|
506 IPTVLOGSTRING_LOW_LEVEL( |
|
507 "CIptvProvisioningAppUi::DoesUserWantToInstallServiceL" ); |
|
508 |
|
509 TBool install( EFalse ); |
|
510 |
|
511 // Create confirmation text combining resourse text and localised name |
|
512 // of the service. |
|
513 HBufC* confirmationText; |
|
514 HBufC* localisedServiceName( NULL ); |
|
515 if ( 0 == aService.GetName().CompareF( KQtnIptvVideoStoreList ) ) |
|
516 { |
|
517 localisedServiceName = StringLoader::LoadLC( R_IPTV_VIDEO_STORE_LIST ); |
|
518 confirmationText = StringLoader::LoadLC( |
|
519 R_IPTV_INSTALL_PROVISIONING_SERVICE, |
|
520 *localisedServiceName ); |
|
521 } |
|
522 else |
|
523 { |
|
524 confirmationText = StringLoader::LoadLC( |
|
525 R_IPTV_INSTALL_PROVISIONING_SERVICE, |
|
526 aService.GetName() ); |
|
527 } |
|
528 |
|
529 CAknQueryDialog* dialog = new( ELeave ) CAknQueryDialog( |
|
530 *confirmationText, |
|
531 CAknQueryDialog::ENoTone ); |
|
532 |
|
533 // Kick the dialog to the screen and wait for an answer. |
|
534 if ( dialog->ExecuteLD( R_IPTV_PROVISIONING_QUERY_INSTALL_SERVICE ) |
|
535 == EAknSoftkeyOk ) |
|
536 { |
|
537 install = ETrue; |
|
538 } |
|
539 |
|
540 // Destroy the text allocated by string loader |
|
541 CleanupStack::PopAndDestroy( confirmationText ); |
|
542 if ( localisedServiceName ) |
|
543 { |
|
544 CleanupStack::PopAndDestroy( localisedServiceName ); |
|
545 } |
|
546 |
|
547 return install; |
|
548 } |
|
549 |
|
550 // --------------------------------------------------------------------------- |
|
551 // CIptvProvisioningAppUi::OverwriteExistingServiceL( ) |
|
552 // --------------------------------------------------------------------------- |
|
553 // |
|
554 TBool CIptvProvisioningAppUi::OverwriteExistingServiceL( |
|
555 const TDesC& aServiceName ) const |
|
556 { |
|
557 IPTVLOGSTRING_LOW_LEVEL( |
|
558 "CIptvProvisioningAppUi::OverwriteExistingServiceL" ); |
|
559 TBool overWrite( EFalse ); |
|
560 |
|
561 // Create confirmation text combining resourse text and name of the |
|
562 // service. |
|
563 HBufC* confirmationText; |
|
564 HBufC* localisedServiceName( NULL ); |
|
565 if ( 0 == aServiceName.CompareF( KQtnIptvVideoStoreList ) ) |
|
566 { |
|
567 localisedServiceName = StringLoader::LoadLC( R_IPTV_VIDEO_STORE_LIST ); |
|
568 confirmationText = StringLoader::LoadLC( |
|
569 R_IPTV_RESET_EXISTING_SERVICE, *localisedServiceName ); |
|
570 } |
|
571 else |
|
572 { |
|
573 confirmationText = StringLoader::LoadLC( |
|
574 R_IPTV_RESET_EXISTING_SERVICE, aServiceName ); |
|
575 } |
|
576 |
|
577 CAknQueryDialog* dialog = new( ELeave ) CAknQueryDialog( |
|
578 *confirmationText, |
|
579 CAknQueryDialog::ENoTone ); |
|
580 |
|
581 // Display the dialog to the screen and wait for an answer. |
|
582 if ( dialog->ExecuteLD( |
|
583 R_IPTV_PROVISIONING_VOD_RESET_EXISTING_SERVICE ) == EAknSoftkeyOk ) |
|
584 { |
|
585 overWrite = ETrue; |
|
586 } |
|
587 |
|
588 // Destroy the text allocated by string loader. |
|
589 CleanupStack::PopAndDestroy( confirmationText ); |
|
590 if ( localisedServiceName ) |
|
591 { |
|
592 CleanupStack::PopAndDestroy( localisedServiceName ); |
|
593 } |
|
594 |
|
595 return overWrite; |
|
596 } |
|
597 |
|
598 // ---------------------------------------------------------------------------- |
|
599 // CIptvProvisioningAppUi::ShowInvalidDataNoteL |
|
600 // ---------------------------------------------------------------------------- |
|
601 // |
|
602 void CIptvProvisioningAppUi::ShowInvalidDataNoteL() const |
|
603 { |
|
604 IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::ShowInvalidDataNoteL"); |
|
605 |
|
606 HBufC* text = StringLoader::LoadLC( R_IPTV_INVALID_DATA ); |
|
607 CAknErrorNote* note = new( ELeave ) CAknErrorNote( R_AKN_ERROR_NOTE ); |
|
608 |
|
609 note->ExecuteLD(*text); |
|
610 CleanupStack::PopAndDestroy(text); |
|
611 } |
|
612 |
|
613 // ---------------------------------------------------------------------------- |
|
614 // CIptvProvisioningAppUi::ShowInvalidServiceTypeNoteL |
|
615 // ---------------------------------------------------------------------------- |
|
616 // |
|
617 void CIptvProvisioningAppUi::ShowInvalidServiceTypeNoteL() const |
|
618 { |
|
619 IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::ShowInvalidServiceTypeNoteL"); |
|
620 |
|
621 HBufC* text = StringLoader::LoadLC( R_IPTV_INVALID_SERVICE_TYPE ); |
|
622 CAknErrorNote* note = new( ELeave ) CAknErrorNote( R_AKN_ERROR_NOTE ); |
|
623 |
|
624 note->ExecuteLD( *text ); |
|
625 CleanupStack::PopAndDestroy( text ); |
|
626 } |
|
627 |
|
628 // ---------------------------------------------------------------------------- |
|
629 // CIptvProvisioningAppUi::ShowDoneNoteL |
|
630 // ---------------------------------------------------------------------------- |
|
631 // |
|
632 void CIptvProvisioningAppUi::ShowDoneNoteL( TBool aFeed ) const |
|
633 { |
|
634 IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::ShowDoneNoteL"); |
|
635 |
|
636 HBufC* text; |
|
637 if ( aFeed ) |
|
638 { |
|
639 text = StringLoader::LoadLC( R_IPTV_INSTALLED ); |
|
640 } |
|
641 else |
|
642 { |
|
643 text = StringLoader::LoadLC( R_IPTV_DONE ); |
|
644 } |
|
645 |
|
646 CAknInformationNote* note = |
|
647 new( ELeave ) CAknInformationNote( R_AKN_INFORMATION_NOTE ); |
|
648 |
|
649 note->ExecuteLD( *text ); |
|
650 CleanupStack::PopAndDestroy( text ); |
|
651 } |
|
652 |
|
653 // ---------------------------------------------------------------------------- |
|
654 // CIptvProvisioningAppUi::GetServiceIdByProviderIdL |
|
655 // ---------------------------------------------------------------------------- |
|
656 // |
|
657 TUint32 CIptvProvisioningAppUi::GetServiceIdByProviderIdL( |
|
658 CIptvServiceManagementClient* aClient, |
|
659 const TDesC& aProviderId ) |
|
660 { |
|
661 CIptvServices* services = CIptvServices::NewL(); |
|
662 CleanupStack::PushL( services ); |
|
663 User::LeaveIfError( aClient->GetServicesL( aProviderId, *services ) ); |
|
664 TUint32 serviceId( services->GetServiceRefL( 0 ).GetId() ); |
|
665 CleanupStack::PopAndDestroy( services ); |
|
666 return serviceId; |
|
667 } |
|
668 |
|
669 // ---------------------------------------------------------------------------- |
|
670 // CIptvProvisioningAppUi::QueryAddedServiceOpenL |
|
671 // ---------------------------------------------------------------------------- |
|
672 // |
|
673 void CIptvProvisioningAppUi::QueryAddedServiceOpenL( |
|
674 TUint32 aServiceId, TUint32 aGroupId ) |
|
675 { |
|
676 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::QueryAddedServiceOpenL" ); |
|
677 |
|
678 HBufC* confirmationText = StringLoader::LoadLC( |
|
679 R_IPTV_ADDED_SERVICE_OPEN ); |
|
680 |
|
681 CAknQueryDialog* dialog = new( ELeave ) CAknQueryDialog( |
|
682 *confirmationText, CAknQueryDialog::ENoTone ); |
|
683 |
|
684 // Display the dialog to the screen and wait for an answer. |
|
685 |
|
686 TInt result = dialog->ExecuteLD( R_IPTV_PROVISIONING_VOD_QUERY_ADDED_SERVICE_OPEN ); |
|
687 |
|
688 if( result == EAknSoftkeyYes || result == EAknSoftkeyOk ) |
|
689 { |
|
690 CleanupStack::PopAndDestroy( confirmationText ); |
|
691 |
|
692 // Start / send message to Main application |
|
693 |
|
694 RWsSession session; |
|
695 User::LeaveIfError( session.Connect() ); |
|
696 TApaTaskList taskList( session ); |
|
697 TApaTask task = taskList.FindApp( KUidMpxVideoPlayerApplication ); |
|
698 |
|
699 if( task.Exists() ) |
|
700 { |
|
701 // VC is open. |
|
702 task.BringToForeground(); |
|
703 |
|
704 TVideoPlayerActivationMessage params; |
|
705 params.iMsgType = TVideoPlayerActivationMessage::ELaunchServiceById; |
|
706 params.iMsgSender = TVideoPlayerActivationMessage::ENotification; |
|
707 params.iServiceId = aServiceId; |
|
708 params.iGroupId = aGroupId; |
|
709 params.iActive = 1; |
|
710 params.iSingle = ETrue; |
|
711 params.iFileId = 0; |
|
712 params.iDrive = 0; |
|
713 params.iFullPath = KNullDesC; |
|
714 |
|
715 TPckg<TVideoPlayerActivationMessage> message( params ); |
|
716 TInt error = task.SendMessage( KMessageUid, message ); |
|
717 |
|
718 IPTVLOGSTRING2_LOW_LEVEL( "CIptvVodNotificationLauncher::send message error = %d", error ); |
|
719 } |
|
720 else |
|
721 { |
|
722 // Task doesn't exist, launch a new instance of an application |
|
723 RApaLsSession lsSession; |
|
724 // connect to AppArc server |
|
725 User::LeaveIfError( lsSession.Connect() ); |
|
726 |
|
727 TApaAppInfo appInfo; |
|
728 if ( lsSession.GetAppInfo( appInfo, KUidMpxVideoPlayerApplication ) == KErrNone ) |
|
729 { |
|
730 CApaCommandLine* cmdLine = CApaCommandLine::NewLC(); |
|
731 cmdLine->SetExecutableNameL( appInfo.iFullName ); |
|
732 |
|
733 TVideoPlayerActivationMessage params; |
|
734 params.iMsgType = TVideoPlayerActivationMessage::ELaunchServiceById; |
|
735 params.iMsgSender = TVideoPlayerActivationMessage::ENotification; |
|
736 params.iServiceId = aServiceId; |
|
737 params.iGroupId = aGroupId; |
|
738 params.iActive = 1; |
|
739 params.iSingle = ETrue; |
|
740 params.iFileId = 0; |
|
741 params.iDrive = 0; |
|
742 params.iFullPath = KNullDesC; |
|
743 TPckg<TVideoPlayerActivationMessage> message( params ); |
|
744 cmdLine->SetTailEndL( message ); |
|
745 User::LeaveIfError( lsSession.StartApp( *cmdLine ) ); |
|
746 CleanupStack::PopAndDestroy( cmdLine ); |
|
747 } |
|
748 } |
|
749 } |
|
750 else |
|
751 { |
|
752 CleanupStack::PopAndDestroy( confirmationText ); |
|
753 } |
|
754 } |
|
755 |
|
756 // ---------------------------------------------------------------------------- |
|
757 // CIptvProvisioningAppUi::IsServiceValidL |
|
758 // ---------------------------------------------------------------------------- |
|
759 // |
|
760 TBool CIptvProvisioningAppUi::IsServiceValidL( CIptvService& aService ) |
|
761 { |
|
762 IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::IsServiceValidL"); |
|
763 |
|
764 TBool liveIncluded( EFalse ); |
|
765 |
|
766 TBool valid = EFalse; |
|
767 RImplInfoPtrArray vodArray; |
|
768 CleanupClosePushL( vodArray ); |
|
769 iEcomSession.ListImplementationsL( KRssPluginInterfaceUid, vodArray ); |
|
770 RImplInfoPtrArray xmlTvArray; |
|
771 CleanupClosePushL( xmlTvArray ); |
|
772 iEcomSession.ListImplementationsL( KXmlTvPluginInterfaceUid, xmlTvArray ); |
|
773 |
|
774 // Here we check: |
|
775 // 1) There is at least one implementation for the pluginuid defined in |
|
776 // service object |
|
777 // 2) Service type is either Vod OR |
|
778 // 3) Service type is Live AND live is included in the build AND there is a |
|
779 // plugin for live tv available (either smart vision plugin or xml tv plugin |
|
780 // 4) Service type is Browser, Search or Upload |
|
781 if ( ( aService.GetType() == CIptvService::EVod || |
|
782 aService.GetType() == CIptvService::EServiceGroup || |
|
783 ( aService.GetType() == CIptvService::EVodCast && |
|
784 vodArray.Count() > 0 ) ) || |
|
785 ( aService.GetType() == CIptvService::ELiveTv && |
|
786 liveIncluded && xmlTvArray.Count() > 0 ) || |
|
787 ( aService.GetType() == CIptvService::EBrowser || |
|
788 aService.GetType() == CIptvService::ESearch || |
|
789 aService.GetType() == CIptvService::EUpload ) ) |
|
790 { |
|
791 valid = ETrue; |
|
792 } |
|
793 |
|
794 CleanupStack::PopAndDestroy( &xmlTvArray ); |
|
795 CleanupStack::PopAndDestroy( &vodArray ); |
|
796 return valid; |
|
797 } |
|
798 |
|
799 // ---------------------------------------------------------------------------- |
|
800 // CIptvProvisioningAppUi::FindExistingGroupedIdsL() |
|
801 // ---------------------------------------------------------------------------- |
|
802 // |
|
803 void CIptvProvisioningAppUi::FindExistingGroupedIdsL( |
|
804 CIptvServiceManagementClient* aClient, |
|
805 RArray<TUint32>& aExistingGroupIds ) |
|
806 { |
|
807 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::FindExistingGroupedIdsL" ); |
|
808 |
|
809 // Find exisitng group feeds |
|
810 CDesC8ArraySeg* services = NULL; |
|
811 MIptvServiceManagementClientObserver::TRespStatus respStatus; |
|
812 aClient->GetServicesL( |
|
813 CIptvServiceManagementClient::EGroupedServices, |
|
814 CIptvServiceManagementClient::EDateAscending, |
|
815 services, respStatus ); |
|
816 |
|
817 // Found any |
|
818 if ( services ) |
|
819 { |
|
820 CleanupStack::PushL( services ); |
|
821 CIptvService* service = CIptvService::NewL(); |
|
822 CleanupStack::PushL( service ); |
|
823 |
|
824 // Go through all grouped services |
|
825 for ( TInt i( 0 ); i < services->Count(); i++ ) |
|
826 { |
|
827 service->SetL( services->MdcaPoint( i ) ); |
|
828 aExistingGroupIds.Append( service->GetId() ); |
|
829 } |
|
830 |
|
831 CleanupStack::PopAndDestroy( service ); |
|
832 CleanupStack::PopAndDestroy( services ); |
|
833 } |
|
834 } |
|
835 |
|
836 // ---------------------------------------------------------------------------- |
|
837 // CIptvProvisioningAppUi::DeleteExistingGroupedIdsL() |
|
838 // ---------------------------------------------------------------------------- |
|
839 // |
|
840 void CIptvProvisioningAppUi::DeleteExistingGroupedIdsL( |
|
841 CIptvServiceManagementClient* aClient, |
|
842 RArray<TUint32>& aExistingGroupIds, |
|
843 const TUint32 aReceivedGroup ) |
|
844 { |
|
845 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::DeleteExistingGroupedIdsL" ); |
|
846 |
|
847 if ( aExistingGroupIds.Count() > 0 ) |
|
848 { |
|
849 // Find exisitng group feeds |
|
850 CDesC8ArraySeg* services = NULL; |
|
851 MIptvServiceManagementClientObserver::TRespStatus respStatus; |
|
852 aClient->GetServicesL( |
|
853 CIptvServiceManagementClient::EGroupedServices, |
|
854 CIptvServiceManagementClient::EDateAscending, |
|
855 services, respStatus ); |
|
856 |
|
857 // Found any |
|
858 if ( services ) |
|
859 { |
|
860 CleanupStack::PushL( services ); |
|
861 CIptvService* service = CIptvService::NewL(); |
|
862 CleanupStack::PushL( service ); |
|
863 // File server for icons deleting |
|
864 RFs fs; |
|
865 CleanupClosePushL( fs ); |
|
866 User::LeaveIfError( fs.Connect() ); |
|
867 |
|
868 // Go through all services |
|
869 for ( TInt i( 0 ); i < services->Count(); i++ ) |
|
870 { |
|
871 service->SetL( services->MdcaPoint( i ) ); |
|
872 if ( service->GetGroupId() == aReceivedGroup ) |
|
873 { |
|
874 const TInt index( |
|
875 aExistingGroupIds.Find( service->GetId() ) ); |
|
876 if ( index > KErrNotFound ) |
|
877 { |
|
878 // Delete icon file if downloaded and exist |
|
879 if ( service->GetIconPath() != KIptvEmptyDes ) |
|
880 { |
|
881 if ( BaflUtils::FileExists( fs, service->GetIconPath() ) ) |
|
882 { |
|
883 fs.Delete( service->GetIconPath() ); |
|
884 } |
|
885 } |
|
886 |
|
887 // Selete service |
|
888 aClient->DeleteServiceL( aExistingGroupIds[index], respStatus ); |
|
889 if ( respStatus != MIptvServiceManagementClientObserver::ESucceeded ) |
|
890 { |
|
891 IPTVLOGSTRING_LOW_LEVEL( "Error during deleting existing grouped service !" ); |
|
892 User::Leave( KErrGeneral ); |
|
893 } |
|
894 } |
|
895 } |
|
896 } |
|
897 |
|
898 // Verify grouped services items order |
|
899 CleanupStack::PopAndDestroy( &fs ); |
|
900 CleanupStack::PopAndDestroy( service ); |
|
901 CleanupStack::PopAndDestroy( services ); |
|
902 } |
|
903 } |
|
904 } |
|
905 |
|
906 // ---------------------------------------------------------------------------- |
|
907 // CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL() |
|
908 // ---------------------------------------------------------------------------- |
|
909 // |
|
910 void CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL( |
|
911 CIptvServiceManagementClient* aClient, |
|
912 RArray<TUint32>& aGroupItemsOrder ) |
|
913 { |
|
914 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL" ); |
|
915 |
|
916 // Find exisitng group feeds |
|
917 CDesC8ArraySeg* services = NULL; |
|
918 MIptvServiceManagementClientObserver::TRespStatus respStatus; |
|
919 aClient->GetServicesL( |
|
920 CIptvServiceManagementClient::EGroupedServices, |
|
921 CIptvServiceManagementClient::EDisplayOrderAscending, |
|
922 services, respStatus ); |
|
923 |
|
924 // Found any |
|
925 if ( services ) |
|
926 { |
|
927 CleanupStack::PushL( services ); |
|
928 |
|
929 for ( TInt i( 0 ); i < aGroupItemsOrder.Count(); i++ ) |
|
930 { |
|
931 const TUint expectedId( aGroupItemsOrder[i] ); |
|
932 CIptvService* service = CIptvService::NewL(); |
|
933 CleanupStack::PushL( service ); |
|
934 service->SetL( services->MdcaPoint( i ) ); |
|
935 |
|
936 // Verify order |
|
937 TBool needUpdate( EFalse ); |
|
938 if ( service->GetId() != expectedId ) |
|
939 { |
|
940 // Find missplaced service |
|
941 for ( TInt j( 0 ); j < services->Count(); j++ ) |
|
942 { |
|
943 CIptvService* second = CIptvService::NewL(); |
|
944 CleanupStack::PushL( second ); |
|
945 second->SetL( services->MdcaPoint( j ) ); |
|
946 if ( second->GetId() == expectedId ) |
|
947 { |
|
948 // Swap those two service display order |
|
949 TRespStatus status( EEmpty ); |
|
950 second->SetDisplayOrder( service->GetDisplayOrder() ); |
|
951 TInt err( aClient->UpdateServiceL( *second, status ) ); |
|
952 |
|
953 // Verify status |
|
954 if ( err != KErrNone || status != ESucceeded ) |
|
955 { |
|
956 IPTVLOGSTRING3_LOW_LEVEL( |
|
957 "CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL(), err: %d, status: %d", |
|
958 err, status ); |
|
959 User::Leave( KErrCompletion ); |
|
960 } |
|
961 |
|
962 // Swap done |
|
963 needUpdate = ETrue; |
|
964 j = services->Count(); |
|
965 } |
|
966 |
|
967 CleanupStack::PopAndDestroy( second ); |
|
968 } |
|
969 } |
|
970 |
|
971 CleanupStack::PopAndDestroy( service ); |
|
972 |
|
973 // Local services list need to be updated when display order swapped |
|
974 if ( needUpdate ) |
|
975 { |
|
976 CleanupStack::Pop( services ); |
|
977 delete services; services = NULL; |
|
978 aClient->GetServicesL( |
|
979 CIptvServiceManagementClient::EGroupedServices, |
|
980 CIptvServiceManagementClient::EDisplayOrderAscending, |
|
981 services, respStatus ); |
|
982 CleanupStack::PushL( services ); |
|
983 } |
|
984 } |
|
985 |
|
986 CleanupStack::PopAndDestroy( services ); |
|
987 } |
|
988 } |
|
989 |
|
990 // ---------------------------------------------------------------------------- |
|
991 // CIptvProvisioningAppUi::VerifyServiceGroupL() |
|
992 // ---------------------------------------------------------------------------- |
|
993 // |
|
994 TBool CIptvProvisioningAppUi::VerifyServiceGroupL( |
|
995 CIptvServiceManagementClient* aClient, |
|
996 CIptvService& aService, |
|
997 TUint32& aGroupId, |
|
998 TUint32& aLaunchId ) |
|
999 { |
|
1000 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::VerifyServiceGroupL" ); |
|
1001 |
|
1002 const TUint32 groupId( aService.GetGroupId() ); |
|
1003 if ( groupId == 0 || |
|
1004 ( groupId > 0 && aService.GetType() == CIptvService::EServiceGroup ) ) |
|
1005 { |
|
1006 // Group id for service lauch |
|
1007 if ( groupId > 0 && aLaunchId == 0 ) |
|
1008 { |
|
1009 aLaunchId = groupId; |
|
1010 } |
|
1011 |
|
1012 return ETrue; // Not grouped feed |
|
1013 } |
|
1014 |
|
1015 // Find group feeds |
|
1016 CDesC8ArraySeg* services = NULL; |
|
1017 MIptvServiceManagementClientObserver::TRespStatus respStatus; |
|
1018 aClient->GetServicesL( |
|
1019 CIptvServiceManagementClient::EServiceGroup, |
|
1020 CIptvServiceManagementClient::EDateAscending, |
|
1021 services, respStatus ); |
|
1022 |
|
1023 // Found any |
|
1024 TBool found( EFalse ); |
|
1025 if ( services ) |
|
1026 { |
|
1027 CleanupStack::PushL( services ); |
|
1028 CIptvService* service = CIptvService::NewL(); |
|
1029 CleanupStack::PushL( service ); |
|
1030 |
|
1031 // Go through all services |
|
1032 for ( TInt i( 0 ); !found && i < services->Count(); i++ ) |
|
1033 { |
|
1034 service->SetL( services->MdcaPoint( i ) ); |
|
1035 if ( service->GetGroupId() == groupId ) |
|
1036 { |
|
1037 found = ETrue; // ok to install |
|
1038 aGroupId = groupId; |
|
1039 } |
|
1040 } |
|
1041 |
|
1042 CleanupStack::PopAndDestroy( service ); |
|
1043 CleanupStack::PopAndDestroy( services ); |
|
1044 } |
|
1045 |
|
1046 return found; |
|
1047 } |
|
1048 |
|
1049 // ---------------------------------------------------------------------------- |
|
1050 // CIptvProvisioningAppUi::SetGroupReceivedL() |
|
1051 // ---------------------------------------------------------------------------- |
|
1052 // |
|
1053 void CIptvProvisioningAppUi::SetGroupReceivedL( |
|
1054 CIptvServiceManagementClient* aClient, |
|
1055 const TUint32& aGroupId ) |
|
1056 { |
|
1057 IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::SetGroupReceivedL" ); |
|
1058 |
|
1059 // Find group feeds |
|
1060 CDesC8ArraySeg* services = NULL; |
|
1061 MIptvServiceManagementClientObserver::TRespStatus respStatus; |
|
1062 aClient->GetServicesL( |
|
1063 CIptvServiceManagementClient::EServiceGroup, |
|
1064 CIptvServiceManagementClient::EDateAscending, |
|
1065 services, respStatus ); |
|
1066 |
|
1067 // Find and update flag |
|
1068 if ( services ) |
|
1069 { |
|
1070 CleanupStack::PushL( services ); |
|
1071 CIptvService* service = CIptvService::NewL(); |
|
1072 CleanupStack::PushL( service ); |
|
1073 |
|
1074 // Go through all services |
|
1075 for ( TInt i( 0 ); i < services->Count(); i++ ) |
|
1076 { |
|
1077 service->SetL( services->MdcaPoint( i ) ); |
|
1078 if ( service->GetGroupId() == aGroupId ) |
|
1079 { |
|
1080 service->SetFlags( |
|
1081 service->GetFlags() | CIptvService::EGroupReceived ); |
|
1082 TRespStatus status( EEmpty ); |
|
1083 User::LeaveIfError( |
|
1084 aClient->UpdateServiceL( *service, status ) ); |
|
1085 i = services->Count(); |
|
1086 } |
|
1087 } |
|
1088 |
|
1089 CleanupStack::PopAndDestroy( service ); |
|
1090 CleanupStack::PopAndDestroy( services ); |
|
1091 } |
|
1092 } |
|
1093 |
|
1094 // Methods implemented to fullfill inheritance of |
|
1095 // MIptvServiceManagementClientObserver. Implementation of the inherited |
|
1096 // methods is empty since we do not use asynchorous versions of the methods |
|
1097 // but nevertheless CIptvServiceManagementClient requires the observer to |
|
1098 // be given for the NewL |
|
1099 |
|
1100 // ---------------------------------------------------------------------------- |
|
1101 // CIptvProvisioningAppUi::AddServiceResp( TRespStatus ) |
|
1102 // ---------------------------------------------------------------------------- |
|
1103 // |
|
1104 void CIptvProvisioningAppUi::AddServiceResp( |
|
1105 TRespStatus /*aRespStatus*/) |
|
1106 { |
|
1107 } |
|
1108 |
|
1109 // ---------------------------------------------------------------------------- |
|
1110 // CIptvProvisioningAppUi::UpdateServiceResp( TRespStatus ) |
|
1111 // ---------------------------------------------------------------------------- |
|
1112 // |
|
1113 void CIptvProvisioningAppUi::UpdateServiceResp( |
|
1114 TRespStatus /*aRespStatus*/) |
|
1115 { |
|
1116 } |
|
1117 |
|
1118 |
|
1119 // ---------------------------------------------------------------------------- |
|
1120 // CIptvProvisioningAppUi::DeleteServiceResp( TRespStatus ) |
|
1121 // ---------------------------------------------------------------------------- |
|
1122 // |
|
1123 void CIptvProvisioningAppUi::DeleteServiceResp( |
|
1124 TRespStatus /*aRespStatus*/ ) |
|
1125 { |
|
1126 } |
|
1127 |
|
1128 // ---------------------------------------------------------------------------- |
|
1129 // CIptvProvisioningAppUi::GetServicesResp( TRespStatus, CDesC8ArraySeg* ) |
|
1130 // ---------------------------------------------------------------------------- |
|
1131 // |
|
1132 void CIptvProvisioningAppUi::GetServicesResp( |
|
1133 TRespStatus /*aRespStatus*/, |
|
1134 CDesC8ArraySeg* /*aServicesArray*/ ) |
|
1135 { |
|
1136 } |
|
1137 |
|
1138 // ---------------------------------------------------------------------------- |
|
1139 // CIptvProvisioningAppUi::GetUsedIapResp( TUInt, |
|
1140 // const TDesC&, |
|
1141 // TConnectionPermission, |
|
1142 // TRespStatus ) |
|
1143 // ---------------------------------------------------------------------------- |
|
1144 // |
|
1145 void CIptvProvisioningAppUi::GetUsedIapResp( |
|
1146 TUint32 /*aIapId*/, |
|
1147 const TDesC& /*aIapName*/, |
|
1148 CIptvNetworkSelection::TConnectionPermission /*aConnectionPermission*/, |
|
1149 TBool /*aWlanWhenGPRS*/, |
|
1150 CIptvNetworkSelection::TRespStatus /*aRespStatus*/ ) |
|
1151 { |
|
1152 } |
|
1153 |
|
1154 // ---------------------------------------------------------------------------- |
|
1155 // CIptvProvisioningAppUi::ServerShutdownResp( TRespStatus ) |
|
1156 // ---------------------------------------------------------------------------- |
|
1157 // |
|
1158 void CIptvProvisioningAppUi::ServerShutdownResp( |
|
1159 TRespStatus /*aRespStatus*/ ) |
|
1160 { |
|
1161 } |