/*

* Copyright (c) 2008 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: 

*

*/

// INCLUDE FILES

#include <bldvariant.hrh>

#include "IptvDebug.h"

#include "CIptvIapList.h"

#include "CIptvServiceManagementClient.h"

#include "vcxnsservicesettings.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::CVcxNsServiceSettings()

// 

// -----------------------------------------------------------------------------

//

CVcxNsServiceSettings::CVcxNsServiceSettings( )

    {

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::CVcxNsServiceSettings()

// 

// -----------------------------------------------------------------------------

//

CVcxNsServiceSettings::~CVcxNsServiceSettings( )

    {

    delete iIptvServiceManagementClient;

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::NewL()

// 

// -----------------------------------------------------------------------------

//

EXPORT_C CVcxNsServiceSettings* CVcxNsServiceSettings::NewL( )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::NewL()");

    return new (ELeave) CVcxNsServiceSettings();

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::GetAllServicesL()

// Note: Returns NULL if an error occurs.

// -----------------------------------------------------------------------------

//

EXPORT_C CDesC8ArraySeg* CVcxNsServiceSettings::GetAllServicesL()

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::GetAllServicesL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    CDesC8ArraySeg* services = NULL;

    TInt error = GetServiceManagementClientL()->GetServicesL( 0, 

                                                              CIptvServiceManagementClient::EDisplayOrderDescending,

                                                              services,

                                                              respStatus );

    if ( error == KErrNone )

        {

        return services;

        }

    else

        {

        return NULL;

        }

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::GetAllSelectedServicesL()

// Note: Returns NULL if an error occurs.

// -----------------------------------------------------------------------------

//

EXPORT_C CDesC8ArraySeg* CVcxNsServiceSettings::GetAllSelectedServicesL( TInt& aError )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::GetAllSelectedServicesL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    CDesC8ArraySeg* services = NULL;

    aError = GetServiceManagementClientL()->GetServicesL( CIptvServiceManagementClient::ESelectedServices, 

                                                          CIptvServiceManagementClient::EDisplayOrderDescending,

                                                          services,

                                                          respStatus );

    if ( aError == KErrNone )

        {

        return services;

        }

    else

        {

        return NULL;

        }

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::GetServicesByTypeL()

// Note: Returns NULL if an error occurs.

// -----------------------------------------------------------------------------

//

EXPORT_C CDesC8ArraySeg* CVcxNsServiceSettings::GetServicesByTypeL( CIptvService::TServiceType aServiceType )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::GetServicesByTypeL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    CDesC8ArraySeg* services = NULL;

    CIptvServiceManagementClient::TSearchLimitFlag flag = (CIptvServiceManagementClient::TSearchLimitFlag) 0;

    switch ( aServiceType )

        {

        case CIptvService::EVod:

            // using flag EVodServices to also include service groups and vodcasts.

            flag = CIptvServiceManagementClient::EVodServices;

            break;

        case CIptvService::ELiveTv:

            flag = CIptvServiceManagementClient::ELiveTv;

            break;

        case CIptvService::EVodCast:

            flag = CIptvServiceManagementClient::EVodCast;

            break;

        case CIptvService::EBrowser:

            flag = CIptvServiceManagementClient::EBrowser;

            break;

        case CIptvService::EVideoRemote:     

            flag = CIptvServiceManagementClient::EVideoRemote;

            break;               

        case CIptvService::EApplication:

            flag = CIptvServiceManagementClient::EApplication;

            break;        

        case CIptvService::EMobileTv:

            flag = CIptvServiceManagementClient::EMobileTv;

            break;

        case CIptvService::EOther:

            flag = CIptvServiceManagementClient::EOther;

            break;        

        default:     

            flag = (CIptvServiceManagementClient::TSearchLimitFlag) 0;

            break;

        }

    TInt error = GetServiceManagementClientL()->GetServicesL( flag, 

                                                              CIptvServiceManagementClient::EDisplayOrderDescending,

                                                              services,

                                                              respStatus );                                                             

    if ( error == KErrNone )

        {

        return services;

        }

    else

        {

        return NULL;

        }

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::GetIapListForNewServiceL()

// Gathers list of IAPs from other user defined services.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CVcxNsServiceSettings::GetIapListForNewServiceL( CIptvIapList& aIapList )

    {

    CDesC8ArraySeg* services = GetAllServicesL();

    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) );

            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;

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::AddServiceL()

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CVcxNsServiceSettings::AddServiceL( const TDesC& aServiceName,

                                             const TDesC& aAddress,

                                             const TDesC& aDescription,

                                             CIptvIapList& aIapList,

                                             CIptvService::TServiceType aServiceType,

                                             const TUid& aEpgPluginUid,

                                             const TUid& aIptvPluginUid,

                                             const TUid& aVodPluginUid )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::AddServiceL()");

    if ( aServiceName.Length() == 0 || aAddress.Length() == 0 )

        {

        return KErrArgument;

        }

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    CIptvService*                                     iptvService = CIptvService::NewL();

    CleanupStack::PushL( iptvService );

    iptvService->SetId( 0 );

    iptvService->SetName( aServiceName );

    iptvService->SetAddress( aAddress );

    iptvService->SetIconPath( KNullDesC );

    iptvService->SetType( aServiceType );

    iptvService->SetDesc( aDescription );

    iptvService->SetFlags( CIptvService::ESelected );

    iptvService->SetApplicationUid( 0 );

    iptvService->SetDisplayOrder( 0 );

    iptvService->iIapList->SetL( aIapList );

    iptvService->SetEpgPluginUid(aEpgPluginUid);

    iptvService->SetIptvPluginUid(aIptvPluginUid);

    iptvService->SetVodPluginUid(aVodPluginUid);

    TInt error = GetServiceManagementClientL()->AddServiceL( *iptvService, respStatus );

    CleanupStack::PopAndDestroy( iptvService );

    return error;

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::UpdateServiceL()

// -----------------------------------------------------------------------------

//

EXPORT_C void CVcxNsServiceSettings::UpdateServiceL( CIptvService& aIptvService )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::UpdateServiceL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    GetServiceManagementClientL()->UpdateServiceL( aIptvService, respStatus );

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::DeleteServiceL()

// -----------------------------------------------------------------------------

//

EXPORT_C void CVcxNsServiceSettings::DeleteServiceL( TUint32 aItemId )

    {

    IPTVLOGSTRING_HIGH_LEVEL("UI Engine ## CVcxNsServiceSettings::DeleteServiceL()");

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    GetServiceManagementClientL()->DeleteServiceL( aItemId, respStatus );

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::GetServiceL()

// Note: Method is not efficient, so use only if absolutely necessary.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CVcxNsServiceSettings::GetServiceL( TUint32 aServiceId, CIptvService& aIptvService )

    {

    /*CDesC8ArraySeg* services = NULL;

    MIptvServiceManagementClientObserver::TRespStatus respStatus;

    if ( ! iIptvServiceManagementClient )

        {

        iIptvServiceManagementClient = CIptvServiceManagementClient::NewL( *this );

        }

    TInt error = iIptvServiceManagementClient->GetServicesL( aServiceId, aServiceId, services, respStatus );

    if ( error == KErrNone && services->MdcaCount() > 0)

        {

        CleanupStack::PushL( services );

        aIptvService.SetL( services->MdcaPoint(0) );

        CleanupStack::PopAndDestroy( services );

        return KErrNone;

        }

    return KErrNotFound;

    */

    //Get only this specified service   

    CDesC8ArraySeg* services = GetAllServicesL();

    TInt            error    = KErrNotFound;

    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->GetId() == aServiceId )

                {

                aIptvService.SetL( services->MdcaPoint(i) );

                error = KErrNone;

                }

            }

        CleanupStack::PopAndDestroy( service );

        CleanupStack::PopAndDestroy( services );

        }

    return error;    

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceProvider::GetServiceManagementClientL()

// -----------------------------------------------------------------------------

//

CIptvServiceManagementClient* CVcxNsServiceSettings::GetServiceManagementClientL()

    {

    if ( ! iIptvServiceManagementClient )

        {

        iIptvServiceManagementClient = CIptvServiceManagementClient::NewL( *this );

        }

    return iIptvServiceManagementClient;    

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::GetScheduledDownloadSettingsL

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CVcxNsServiceSettings::GetScheduledDownloadSettingsL(

    TIptvServiceId aServiceId,

    TIptvVodScheduleDownloadtimeCombination& aDownloadTime,

    TIptvVodScheduleConnectionCondition& aCondition,

    TIptvVodScheduleDownloadTypeCombination& aType )

    {

    CIptvService* service = CIptvService::NewL();

    CleanupStack::PushL( service );

    TInt err = GetServiceL( aServiceId, *service );

    if ( err == KErrNone )

        {

        aDownloadTime = service->ScheduleDlTime();

        aCondition = static_cast<TIptvVodScheduleConnectionCondition>(

                        service->ScheduleDlNetwork() );

        aType = service->ScheduleDlType();

        }

    CleanupStack::PopAndDestroy( service );

    return err;

    }

// -----------------------------------------------------------------------------

// CVcxNsServiceSettings::SetScheduledDownloadSettingsL

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CVcxNsServiceSettings::SetScheduledDownloadSettingsL(

    TIptvServiceId aServiceId,

    TIptvVodScheduleDownloadtimeCombination aDownloadTime,

    TIptvVodScheduleConnectionCondition aCondition,

    TIptvVodScheduleDownloadTypeCombination aType )

    {

    CIptvService* service = CIptvService::NewL();

    CleanupStack::PushL( service );

    TInt err = GetServiceL( aServiceId, *service );

    if ( err == KErrNone )

        {

        service->SetScheduleDlTime( aDownloadTime );

        service->SetScheduleDlNetwork( aCondition );

        service->SetScheduleDlType( aType );

        //  If this is the first time scheduling for this service.

        if ( service->GetScheduledLastDownloadTime().Int64() == 0 &&

             aCondition != EManual &&

             aDownloadTime != ENoSchedule )

            {

            TTime current;

            current.UniversalTime();

            service->SetScheduledLastDownloadTime( current );

            }

        // If we move back to manual download state, let's reset the 'last

        // scheduled download time' so that old scheduling for service does

        // not confuse user when he later on sets scheduling on again.

        else if ( aCondition == EManual )

            {

            TTime zero( 0 );

            service->SetScheduledLastDownloadTime( zero );

            }

        UpdateServiceL( *service );

        }

    CleanupStack::PopAndDestroy( service );

    return err;

    }