diff -r 000000000000 -r 96612d01cf9f videofeeds/provisioningappui/Src/IptvProvisioningAppUi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videofeeds/provisioningappui/Src/IptvProvisioningAppUi.cpp Mon Jan 18 20:21:12 2010 +0200 @@ -0,0 +1,1161 @@ +/* +* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + + + +// INCLUDES +#include +#include "IptvDebug.h" +#include "CIptvIapList.h" +#include "CIptvUtil.h" +#include +#include +#include +#include +#include // RApaLsSession +#include + +#include "CIptvService.h" +#include "CIptvServiceManagementClient.h" +#include "CIptvProvisioningProcessor.h" +#include "IptvProvisioningAppUi.h" +#include "IptvProvisioningApp.h" +#include "IptvProvisioningDocument.h" +#include "iptvlocalisationliterals.h" +#include + +// CONSTANTS +const TUid KUidMpxVideoPlayerApplication = { 0x200159B2 }; +const TUid KMessageUid = { 10500 }; + +// ============================ MEMBER FUNCTIONS ============================== + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::CIptvProvisioningAppUi() +// ---------------------------------------------------------------------------- +// +CIptvProvisioningAppUi::CIptvProvisioningAppUi() + { + // None + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ConstructL() +// ---------------------------------------------------------------------------- + +void CIptvProvisioningAppUi::ConstructL() + { + // Call base classes ConstructL method. + BaseConstructL( ENoScreenFurniture | EAknEnableMSK ); + + StatusPane()->MakeVisible( EFalse ); + HideApplicationFromFSW( ETrue ); + iEcomSession = REComSession::OpenL(); + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::~CIptvProvisioningAppUi() +// ---------------------------------------------------------------------------- +// +CIptvProvisioningAppUi::~CIptvProvisioningAppUi() + { + iEcomSession.Close(); + REComSession::FinalClose(); + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::HandleKeyEventL( ) +// ---------------------------------------------------------------------------- +// +TKeyResponse CIptvProvisioningAppUi::HandleKeyEventL( + const TKeyEvent& /*aKeyEvent*/, + TEventCode /*aType*/ ) + { + // Do not consume any keyevents in here + return EKeyWasNotConsumed; + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::HandleCommandL( TInt aCommand) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::HandleCommandL( TInt /*aCommand*/ ) + { + // Since there is no menubars etc there is no need for the + // implementation of this method + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ProcessCommandParametersL( TInt aCommand) +// ---------------------------------------------------------------------------- +// +TBool CIptvProvisioningAppUi::ProcessCommandParametersL( + TApaCommand /*aCommand*/, + TFileName& /*aDocumentName*/, + const TDesC8& /*aTail*/ ) + { + // Always return ETrue to make CIptvProvisioningDocument's + // OpenFileL to be called. + return ETrue; + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::HandleFileL( TInt aCommand) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::HandleFileL( RFile& aFile ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::HandleFileL"); + // Create instance of the processor which takes care of + // parsing the content of the xml file. + CIptvProvisioningProcessor* processor = CIptvProvisioningProcessor::NewL(); + CleanupStack::PushL( processor ); + + // Ask processor to handle aFile that is opened by the framework. + CIptvServices* services = NULL; + TInt errorCode = KErrNone; + TRAPD( provisioningError, + services = processor->ExternalProvisionL( aFile, errorCode ) ); + aFile.Close(); + + // If leave happened, set the error status so that note will be shown. + if ( errorCode == KErrNone && provisioningError != KErrNone ) + { + errorCode = provisioningError; + } + + // Since processor is not needed in here any more, we can destroy + // it now + CleanupStack::PopAndDestroy( processor ); + + // If there was something wrong while parsing the provisioning data + // just stop things immediatelly. Xml file MUST be constructed in + // the way that processor wont get any error messages during parsing. + if ( errorCode != KErrNone ) + { + if ( services ) + { + delete services; + } + + if ( errorCode == KIptvInvalidServiceType ) + { + ShowInvalidServiceTypeNoteL(); + } + else + { + ShowInvalidDataNoteL(); + } + + User::Exit( 0 ); + } + + if ( services ) + { + CleanupStack::PushL( services ); + HandleServicesAdditionL( services ); + CleanupStack::PopAndDestroy( services ); + } + + // Finally close this app since our job here is done + User::Exit( 0 ); + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::HandleServiceAdditionL() +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::HandleServicesAdditionL( CIptvServices* aServices ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::HandleServicesAdditionL" ); + + if ( !aServices ) + { + IPTVLOGSTRING_LOW_LEVEL( "Leave: NULL argument aServices" ); + User::Leave( KErrArgument ); + } + + IPTVLOGSTRING2_LOW_LEVEL( "Received %d services", aServices->Count() ); + + TInt counter( ( aServices->Count() > KMaxNumberOfServices ) ? + KMaxNumberOfServices : aServices->Count() ); + CIptvService* service = NULL; + TInt32 launchId( KErrNotFound ); + TUint32 receivedGgroupId( 0 ); + TUint32 lauchGroupId( 0 ); + + // Create instance of service management client + CIptvServiceManagementClient* client = + CIptvServiceManagementClient::NewL( *this ); + CleanupStack::PushL( client ); + + // Array for existing group items + RArray existingGroupIds; + CleanupClosePushL( existingGroupIds ); + FindExistingGroupedIdsL( client, existingGroupIds ); + + // Orginal group items order + RArray groupItemsOrder; + CleanupClosePushL( groupItemsOrder ); + + // Add new services + for ( TInt i = 0; i < counter; i++ ) + { + service = aServices->GetServiceL( i ); + CleanupStack::PushL( service ); + + // Check that plugin for service exist and user want's to install + // service before proceeding + if ( IsServiceValidL( *service ) ) + { + if ( VerifyServiceGroupL( + client, *service, receivedGgroupId, lauchGroupId ) ) + { + CIptvServices* tempServices = CIptvServices::NewL(); + CleanupStack::PushL( tempServices ); + TInt err( client->GetServicesL( + service->GetProviderId(), *tempServices ) ); + + // If get services was successful and there + // was no service for serviceId found, we can add new + // service to the database. + if ( err == KErrNone ) + { + TBool feed( EFalse ); + TBool noNote( service->GetGroupId() > 0 && + service->GetType() != CIptvService::EServiceGroup ); + TRespStatus status( EEmpty ); + + if ( tempServices->Count() == 0 ) + { + // Add new service + if ( noNote || DoesUserWantToInstallServiceL( *service ) ) + { + IPTVLOGSTRING_LOW_LEVEL("Calling client->AddServiceL"); + + // Before adding the service to service list, check if has + // any IAPs defined. If doesn't, add some if we are allowed. + if ( ( service->GetIapList().Count() == 0 ) && + !( service->GetFlags() & CIptvService::EReadOnlyIaps ) ) + { + CIptvIapList* iapList = CIptvIapList::NewL(); + CleanupStack::PushL( iapList ); + + // Get IAP list for the new service. + if ( GetIapListForNewServiceL( client, *iapList ) == KErrNone ) + { + service->SetIapListL( *iapList ); + } + + CleanupStack::PopAndDestroy( iapList ); + } + + // Send request to add parsed service to the database + err = client->AddServiceL( *service, status ); + + // Save orginal order of services in vcfg + if ( noNote && err == KErrNone ) + { + groupItemsOrder.Append( + GetServiceIdByProviderIdL( + client, service->GetProviderId() ) ); + } + + // Only vod & vodcast & servicegroup services are not installed to main level. + if ( service->GetType() == CIptvService::EVod || + service->GetType() == CIptvService::EVodCast || + service->GetType() == CIptvService::EServiceGroup ) + { + feed = ETrue; + } + + // First new added succesfully, store the serviceId for query. + if ( err == KErrNone && status == ESucceeded && + launchId == KErrNotFound && feed && !noNote ) + { + launchId = GetServiceIdByProviderIdL( + client, service->GetProviderId() ); + } + } + else + { + err = KErrCancel; + } + } + else if ( tempServices->Count() == 1 ) // Update + { + if ( noNote || OverwriteExistingServiceL( service->GetName() ) ) + { + IPTVLOGSTRING_LOW_LEVEL("Calling client->UpdateServiceL"); + + // Get the service and dig out the auto-increment service-id + // from existing service and set it to the one to be updated + CIptvService* existingService = tempServices->GetServiceL( 0 ); + CleanupStack::PushL( existingService ); + + const TInt existingId( existingService->GetId() ); + service->SetId( existingId ); + const TInt existingGroup( existingGroupIds.Find( existingId ) ); + if ( existingGroup > KErrNotFound ) + { + existingGroupIds.Remove( existingGroup ); + } + + // Before updating service, chech if it has any IAPs defined. + // If it doesn't, take IAPs from old service if we are allowed. + if ( ( service->GetIapList().Count() == 0 ) && + !( service->GetFlags() & CIptvService::EReadOnlyIaps ) ) + { + service->SetIapListL( existingService->GetIapList() ); + } + + err = client->UpdateServiceL( *service, status ); + + // Save orginal order of services in vcfg + if ( noNote && err == KErrNone ) + { + groupItemsOrder.Append( existingId ); + } + + // Only vod & vodcast services are not installed to main level. + if ( service->GetType() == CIptvService::EVod || + service->GetType() == CIptvService::EVodCast || + service->GetType() == CIptvService::EServiceGroup ) + { + feed = ETrue; + } + + // First one updated succesfully, store the serviceId for query. + if ( err == KErrNone && status == ESucceeded && + launchId == KErrNotFound && feed && !noNote ) + { + IPTVLOGSTRING2_LOW_LEVEL("CIptvProvisioningAppUi::HandleServicesAdditionL update id:%d", existingService->GetId() ); + launchId = existingService->GetId(); + } + + CleanupStack::PopAndDestroy( existingService ); + } + else + { + err = KErrCancel; + } + } + else + { + // What if there is two services found from db with + // same ProvidedId. + // Situation might be that two separate service providers + // deliver their provisioning xml files and they have same + // ProviderId. This situation should be rather rare case + // because ProviderId is usually a url pointing to some + // provider specific address. + } + + // Check, everything go right. Currently there is no feedback defined + // to be shown for the user was the operation successful or not + if ( err == KErrNone && status == ESucceeded ) + { + // Everything went just fine. If in the future there is a need + // to display note to the user about successful operation, + // add it here + IPTVLOGSTRING_LOW_LEVEL("Add/Update service: err = KErrNone, status = ESucceeded"); + if ( !noNote && !feed ) + { + // Done note shown only if not feed type + ShowDoneNoteL( feed ); + } + } + else + { + // Service was not installed to the service database. If user + // needs to be notified about the error situation, do it here. + IPTVLOGSTRING3_LOW_LEVEL("Add/Update service: err = %d, status = %d", err, status ); + } + } + + CleanupStack::PopAndDestroy( tempServices ); + } + } + + CleanupStack::PopAndDestroy( service ); + } + + // Handle grouped items + if ( receivedGgroupId > 0 ) + { + // Update parsed indication of group feed + SetGroupReceivedL( client, receivedGgroupId ); + // Remove existing non updated group services + DeleteExistingGroupedIdsL( client, existingGroupIds, receivedGgroupId ); + // Verify and force order of group items + ForceOrderOfGroupedServicesL( client, groupItemsOrder ); + } + + CleanupStack::PopAndDestroy( &groupItemsOrder ); + CleanupStack::PopAndDestroy( &existingGroupIds ); + CleanupStack::PopAndDestroy( client ); + + // All db modification made. Now show query to open first added feed. + if ( launchId > KErrNotFound ) + { + QueryAddedServiceOpenL( launchId, lauchGroupId ); + } + } + +// ----------------------------------------------------------------------------- +// CIptvProvisioningAppUi::GetIapListForNewServiceL() +// Gathers list of IAPs from other user defined services. +// ----------------------------------------------------------------------------- +// +TInt CIptvProvisioningAppUi::GetIapListForNewServiceL( + CIptvServiceManagementClient* aClient, + CIptvIapList& aIapList ) const + { + if ( !aClient ) + { + IPTVLOGSTRING_LOW_LEVEL( "Leave: NULL argument aClient" ); + User::Leave( KErrArgument ); + } + + MIptvServiceManagementClientObserver::TRespStatus respStatus; + CDesC8ArraySeg* services = NULL; + + TInt error = aClient->GetServicesL( 0, + CIptvServiceManagementClient::EDisplayOrderAscending, + services, + respStatus ); + + if ( error == KErrNone && services ) + { + CleanupStack::PushL( services ); + + CIptvService* service = CIptvService::NewL(); + CleanupStack::PushL( service ); + + // Go through all services. + for (TInt i = 0; i < services->Count(); i++ ) + { + service->SetL( services->MdcaPoint(i) ); + + TUint32 flags = service->GetFlags(); + + // Only copy IAPs from user modifiable services (not provisioned). + if ( ! (flags & CIptvService::EReadOnlyIaps) ) + { + // Go through all IAPs for this service. + for ( TUint8 j = 0; j < service->iIapList->Count(); j++ ) + { + TIptvIap& existingIap = service->iIapList->IapL( j ); + + // Check that this IAP is not already on user's list. + TBool bFound = EFalse; + for ( TUint8 k = 0; k < aIapList.Count(); k++ ) + { + TIptvIap& userIap = aIapList.IapL( k ); + + if ( userIap.iId == existingIap.iId ) + { + bFound = ETrue; + break; + } + } + + // Add IAP to user's list. + if ( ! bFound ) + { + aIapList.AddIap( existingIap ); + } + } + } + } + + CleanupStack::PopAndDestroy( service ); + services->Reset(); + CleanupStack::PopAndDestroy( services ); + + if ( aIapList.Count() > 0 ) + { + return KErrNone; + } + } + return KErrNotFound; + } + +// --------------------------------------------------------------------------- +// CIptvProvisioningAppUi::DoesUserWantToInstallServiceL( CIptvService& ) +// --------------------------------------------------------------------------- +// +TBool CIptvProvisioningAppUi::DoesUserWantToInstallServiceL( + CIptvService& aService ) const + { + IPTVLOGSTRING_LOW_LEVEL( + "CIptvProvisioningAppUi::DoesUserWantToInstallServiceL" ); + + TBool install( EFalse ); + + // Create confirmation text combining resourse text and localised name + // of the service. + HBufC* confirmationText; + HBufC* localisedServiceName( NULL ); + if ( 0 == aService.GetName().CompareF( KQtnIptvVideoStoreList ) ) + { + localisedServiceName = StringLoader::LoadLC( R_IPTV_VIDEO_STORE_LIST ); + confirmationText = StringLoader::LoadLC( + R_IPTV_INSTALL_PROVISIONING_SERVICE, + *localisedServiceName ); + } + else + { + confirmationText = StringLoader::LoadLC( + R_IPTV_INSTALL_PROVISIONING_SERVICE, + aService.GetName() ); + } + + CAknQueryDialog* dialog = new( ELeave ) CAknQueryDialog( + *confirmationText, + CAknQueryDialog::ENoTone ); + + // Kick the dialog to the screen and wait for an answer. + if ( dialog->ExecuteLD( R_IPTV_PROVISIONING_QUERY_INSTALL_SERVICE ) + == EAknSoftkeyOk ) + { + install = ETrue; + } + + // Destroy the text allocated by string loader + CleanupStack::PopAndDestroy( confirmationText ); + if ( localisedServiceName ) + { + CleanupStack::PopAndDestroy( localisedServiceName ); + } + + return install; + } + +// --------------------------------------------------------------------------- +// CIptvProvisioningAppUi::OverwriteExistingServiceL( ) +// --------------------------------------------------------------------------- +// +TBool CIptvProvisioningAppUi::OverwriteExistingServiceL( + const TDesC& aServiceName ) const + { + IPTVLOGSTRING_LOW_LEVEL( + "CIptvProvisioningAppUi::OverwriteExistingServiceL" ); + TBool overWrite( EFalse ); + + // Create confirmation text combining resourse text and name of the + // service. + HBufC* confirmationText; + HBufC* localisedServiceName( NULL ); + if ( 0 == aServiceName.CompareF( KQtnIptvVideoStoreList ) ) + { + localisedServiceName = StringLoader::LoadLC( R_IPTV_VIDEO_STORE_LIST ); + confirmationText = StringLoader::LoadLC( + R_IPTV_RESET_EXISTING_SERVICE, *localisedServiceName ); + } + else + { + confirmationText = StringLoader::LoadLC( + R_IPTV_RESET_EXISTING_SERVICE, aServiceName ); + } + + CAknQueryDialog* dialog = new( ELeave ) CAknQueryDialog( + *confirmationText, + CAknQueryDialog::ENoTone ); + + // Display the dialog to the screen and wait for an answer. + if ( dialog->ExecuteLD( + R_IPTV_PROVISIONING_VOD_RESET_EXISTING_SERVICE ) == EAknSoftkeyOk ) + { + overWrite = ETrue; + } + + // Destroy the text allocated by string loader. + CleanupStack::PopAndDestroy( confirmationText ); + if ( localisedServiceName ) + { + CleanupStack::PopAndDestroy( localisedServiceName ); + } + + return overWrite; + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ShowInvalidDataNoteL +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::ShowInvalidDataNoteL() const + { + IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::ShowInvalidDataNoteL"); + + HBufC* text = StringLoader::LoadLC( R_IPTV_INVALID_DATA ); + CAknErrorNote* note = new( ELeave ) CAknErrorNote( R_AKN_ERROR_NOTE ); + + note->ExecuteLD(*text); + CleanupStack::PopAndDestroy(text); + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ShowInvalidServiceTypeNoteL +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::ShowInvalidServiceTypeNoteL() const + { + IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::ShowInvalidServiceTypeNoteL"); + + HBufC* text = StringLoader::LoadLC( R_IPTV_INVALID_SERVICE_TYPE ); + CAknErrorNote* note = new( ELeave ) CAknErrorNote( R_AKN_ERROR_NOTE ); + + note->ExecuteLD( *text ); + CleanupStack::PopAndDestroy( text ); + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ShowDoneNoteL +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::ShowDoneNoteL( TBool aFeed ) const + { + IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::ShowDoneNoteL"); + + HBufC* text; + if ( aFeed ) + { + text = StringLoader::LoadLC( R_IPTV_INSTALLED ); + } + else + { + text = StringLoader::LoadLC( R_IPTV_DONE ); + } + + CAknInformationNote* note = + new( ELeave ) CAknInformationNote( R_AKN_INFORMATION_NOTE ); + + note->ExecuteLD( *text ); + CleanupStack::PopAndDestroy( text ); + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::GetServiceIdByProviderIdL +// ---------------------------------------------------------------------------- +// +TUint32 CIptvProvisioningAppUi::GetServiceIdByProviderIdL( + CIptvServiceManagementClient* aClient, + const TDesC& aProviderId ) + { + CIptvServices* services = CIptvServices::NewL(); + CleanupStack::PushL( services ); + User::LeaveIfError( aClient->GetServicesL( aProviderId, *services ) ); + TUint32 serviceId( services->GetServiceRefL( 0 ).GetId() ); + CleanupStack::PopAndDestroy( services ); + return serviceId; + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::QueryAddedServiceOpenL +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::QueryAddedServiceOpenL( + TUint32 aServiceId, TUint32 aGroupId ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::QueryAddedServiceOpenL" ); + + HBufC* confirmationText = StringLoader::LoadLC( + R_IPTV_ADDED_SERVICE_OPEN ); + + CAknQueryDialog* dialog = new( ELeave ) CAknQueryDialog( + *confirmationText, CAknQueryDialog::ENoTone ); + + // Display the dialog to the screen and wait for an answer. + + TInt result = dialog->ExecuteLD( R_IPTV_PROVISIONING_VOD_QUERY_ADDED_SERVICE_OPEN ); + + if( result == EAknSoftkeyYes || result == EAknSoftkeyOk ) + { + CleanupStack::PopAndDestroy( confirmationText ); + + // Start / send message to Main application + + RWsSession session; + User::LeaveIfError( session.Connect() ); + TApaTaskList taskList( session ); + TApaTask task = taskList.FindApp( KUidMpxVideoPlayerApplication ); + + if( task.Exists() ) + { + // VC is open. + task.BringToForeground(); + + TVideoPlayerActivationMessage params; + params.iMsgType = TVideoPlayerActivationMessage::ELaunchServiceById; + params.iMsgSender = TVideoPlayerActivationMessage::ENotification; + params.iServiceId = aServiceId; + params.iGroupId = aGroupId; + params.iActive = 1; + params.iSingle = ETrue; + params.iFileId = 0; + params.iDrive = 0; + params.iFullPath = KNullDesC; + + TPckg message( params ); + TInt error = task.SendMessage( KMessageUid, message ); + + IPTVLOGSTRING2_LOW_LEVEL( "CIptvVodNotificationLauncher::send message error = %d", error ); + } + else + { + // Task doesn't exist, launch a new instance of an application + RApaLsSession lsSession; + // connect to AppArc server + User::LeaveIfError( lsSession.Connect() ); + + TApaAppInfo appInfo; + if ( lsSession.GetAppInfo( appInfo, KUidMpxVideoPlayerApplication ) == KErrNone ) + { + CApaCommandLine* cmdLine = CApaCommandLine::NewLC(); + cmdLine->SetExecutableNameL( appInfo.iFullName ); + + TVideoPlayerActivationMessage params; + params.iMsgType = TVideoPlayerActivationMessage::ELaunchServiceById; + params.iMsgSender = TVideoPlayerActivationMessage::ENotification; + params.iServiceId = aServiceId; + params.iGroupId = aGroupId; + params.iActive = 1; + params.iSingle = ETrue; + params.iFileId = 0; + params.iDrive = 0; + params.iFullPath = KNullDesC; + TPckg message( params ); + cmdLine->SetTailEndL( message ); + User::LeaveIfError( lsSession.StartApp( *cmdLine ) ); + CleanupStack::PopAndDestroy( cmdLine ); + } + } + } + else + { + CleanupStack::PopAndDestroy( confirmationText ); + } + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::IsServiceValidL +// ---------------------------------------------------------------------------- +// +TBool CIptvProvisioningAppUi::IsServiceValidL( CIptvService& aService ) + { + IPTVLOGSTRING_LOW_LEVEL("CIptvProvisioningAppUi::IsServiceValidL"); + + TBool liveIncluded( EFalse ); + + TBool valid = EFalse; + RImplInfoPtrArray vodArray; + CleanupClosePushL( vodArray ); + iEcomSession.ListImplementationsL( KRssPluginInterfaceUid, vodArray ); + RImplInfoPtrArray xmlTvArray; + CleanupClosePushL( xmlTvArray ); + iEcomSession.ListImplementationsL( KXmlTvPluginInterfaceUid, xmlTvArray ); + + // Here we check: + // 1) There is at least one implementation for the pluginuid defined in + // service object + // 2) Service type is either Vod OR + // 3) Service type is Live AND live is included in the build AND there is a + // plugin for live tv available (either smart vision plugin or xml tv plugin + // 4) Service type is Browser, Search or Upload + if ( ( aService.GetType() == CIptvService::EVod || + aService.GetType() == CIptvService::EServiceGroup || + ( aService.GetType() == CIptvService::EVodCast && + vodArray.Count() > 0 ) ) || + ( aService.GetType() == CIptvService::ELiveTv && + liveIncluded && xmlTvArray.Count() > 0 ) || + ( aService.GetType() == CIptvService::EBrowser || + aService.GetType() == CIptvService::ESearch || + aService.GetType() == CIptvService::EUpload ) ) + { + valid = ETrue; + } + + CleanupStack::PopAndDestroy( &xmlTvArray ); + CleanupStack::PopAndDestroy( &vodArray ); + return valid; + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::FindExistingGroupedIdsL() +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::FindExistingGroupedIdsL( + CIptvServiceManagementClient* aClient, + RArray& aExistingGroupIds ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::FindExistingGroupedIdsL" ); + + // Find exisitng group feeds + CDesC8ArraySeg* services = NULL; + MIptvServiceManagementClientObserver::TRespStatus respStatus; + aClient->GetServicesL( + CIptvServiceManagementClient::EGroupedServices, + CIptvServiceManagementClient::EDateAscending, + services, respStatus ); + + // Found any + if ( services ) + { + CleanupStack::PushL( services ); + CIptvService* service = CIptvService::NewL(); + CleanupStack::PushL( service ); + + // Go through all grouped services + for ( TInt i( 0 ); i < services->Count(); i++ ) + { + service->SetL( services->MdcaPoint( i ) ); + aExistingGroupIds.Append( service->GetId() ); + } + + CleanupStack::PopAndDestroy( service ); + CleanupStack::PopAndDestroy( services ); + } + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::DeleteExistingGroupedIdsL() +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::DeleteExistingGroupedIdsL( + CIptvServiceManagementClient* aClient, + RArray& aExistingGroupIds, + const TUint32 aReceivedGroup ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::DeleteExistingGroupedIdsL" ); + + if ( aExistingGroupIds.Count() > 0 ) + { + // Find exisitng group feeds + CDesC8ArraySeg* services = NULL; + MIptvServiceManagementClientObserver::TRespStatus respStatus; + aClient->GetServicesL( + CIptvServiceManagementClient::EGroupedServices, + CIptvServiceManagementClient::EDateAscending, + services, respStatus ); + + // Found any + if ( services ) + { + CleanupStack::PushL( services ); + CIptvService* service = CIptvService::NewL(); + CleanupStack::PushL( service ); + // File server for icons deleting + RFs fs; + CleanupClosePushL( fs ); + User::LeaveIfError( fs.Connect() ); + + // Go through all services + for ( TInt i( 0 ); i < services->Count(); i++ ) + { + service->SetL( services->MdcaPoint( i ) ); + if ( service->GetGroupId() == aReceivedGroup ) + { + const TInt index( + aExistingGroupIds.Find( service->GetId() ) ); + if ( index > KErrNotFound ) + { + // Delete icon file if downloaded and exist + if ( service->GetIconPath() != KIptvEmptyDes ) + { + if ( BaflUtils::FileExists( fs, service->GetIconPath() ) ) + { + fs.Delete( service->GetIconPath() ); + } + } + + // Selete service + aClient->DeleteServiceL( aExistingGroupIds[index], respStatus ); + if ( respStatus != MIptvServiceManagementClientObserver::ESucceeded ) + { + IPTVLOGSTRING_LOW_LEVEL( "Error during deleting existing grouped service !" ); + User::Leave( KErrGeneral ); + } + } + } + } + + // Verify grouped services items order + CleanupStack::PopAndDestroy( &fs ); + CleanupStack::PopAndDestroy( service ); + CleanupStack::PopAndDestroy( services ); + } + } + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL() +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL( + CIptvServiceManagementClient* aClient, + RArray& aGroupItemsOrder ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL" ); + + // Find exisitng group feeds + CDesC8ArraySeg* services = NULL; + MIptvServiceManagementClientObserver::TRespStatus respStatus; + aClient->GetServicesL( + CIptvServiceManagementClient::EGroupedServices, + CIptvServiceManagementClient::EDisplayOrderAscending, + services, respStatus ); + + // Found any + if ( services ) + { + CleanupStack::PushL( services ); + + for ( TInt i( 0 ); i < aGroupItemsOrder.Count(); i++ ) + { + const TUint expectedId( aGroupItemsOrder[i] ); + CIptvService* service = CIptvService::NewL(); + CleanupStack::PushL( service ); + service->SetL( services->MdcaPoint( i ) ); + + // Verify order + TBool needUpdate( EFalse ); + if ( service->GetId() != expectedId ) + { + // Find missplaced service + for ( TInt j( 0 ); j < services->Count(); j++ ) + { + CIptvService* second = CIptvService::NewL(); + CleanupStack::PushL( second ); + second->SetL( services->MdcaPoint( j ) ); + if ( second->GetId() == expectedId ) + { + // Swap those two service display order + TRespStatus status( EEmpty ); + second->SetDisplayOrder( service->GetDisplayOrder() ); + TInt err( aClient->UpdateServiceL( *second, status ) ); + + // Verify status + if ( err != KErrNone || status != ESucceeded ) + { + IPTVLOGSTRING3_LOW_LEVEL( + "CIptvProvisioningAppUi::ForceOrderOfGroupedServicesL(), err: %d, status: %d", + err, status ); + User::Leave( KErrCompletion ); + } + + // Swap done + needUpdate = ETrue; + j = services->Count(); + } + + CleanupStack::PopAndDestroy( second ); + } + } + + CleanupStack::PopAndDestroy( service ); + + // Local services list need to be updated when display order swapped + if ( needUpdate ) + { + CleanupStack::Pop( services ); + delete services; services = NULL; + aClient->GetServicesL( + CIptvServiceManagementClient::EGroupedServices, + CIptvServiceManagementClient::EDisplayOrderAscending, + services, respStatus ); + CleanupStack::PushL( services ); + } + } + + CleanupStack::PopAndDestroy( services ); + } + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::VerifyServiceGroupL() +// ---------------------------------------------------------------------------- +// +TBool CIptvProvisioningAppUi::VerifyServiceGroupL( + CIptvServiceManagementClient* aClient, + CIptvService& aService, + TUint32& aGroupId, + TUint32& aLaunchId ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::VerifyServiceGroupL" ); + + const TUint32 groupId( aService.GetGroupId() ); + if ( groupId == 0 || + ( groupId > 0 && aService.GetType() == CIptvService::EServiceGroup ) ) + { + // Group id for service lauch + if ( groupId > 0 && aLaunchId == 0 ) + { + aLaunchId = groupId; + } + + return ETrue; // Not grouped feed + } + + // Find group feeds + CDesC8ArraySeg* services = NULL; + MIptvServiceManagementClientObserver::TRespStatus respStatus; + aClient->GetServicesL( + CIptvServiceManagementClient::EServiceGroup, + CIptvServiceManagementClient::EDateAscending, + services, respStatus ); + + // Found any + TBool found( EFalse ); + if ( services ) + { + CleanupStack::PushL( services ); + CIptvService* service = CIptvService::NewL(); + CleanupStack::PushL( service ); + + // Go through all services + for ( TInt i( 0 ); !found && i < services->Count(); i++ ) + { + service->SetL( services->MdcaPoint( i ) ); + if ( service->GetGroupId() == groupId ) + { + found = ETrue; // ok to install + aGroupId = groupId; + } + } + + CleanupStack::PopAndDestroy( service ); + CleanupStack::PopAndDestroy( services ); + } + + return found; + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::SetGroupReceivedL() +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::SetGroupReceivedL( + CIptvServiceManagementClient* aClient, + const TUint32& aGroupId ) + { + IPTVLOGSTRING_LOW_LEVEL( "CIptvProvisioningAppUi::SetGroupReceivedL" ); + + // Find group feeds + CDesC8ArraySeg* services = NULL; + MIptvServiceManagementClientObserver::TRespStatus respStatus; + aClient->GetServicesL( + CIptvServiceManagementClient::EServiceGroup, + CIptvServiceManagementClient::EDateAscending, + services, respStatus ); + + // Find and update flag + if ( services ) + { + CleanupStack::PushL( services ); + CIptvService* service = CIptvService::NewL(); + CleanupStack::PushL( service ); + + // Go through all services + for ( TInt i( 0 ); i < services->Count(); i++ ) + { + service->SetL( services->MdcaPoint( i ) ); + if ( service->GetGroupId() == aGroupId ) + { + service->SetFlags( + service->GetFlags() | CIptvService::EGroupReceived ); + TRespStatus status( EEmpty ); + User::LeaveIfError( + aClient->UpdateServiceL( *service, status ) ); + i = services->Count(); + } + } + + CleanupStack::PopAndDestroy( service ); + CleanupStack::PopAndDestroy( services ); + } + } + +// Methods implemented to fullfill inheritance of +// MIptvServiceManagementClientObserver. Implementation of the inherited +// methods is empty since we do not use asynchorous versions of the methods +// but nevertheless CIptvServiceManagementClient requires the observer to +// be given for the NewL + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::AddServiceResp( TRespStatus ) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::AddServiceResp( + TRespStatus /*aRespStatus*/) + { + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::UpdateServiceResp( TRespStatus ) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::UpdateServiceResp( + TRespStatus /*aRespStatus*/) + { + } + + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::DeleteServiceResp( TRespStatus ) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::DeleteServiceResp( + TRespStatus /*aRespStatus*/ ) + { + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::GetServicesResp( TRespStatus, CDesC8ArraySeg* ) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::GetServicesResp( + TRespStatus /*aRespStatus*/, + CDesC8ArraySeg* /*aServicesArray*/ ) + { + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::GetUsedIapResp( TUInt, +// const TDesC&, +// TConnectionPermission, +// TRespStatus ) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::GetUsedIapResp( + TUint32 /*aIapId*/, + const TDesC& /*aIapName*/, + CIptvNetworkSelection::TConnectionPermission /*aConnectionPermission*/, + TBool /*aWlanWhenGPRS*/, + CIptvNetworkSelection::TRespStatus /*aRespStatus*/ ) + { + } + +// ---------------------------------------------------------------------------- +// CIptvProvisioningAppUi::ServerShutdownResp( TRespStatus ) +// ---------------------------------------------------------------------------- +// +void CIptvProvisioningAppUi::ServerShutdownResp( + TRespStatus /*aRespStatus*/ ) + { + }