/*

* Copyright (c) 2002-2004 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:   Object to offer some common utility functions to Iptv engine testing*

*/

// INCLUDE FILES

#include <e32Base.h>

#include "CIptvTestSMApiUtil.h"

#include "CIptvService.h"

#include "VCXTestLog.h"

#include <BAUTILS.H>

//#include <CIptvServiceManager.h>

#include "CIptvTestActiveWait.h"

#include "CIptvServiceManagementClient.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CIptvTestSMApiUtil::CIptvTestSMApiUtil

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIptvTestSMApiUtil::CIptvTestSMApiUtil()

    {

    }

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

// CIptvTestSMApiUtil::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvTestSMApiUtil::ConstructL()

    {

    iIptvServiceManagementClient = CIptvServiceManagementClient::NewL(*this);

    iActiveWait = CIptvTestActiveWait::NewL();

    iRefreshNeeded = ETrue;

    }

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

// CIptvServicesFromFile::NewL

// Two-phased constructor.

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

//

CIptvTestSMApiUtil* CIptvTestSMApiUtil::NewL()

    {

    VCXLOGLO1(">>>CIptvTestSMApiUtil::NewL");

    CIptvTestSMApiUtil* self = new( ELeave ) CIptvTestSMApiUtil;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

	VCXLOGLO1("<<<CIptvTestSMApiUtil::NewL");

    return self;

    }

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

// CIptvServicesFromFile::NewL

// Destructor

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

//

CIptvTestSMApiUtil::~CIptvTestSMApiUtil()

    {

    VCXLOGLO1(">>>CIptvTestSMApiUtil::~CIptvTestSMApiUtil");

  	iServicesArray.ResetAndDestroy();

	delete iActiveWait;

    if(iIptvServiceManagementClient)

        {

        delete iIptvServiceManagementClient;

        iIptvServiceManagementClient=NULL;

        }

 	iFsSession.Close();

    VCXLOGLO1("<<<CIptvTestSMApiUtil::~CIptvTestSMApiUtil");

    }

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

// CIptvTestSMApiUtil::GetServiceFromDb

// Creates CIptvServiceInstance from parameters

// returns pointer to service if succeeded, otherwise NULL

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

//

CIptvService* CIptvTestSMApiUtil::GetServiceFromDb(TInt aId)

    {

    if( iRefreshNeeded )

        {

        RefreshServicesL();

        }

    for(TInt i=iServicesArray.Count()-1; i>=0; i--)

        {

        if( iServicesArray[i]->GetId() == aId )

            {

            return CopyServiceL( *iServicesArray[i] );

            }

        }

    return NULL;

    }

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

// CIptvTestSMApiUtil::GetUsedIap

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

//

TBool CIptvTestSMApiUtil::GetUsedIap(TUint32 aServiceId, TUint32& aIAPId, TDes& aIapName)

    {

    VCXLOGLO1(">>>CIptvTestSMApiUtil::GetUsedIap");

    TBool rv = ETrue;

    CIptvNetworkSelection::TConnectionPermission connectionPermission;

    CIptvNetworkSelection::TRespStatus respStatus;

    TRAPD(error, iIptvServiceManagementClient->GetUsedIapL(aServiceId,

                                                                aIAPId,

                                                                aIapName,

                                                                connectionPermission,

                                                                respStatus));

    if(error != KErrNone ||

        respStatus != CIptvNetworkSelection::ESucceeded)

        {

        VCXLOGLO1("<<<CIptvTestSMApiUtil::GetUsedIap failed!!!");

        rv = EFalse;

        }

    VCXLOGLO1("<<<CIptvTestSMApiUtil::GetUsedIap");

    return rv;

    }

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

// CIptvServiceManager::GetServicesFromDbL()

// Get services from databases.

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

//

TBool CIptvTestSMApiUtil::GetServicesFromDbL(RPointerArray<CIptvService>& aServicesArray, TUint32 aFlagsFilter,

        CIptvServiceManagementClient::TOrder aOrder)

    {

    VCXLOGLO1(">>>CIptvTestSMApiUtil::GetServicesFromDbL");

	aServicesArray.ResetAndDestroy();

	TInt err = KErrNone, err2 = KErrNone;

    TRAP(err2, err = iIptvServiceManagementClient->GetServicesReqL( aFlagsFilter, aOrder ) );

	if(err2 != KErrNone)

    	{

        VCXLOGLO2("GetServicesReqL caused a leave: %d", err2);

        VCXLOGLO1("<<<CIptvTestSMApiUtil::GetServicesFromDbL");

    	return EFalse;

    	}

    else

    if(err != KErrNone)

    	{

        VCXLOGLO2("GetServicesReqL returned error: %d", err);

        VCXLOGLO1("<<<CIptvTestSMApiUtil::GetServicesFromDbL");

        return EFalse;

    	}

	iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

    TBool ret = ETrue;

    if( iSMRespStatus != MIptvServiceManagementClientObserver::ESucceeded

            && iSMRespStatus != MIptvServiceManagementClientObserver::EEmpty

            )

        {

        ret = EFalse;

        }

	for(TInt i = 0; i < iServicesArray.Count(); i++)

    	{

        aServicesArray.Append( CopyServiceL( *iServicesArray[i] ) );

    	}

    VCXLOGLO1("<<<CIptvTestSMApiUtil::GetServicesFromDbL");

    return ret;

    }

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

// CIptvServiceManager::GetServicesFromDbL()

// Get services from databases.

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

//

TBool CIptvTestSMApiUtil::GetServicesFromDbL(RPointerArray<CIptvService>& aServicesArray)

    {

    VCXLOGLO1(">>>CIptvTestSMApiUtil::GetServicesFromDbL (2)");

    aServicesArray.ResetAndDestroy();

    if( iRefreshNeeded )

        {

        RefreshServicesL();

        }

    for(TInt i = 0; i < iServicesArray.Count(); i++)

        {

        aServicesArray.Append( CopyServiceL( *iServicesArray[i] ) );

        }

    VCXLOGLO1("<<<CIptvTestSMApiUtil::GetServicesFromDbL (2)");

    return ETrue;

    }

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

// CIptvServiceManager::RefreshServicesL()

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

//

TBool CIptvTestSMApiUtil::RefreshServicesL()

    {

    VCXLOGLO1(">>>CIptvTestSMApiUtil::RefreshServicesL");

    iServicesArray.ResetAndDestroy();

    if( iRefreshingServices )

        {

        VCXLOGLO1("<<<CIptvTestSMApiUtil:: Already refreshing.");

        VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshServicesL");

        return ETrue;

        }

    TInt err = KErrNone, err2 = KErrNone;

    TRAP(err2, err = iIptvServiceManagementClient->GetServicesReqL(0, CIptvServiceManagementClient::EDisplayOrderAscending ));

    if(err2 != KErrNone)

        {

        VCXLOGLO2("GetServicesReqL caused a leave: %d", err2);

        VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshServicesL");

        return EFalse;

        }

    else

    if(err != KErrNone)

        {

        VCXLOGLO2("GetServicesReqL returned error: %d", err);

        VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshServicesL");

        return EFalse;

        }

    iRefreshingServices = ETrue;

    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

    TBool ret = ETrue;

    if( iSMRespStatus != MIptvServiceManagementClientObserver::ESucceeded

            && iSMRespStatus != MIptvServiceManagementClientObserver::EEmpty

            )

        {

        ret = EFalse;

        }

    VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshServicesL");

    return ret;

    }

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

// CIptvTestSMApiUtil::IsServiceIncludedInSearch()

//

// Decides if the service is included in the search.

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

//

TBool CIptvTestSMApiUtil::IsServiceIncludedInSearch(TUint32 aSearchLimitFlags, CIptvService& aIptvService)

    {

    if(aSearchLimitFlags == 0)

        {

        return ETrue;

        }

         /*   ESelectedServices = (1 << 0),

            EMainServices     = (1 << 1),

            ESubServices      = (1 << 2),

            EVod              = (1 << 3),

            ELiveTv           = (1 << 4),

            EVodCast          = (1 << 5),

            EOther            = (1 << 6)        */

    if((aSearchLimitFlags & CIptvServiceManagementClient::ESelectedServices)

       && aIptvService.GetFlags() & CIptvService::ESelected)

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::EMainServices)

       && (aIptvService.GetFlags() & CIptvService::EMainService))

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::ESubServices)

        && !(aIptvService.GetFlags() & CIptvService::EMainService))

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::EVod)

       && (aIptvService.GetType() == CIptvService::EVod))

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::EVodCast)

       && (aIptvService.GetType() == CIptvService::EVodCast))

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::EBrowser)

       && (aIptvService.GetType() == CIptvService::EBrowser))

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::EVideoRemote)

       && (aIptvService.GetType() == CIptvService::EVideoRemote))

        {

        return ETrue;

        }

    if((aSearchLimitFlags & CIptvServiceManagementClient::EApplication)

       && (aIptvService.GetType() == CIptvService::EApplication))

        {

        return ETrue;

        }

    if(aSearchLimitFlags & CIptvServiceManagementClient::ELiveTv

       && (aIptvService.GetType() == CIptvService::ELiveTv))

        {

        return ETrue;

        }

    if(aSearchLimitFlags & CIptvServiceManagementClient::EMobileTv

       && (aIptvService.GetType() == CIptvService::EMobileTv))

        {

        return ETrue;

        }

    if(aSearchLimitFlags & CIptvServiceManagementClient::EOther

       && (aIptvService.GetType() == CIptvService::EOther))

        {

        return ETrue;

        }

    return EFalse;

    }

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

// CIptvTestSMApiUtil::CopyService

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

//

CIptvService* CIptvTestSMApiUtil::CopyServiceL( CIptvService& aService )

    {

    CIptvService* iptvService = NULL;

    iptvService = CIptvService::NewL();

    CleanupStack::PushL(iptvService);

    HBufC8* buff = aService.GetL();

    CleanupStack::PushL(buff);

    iptvService->SetL( buff->Des() );

    CleanupStack::PopAndDestroy(buff);

    CleanupStack::Pop(iptvService);

    return iptvService;

    }

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

// CIptvTestSMApiUtil::SetUsedIap(TUint32 aServiceId, TUint32 aIapId)

//

// Sets default iap for a service, and set connecting allowed for the iap.

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

//

TInt CIptvTestSMApiUtil::SetUsedIap(TUint32 aServiceId, TUint32 aIapId)

	{

	TInt err(KErrNone);

	CIptvNetworkSelection::TRespStatus respStatus;

    TRAP(err, iIptvServiceManagementClient->SetUsedIapL(aIapId, aServiceId, ETrue, respStatus));

	if(KErrNone != err)

	    {

	    VCXLOGLO1("CIptvServiceManagementClient::SetUsedIapL leaved");

	    return err;

	    }

	else if( CIptvNetworkSelection::ESucceeded != respStatus )

	    {

	    VCXLOGLO1("CIptvServiceManagementClient::SetUsedIapL returned error");

	    return respStatus;

	    }

    TRAP(err, iIptvServiceManagementClient->SetConnectionAllowedL(ETrue, aIapId, respStatus));

	if(KErrNone != err)

	    {

	    VCXLOGLO1("CIptvServiceManagementClient::SetConnectionAllowedL leaved");

	    return err;

	    }

	else if( CIptvNetworkSelection::ESucceeded != respStatus )

	    {

	    VCXLOGLO1("CIptvServiceManagementClient::SetConnectionAllowedL returned error");

	    return respStatus;

	    }

	return err;

	}

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

// CIptvTestSMApiUtil::RefreshService(TUint32 aServiceId)

//

// Loads old service, creates a new duplicate of it and delete the old service.

// Useful for testing scheduled download, because all the contents seems to be

// new, not previously downloaded after calling this for a service.

// Old service id is not valid after calling this

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

//

TInt CIptvTestSMApiUtil::RefreshService(TUint32 aServiceId, TTime aLastDownloadTime)

	{

	VCXLOGLO1(">>>CIptvTestSMApiUtil::RefreshService");

    MIptvServiceManagementClientObserver::TRespStatus status;

    TInt leave(KErrNone);

    TInt err(KErrNone);

    CIptvService* service(NULL);

    TRAP(leave, service = GetServiceFromDb(aServiceId));

    if( leave!=KErrNone || service==NULL )

        {

        VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshService: GetServiceFromDb");

        return KErrNotFound;

        }

    TRAP(leave, err = iIptvServiceManagementClient->DeleteServiceL(aServiceId, status));

    if( MIptvServiceManagementClientObserver::ESucceeded != status ||

        KErrNone != leave || KErrNone != err)

        {

        VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshService: DeleteServiceL");

        return KErrGeneral;

        }

    // Create new unique provider id.

    _LIT(Kd,"%d");

    TBuf<24> buf;

    TTime now;

    now.HomeTime();

    buf.Format(Kd, now.Int64());

    service->SetProviderId(buf);

    //  After this it seems that downloas haven't ever been scheduled for this service.

    service->SetScheduledLastDownloadTime(aLastDownloadTime);

    TRAP(leave, err = iIptvServiceManagementClient->AddServiceL(*service, status));

    if( MIptvServiceManagementClientObserver::ESucceeded != status||

        KErrNone != leave|| KErrNone != err )

        {

        VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshService: AddServiceL");

        return KErrGeneral;

        }

	VCXLOGLO1("<<<CIptvTestSMApiUtil::RefreshService");

	return KErrNone;

	}

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

// CIptvTestSMApiUtil::GetServicesResp()

//

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

//

void CIptvTestSMApiUtil::GetServicesResp(TRespStatus aRespStatus, CDesC8ArraySeg* aServicesArray)

	{

	VCXLOGLO1(">>>CIptvTestSMApiUtil::GetServicesResp");

	iRefreshNeeded = EFalse;

	switch(iSMRespStatus)

        {

        case MIptvServiceManagementClientObserver::ESucceeded:

            {

            VCXLOGLO1("GetServicesReqL response: ESucceeded");

            break;

            }

        case MIptvServiceManagementClientObserver::EEmpty:

            {

            VCXLOGLO1("GetServicesReqL response: EEmpty");

            break;

            }

        case MIptvServiceManagementClientObserver::EServiceNotFound:

            {

            VCXLOGLO1("GetServicesReqL response: EServiceNotFound");

            iRefreshNeeded = ETrue;