/*

* 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 <eikdoc.h>

#include "IptvDebug.h"

#include "CIptvIapList.h"

#include "CIptvUtil.h"

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <IptvProvisioningApp.rsg>

#include <aknnotewrappers.h>

#include <apgcli.h> // RApaLsSession

#include <bautils.h>

#include "CIptvService.h"

#include "CIptvServiceManagementClient.h"

#include "CIptvProvisioningProcessor.h"

#include "IptvProvisioningAppUi.h"

#include "IptvProvisioningApp.h"

#include "IptvProvisioningDocument.h"

#include "iptvlocalisationliterals.h"

#include <videoplayeractivationmessage.h>

// 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<TUint32> existingGroupIds;

    CleanupClosePushL( existingGroupIds );

    FindExistingGroupedIdsL( client, existingGroupIds );

    // Orginal group items order

    RArray<TUint32> 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() );

        }