/*

* Copyright (c) 2005 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 "CIptvServiceManagementSync.h"

#include "CIptvServiceManagementClient.h"

#include "CIptvTestUtilities.h"

#include "CIptvService.h"

#include "VCXTestLog.h"

#include "CIptvTestTimer.h"

#include "CIptvTestActiveWait.h"

#include <f32file.h>

#include <S32FILE.H>

#include <BAUTILS.H>

//#include <CIptvSmEvent.h>

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

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

// CIptvServiceManagementSync::NewL()

// Two-phased constructor.

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

CIptvServiceManagementSync* CIptvServiceManagementSync::NewL()

    {

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

    CIptvServiceManagementSync* self = new (ELeave) CIptvServiceManagementSync;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

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

    return( self ) ;

    }

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

// CIptvServiceManagementSync::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CIptvServiceManagementSync::ConstructL()

    {

    VCXLOGLO1(">>>CIptvServiceManagementSync::ConstructL");

    iActiveWait = CIptvTestActiveWait::NewL();

    iIptvTestTimer = CIptvTestTimer::NewL( *this, 0 );

    iIptvServiceManagementClient = CIptvServiceManagementClient::NewL(*this);

    TRAPD(err, iIptvTestUtilities = CIptvTestUtilities::NewL() );

    if(err != KErrNone)

        {

        VCXLOGLO1("CIptvServiceManagementSync:: ** FAIL ** Creating CIptvTestUtilities failed! Leaving.");

        User::Leave(KErrGeneral);

        }

    VCXLOGLO1("<<<CIptvServiceManagementSync::ConstructL");

    }

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

// CIptvServiceManagementSync::CIptvServiceManagementSync()

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

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

CIptvServiceManagementSync::CIptvServiceManagementSync()

    {

    VCXLOGLO1(">>>CIptvServiceManagementSync::CIptvServiceManagementSync");

    VCXLOGLO1("<<<CIptvServiceManagementSync::CIptvServiceManagementSync");

    }

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

// CIptvServiceManagementSync::~CIptvServiceManagementSync()

// Destructor.

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

//

CIptvServiceManagementSync::~CIptvServiceManagementSync()

    {

    VCXLOGLO1(">>>~CIptvServiceManagementSync()");

    if(iServicesArray)

        {

        iServicesArray->Reset();

        delete iServicesArray;

        iServicesArray = NULL;

        }

    delete iIptvServiceManagementClient;

    iIptvServiceManagementClient = NULL;

    delete iIptvTestTimer;

    iIptvTestTimer = NULL;

    delete iIptvTestUtilities;

    iIptvTestUtilities = NULL;

    delete iActiveWait;

    iActiveWait = NULL;

    VCXLOGLO1("<<<~CIptvServiceManagementSync()");

    }

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

// CIptvServiceManagementSync::CallAddService(TIptvSmTestConnection aConn, CIptvService& aService);

// Adds a service to Service data base.

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

//

TRespStatus CIptvServiceManagementSync::CallAddService(TIptvSmTestConnection aConn, CIptvService& aService)

    {

    VCXLOGLO1(">>>CIptvServiceManagementSync::CallAddService()");

    TInt err = KErrNone, err2 = KErrNone;

    err = PrepareForRequest();

    if(err != KErrNone)

        {

        VCXLOGLO1("<<<CIptvServiceManagementSync::CallAddService.");

        return EGeneralError;

        }

    if(aConn == EIptvSmTestAsync)

        {

        VCXLOGLO1("Async service request");

        while(iRequestRepeatCount-- > 0)

            {

            SetExpectedSmEvent(CIptvSmEvent::EServiceAdded, 1);

            TInt retryCount = 5;

            while(retryCount-- > 0)

                {

                TRAP(err2, err = iIptvServiceManagementClient->AddServiceReqL(aService) );

                if(err2 == KErrNone && err == KErrNotReady)

                    {

                    VCXLOGLO1("Server not ready, waiting a second before retry.");

                    iIptvTestTimer->After(1 * 1000000);

                    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

                    }

                else

                    {

                    break; // request succeeded or there's an error

                    }

                }

            if(err2 != KErrNone)

                {

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

                VCXLOGLO1("<<<CIptvServiceManagementSync::CallAddService");

                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end

                return EGeneralError;

                }

            if(err != KErrNone)

                {

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

                VCXLOGLO1("<<<CIptvServiceManagementSync::CallAddService");

                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end

                return EGeneralError;

                }

          }

        if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

            {

            iIptvServiceManagementClient->CancelRequest();

            VCXLOGLO1("Canceling request to server.");

            }

        else

            {

            iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

            if(WaitForSmEvent() != KErrNone)

                {

                iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

                }

            }

        }

    else

        {

        VCXLOGLO1("Sync service request");

        TRespStatus rv = ESucceeded;

        while(iRequestRepeatCount-- > 0)

            {

            SetExpectedSmEvent(CIptvSmEvent::EServiceAdded, 1);

            TInt retryCount = 5;

            while(retryCount-- > 0)

                {

                TRAP(err2, err = iIptvServiceManagementClient->AddServiceL(aService, rv) );

                if(err2 == KErrNone && err == KErrNotReady)

                    {

                    VCXLOGLO1("Server not ready, waiting a second before retry.");

                    iIptvTestTimer->After(1 * 1000000);

                    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

                    }

                else

                    {

                    break; // request succeeded or there's an error

                    }

                }

            if(err2 != KErrNone)

                {

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

                rv = EGeneralError;

                }

            else

            if(err != KErrNone)

                {

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

                rv = EGeneralError;

                }

            else

            if(MIptvServiceManagementClientObserver::ESucceeded != rv)

               {

               VCXLOGLO2("AddServiceL response error: %d", rv);

               }

            else

            if(WaitForSmEvent() != KErrNone)

                {

                iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

                }

            }

        iSyncReturnValue = rv;

        }

    FinishRequest();

    VCXLOGLO1("<<<CIptvServiceManagementSync::CallAddService");

    return iSyncReturnValue;

    }

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

// CIptvServiceManagementSync::UpdateServiceReq()

// Updates a service to Service data base.

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

//

TRespStatus CIptvServiceManagementSync::CallUpdateService(TIptvSmTestConnection aConn, CIptvService& aService, CIptvSmEvent::TEvent aExpectedEvent)

    {

    VCXLOGLO1(">>>CIptvServiceManagementSync::CallUpdateService()");

    TInt err = KErrNone, err2 = KErrNone;

    err = PrepareForRequest();

    if(err != KErrNone)

        {

        VCXLOGLO1("<<<CIptvServiceManagementSync::CallUpdateService.");

        return EGeneralError;

        }

    if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;

    if(aConn == EIptvSmTestAsync)

        {

        VCXLOGLO1("Async service request");

        while(iRequestRepeatCount-- > 0)

            {

            SetExpectedSmEvent(aExpectedEvent, 1);

            TInt retryCount = 5;

            while(retryCount-- > 0)

                {

                TRAP(err2, err = iIptvServiceManagementClient->UpdateServiceReqL(aService)  );

                if(err2 == KErrNone && err == KErrNotReady)

                    {

                    VCXLOGLO1("Server not ready, waiting a second before retry.");

                    iIptvTestTimer->After(1 * 1000000);

                    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

                    }

                else

                    {

                    break; // request succeeded or there's an error

                    }

                }

            if(err2 != KErrNone)

                {

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

                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end

                VCXLOGLO1("<<<CIptvServiceManagementSync::CallUpdateService");

                return EGeneralError;

                }

            if(err != KErrNone)

                {

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

                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end

                VCXLOGLO1("<<<CIptvServiceManagementSync::CallUpdateService");

                return EGeneralError;

                }

            }

        if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

            {

            iIptvServiceManagementClient->CancelRequest();

            VCXLOGLO1("Canceling request to server.");

            }

        else

            {

            iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // wait for the response from server

            if(WaitForSmEvent() != KErrNone)

                {

                iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

                }

            }

        }

    else

        {

        VCXLOGLO1("Sync service request");

        TRespStatus rv = ESucceeded;

        while(iRequestRepeatCount-- > 0)

            {

            SetExpectedSmEvent(aExpectedEvent, 1);

            TInt retryCount = 5;

            while(retryCount-- > 0)

                {

                TRAP(err2, err = iIptvServiceManagementClient->UpdateServiceL(aService, rv)  );

                if(err2 == KErrNone && err == KErrNotReady)

                    {

                    VCXLOGLO1("Server not ready, waiting a second before retry.");

                    iIptvTestTimer->After(1 * 1000000);

                    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

                    }

                else

                    {

                    break; // request succeeded or there's an error

                    }

                }

            if(err2 != KErrNone)

                {

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

                rv = EGeneralError;

                }

            else

            if(err != KErrNone)

                {

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

                rv = EGeneralError;

                }

            else

            if(MIptvServiceManagementClientObserver::ESucceeded != rv)

               {

               VCXLOGLO2("UpdateServiceL response error: %d", rv);

               }

            else

            if(WaitForSmEvent() != KErrNone)

                {

                iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

                }

            }

        iSyncReturnValue = rv;

        }

    FinishRequest();

    VCXLOGLO1("<<<CIptvServiceManagementSync::CallUpdateService() ");

    return iSyncReturnValue;

    }

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

// CIptvServiceManagementSync::CallGetServices()

// Gets service entries from Services database.

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

//

TRespStatus CIptvServiceManagementSync::CallGetServices(

                                    TIptvSmTestConnection aConn,

                                    TUint32 aStartId,

                                    TUint32 aEndId,

                                    CDesC8ArraySeg** aServicesArray

                                    )

    {

    VCXLOGLO1(">>>CIptvServiceManagementSync::GetServicesReqSync()");

    TInt err = KErrNone, err2 = KErrNone;

    // this should be always NULL, otherwise there probably has been an error and we still own this

    if(iServicesArray)

        {

        VCXLOGLO1("* ERROR * iServicesArray not NULL, error in previous GetServices request?");

        iServicesArray->Reset();

        delete iServicesArray;

        iServicesArray = NULL;

        }

    err = PrepareForRequest();

    if(err != KErrNone)

        {

        VCXLOGLO1("<<<CIptvServiceManagementSync::GetServicesReqSync");

        return EGeneralError;

        }

    if(aConn == EIptvSmTestAsync)

        {

        VCXLOGLO1("Async service request");

        while(iRequestRepeatCount-- > 0)

            {

            TInt retryCount = 5;

            while(retryCount-- > 0)

                {

                TRAP(err2, err = iIptvServiceManagementClient->GetServicesReqL(aStartId, aEndId)  );

                if(err2 == KErrNone && err == KErrNotReady)

                    {

                    VCXLOGLO1("Server not ready, waiting a second before retry.");

                    iIptvTestTimer->After(1 * 1000000);

                    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

                    }

                else

                    {

                    break; // request succeeded or there's an error

                    }

                }

            if(err2 != KErrNone)

                {

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

                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end

                VCXLOGLO1("<<<CIptvServiceManagementSync::GetServicesReqSync");

                return EGeneralError;

                }

            if(err != KErrNone)

                {

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

                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end

                VCXLOGLO1("<<<CIptvServiceManagementSync::GetServicesReqSync");

                return EGeneralError;

                }

            }

        if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

            {

            iIptvServiceManagementClient->CancelRequest();

            VCXLOGLO1("Canceling request to server.");

            }

        else

            {

            iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

            }

        }

    else

        {

        VCXLOGLO1("Sync service request");

        TRespStatus rv = ESucceeded;

        while(iRequestRepeatCount-- > 0)

            {

            TInt retryCount = 5;

            while(retryCount-- > 0)

                {

                TRAP(err2, err = iIptvServiceManagementClient->GetServicesL(aStartId, aEndId, iServicesArray, rv) );

                if(err2 == KErrNone && err == KErrNotReady)

                    {

                    VCXLOGLO1("Server not ready, waiting a second before retry.");

                    iIptvTestTimer->After(1 * 1000000);

                    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

                    }

                else

                    {

                    break; // request succeeded or there's an error

                    }

                }

            if(err2 != KErrNone)

                {

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

                rv = EGeneralError;

                }

            else

            if(err != KErrNone)

                {

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

                rv = EGeneralError;

                }

            else

            if(MIptvServiceManagementClientObserver::ESucceeded != rv)

               {

               VCXLOGLO2("GetServicesL response error: %d", rv);

               }

            }

        iSyncReturnValue = rv;

        }

    if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

        {

        if(iServicesArray == NULL)

            {

            iServicesArray  = new (ELeave) CDesC8ArraySeg(10);

            }

        }

    FinishRequest();