diff -r 000000000000 -r 96612d01cf9f videofeeds/server/tsrc/VCXServiceManagementApiTest/src/CIptvServiceManagementSync.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videofeeds/server/tsrc/VCXServiceManagementApiTest/src/CIptvServiceManagementSync.cpp	Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,1972 @@
+/*
+* 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();
+
+    *aServicesArray = iServicesArray;
+    iServicesArray = NULL; // we don't need this anymore, ownership moves
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::GetServicesReqSync()");
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::GetAllSelectedServicesReq()
+// Requests all filtered services from the database.
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallGetServicesFiltered(
+                                            TUint32 aSearchLimitFlags,
+                                            CIptvServiceManagementClient::TOrder aOrder,
+                                            TIptvSmTestConnection aConn,
+                                            CDesC8ArraySeg** aServicesArray
+                                            )
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallGetServicesFiltered()");
+
+    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::CallGetServicesFiltered");
+        return EGeneralError;
+        }
+
+    if(aConn == EIptvSmTestAsync)
+        {
+        VCXLOGLO1("Async service request");
+
+        while(iRequestRepeatCount-- > 0)
+            {
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                TRAP(err2, err = iIptvServiceManagementClient->GetServicesReqL(aSearchLimitFlags, aOrder)  );
+
+                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::CallGetServicesFiltered");
+                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::CallGetServicesFiltered");
+                return EGeneralError;
+                }
+            }
+
+        if(iSpecialAction == EIptvSmCancelNextAsyncRequest)
+            {
+            //removed: iIptvTestTimer->After(5 * 1000000);
+
+            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(aSearchLimitFlags, aOrder, 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;
+                }
+            if(err != KErrNone)
+                {
+                VCXLOGLO2("GetServicesL returned error: %d", err);
+                rv = EGeneralError;
+                }
+            }
+
+            iSyncReturnValue = rv;
+        }
+
+
+    if(iSpecialAction == EIptvSmCancelNextAsyncRequest)
+        {
+        if(iServicesArray == NULL)
+            {
+            iServicesArray  = new (ELeave) CDesC8ArraySeg(10);
+            }
+        }
+
+    *aServicesArray = iServicesArray;
+    iServicesArray = NULL; // ownership moves
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetServicesFiltered()");
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::GetGetServicesByProviderId()
+// Requests all filtered services from the database.
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallGetServicesByProviderId(
+                                            TDesC& aProviderId,
+                                            CIptvServices& aServices
+                                            )
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallGetServicesByProviderId()");
+
+    TInt err = KErrNone, err2 = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetServicesByProviderId");
+        return EGeneralError;
+        }
+
+    VCXLOGLO1("Sync service request");
+
+    TInt retryCount = 5;
+
+    while(retryCount-- > 0)
+        {
+        TRAP(err2, err = iIptvServiceManagementClient->GetServicesL(aProviderId, aServices)  );
+
+        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("CallGetServicesByProviderId caused a leave: %d", err2);
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetServicesByProviderId");
+        return EGeneralError;
+        }
+    if(err != KErrNone)
+        {
+        VCXLOGLO2("CallGetServicesByProviderId returned error: %d", err);
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetServicesByProviderId");
+        return EGeneralError;
+        }
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetServicesByProviderId()");
+
+    FinishRequest();
+
+    return iSyncReturnValue;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallDeleteService()
+// Deletes a service from the database.
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallDeleteService(TIptvSmTestConnection aConn, TUint32 aId)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallDeleteService()");
+
+    TInt err = KErrNone, err2 = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallDeleteService");
+        return EGeneralError;
+        }
+
+    if(aConn == EIptvSmTestAsync)
+        {
+        VCXLOGLO1("Async service request");
+
+        while(iRequestRepeatCount-- > 0)
+            {
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                SetExpectedSmEvent(CIptvSmEvent::EServiceDeleted, 1);
+                TRAP(err2, err = iIptvServiceManagementClient->DeleteServiceReqL(aId) );
+                iIptvTestTimer->After(2 * 1000000);
+                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);
+
+                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("DeleteServiceReqL caused a leave: %d", err2);
+                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end
+                VCXLOGLO1("<<<CIptvServiceManagementSync::CallDeleteService");
+                return EGeneralError;
+                }
+            if(err != KErrNone)
+                {
+                VCXLOGLO2("DeleteServiceReqL returned error: %d", err);
+                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart); // don't just leave, wait possible request from server to end
+                VCXLOGLO1("<<<CIptvServiceManagementSync::CallDeleteService");
+                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(CIptvSmEvent::EServiceDeleted, 1);
+
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                TRAP(err2, err = iIptvServiceManagementClient->DeleteServiceL(aId + iRequestRepeatCount, rv) );
+
+                VCXLOGLO1("Request done.");
+
+                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
+                    }
+                }
+
+            VCXLOGLO1("Checking errors.");
+
+            if(err2 != KErrNone)
+                {
+                VCXLOGLO2("DeleteServiceL caused a leave: %d", err2);
+                rv = EGeneralError;
+                }
+            else
+            if(err != KErrNone)
+                {
+                VCXLOGLO2("DeleteServiceL returned error: %d", err);
+                rv = EGeneralError;
+                }
+            else
+            if(MIptvServiceManagementClientObserver::ESucceeded != rv)
+               {
+               VCXLOGLO2("DeleteServiceL response error: %d", rv);
+               }
+            else
+            if(WaitForSmEvent() != KErrNone)
+                {
+                iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;
+                }
+            }
+        iSyncReturnValue = rv;
+        }
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallDeleteService()");
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallShutdownServer()
+// Requests server to shutdown itself.
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallShutdownServer(TIptvSmTestConnection aConn )
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallShutdownServer()");
+
+    TInt err = KErrNone;
+
+    if(aConn == EIptvSmTestAsync)
+        {
+        VCXLOGLO1("Async service request");
+        err = iIptvServiceManagementClient->ServerShutdownReq();
+        if(err != KErrNone)
+            {
+            VCXLOGLO2("ServerShutdownReq returned error: %d", err);
+            VCXLOGLO1("<<<CIptvServiceManagementSync::CallShutdownServer");
+            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;
+        err = iIptvServiceManagementClient->ServerShutdown(rv);
+        if(err != KErrNone)
+            {
+            VCXLOGLO2("ServerShutdown returned error: %d", err);
+            rv = EGeneralError;
+            }
+        else
+        if(MIptvServiceManagementClientObserver::ESucceeded != rv)
+           {
+           VCXLOGLO2("ServerShutdown response error: %d", rv);
+           }
+
+        iSyncReturnValue = rv;
+        }
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallShutdownServer()");
+
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallSetUsedIap()
+// Sets used Iap
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallSetUsedIap(TUint32 aIapId,
+                                  TUint32 aServiceId,
+                                  TBool aSetToDefaultForService
+                                  )
+    {
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetUsedIap()");
+    TRespStatus rv = ESucceeded;
+    CIptvNetworkSelection::TRespStatus status = CIptvNetworkSelection::ESucceeded;
+
+    TInt err = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetUsedIap()");
+        return EGeneralError;
+        }
+
+    VCXLOGLO1("Sync service request");
+
+    TInt timeOut = 30;
+
+    if(iRequestRepeatCount <= 0)
+        iRequestRepeatCount = 1; // do once if repeat not set
+    else
+        timeOut = 0; // don't wait server to get ready if repeat is set
+
+    while(iRequestRepeatCount-- > 0)
+        {
+
+        do // try again if server busy
+            {
+
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                TRAP(err, iIptvServiceManagementClient->SetUsedIapL(aIapId, aServiceId, aSetToDefaultForService, status) );
+
+                if(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(err == KErrNone || err != KErrNotReady) break; // request ok
+
+            timeOut -= 2;
+            }
+        while (timeOut > 0);
+
+        if(err != KErrNone)
+            {
+            VCXLOGLO2("SetUsedIapL caused a leave: %d", err);
+            rv = EGeneralError;
+            if(err == KErrNotReady)
+                {
+                VCXLOGLO1(" - previous request still on server. Not ready");
+                }
+            }
+        else
+        if(CIptvNetworkSelection::ESucceeded != status)
+           {
+           VCXLOGLO2("SetUsedIapL response error: %d", status);
+           rv = EGeneralError;
+           }
+        }
+
+    // network selection api specific return values!!
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetUsedIap()");
+    return rv;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallClearUsedIap()
+// Sets used Iap
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallClearUsedIap()
+    {
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallClearUsedIap()");
+    TRespStatus rv = ESucceeded;
+
+    TInt err = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallClearUsedIap()");
+        return EGeneralError;
+        }
+
+    VCXLOGLO1("Sync service request");
+
+    if(iRequestRepeatCount <= 0)
+        iRequestRepeatCount = 1; // do once if repeat not set
+
+    while(iRequestRepeatCount-- > 0)
+        {
+
+        TInt retryCount = 5;
+
+        while(retryCount-- > 0)
+            {
+            err = iIptvServiceManagementClient->ClearUsedIap();
+
+            if(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(err != KErrNone)
+            {
+            VCXLOGLO2("ClearUsedIap returned error: %d", err);
+            rv = EGeneralError;
+            }
+        }
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallClearUsedIap()");
+    return rv;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallGetUsedIap()
+// Gets used iap
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallGetUsedIap(
+                                  TIptvSmTestConnection aConn,
+                                  TUint32 aServiceId,
+                                  TUint32& aIapId
+                                  )
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallGetUsedIap()");
+
+    TInt err = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetUsedIap()");
+        return EGeneralError;
+        }
+
+
+    TRespStatus rv = ESucceeded;
+    TBuf<256> iapName;
+    CIptvNetworkSelection::TRespStatus status = CIptvNetworkSelection::ESucceeded;
+    CIptvNetworkSelection::TConnectionPermission connectionPermission;
+
+    if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;
+
+    // network selection api specific return values!!
+    if(aConn == EIptvSmTestAsync)
+        {
+
+        VCXLOGLO1("Async service request");
+
+        while(iRequestRepeatCount-- > 0)
+            {
+
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                TRAP(err, iIptvServiceManagementClient->GetUsedIapReqL(aServiceId) );
+
+                if(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(err != KErrNone)
+                {
+                VCXLOGLO2("GetUsedIapReqL caused a leave: %d", err);
+                rv = EGeneralError;
+                iSyncReturnValue = rv;
+                iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);
+                return rv;
+                }
+            }
+
+        if(iSpecialAction == EIptvSmCancelNextAsyncRequest)
+            {
+            iIptvServiceManagementClient->CancelRequest();
+            VCXLOGLO1("Canceling request to server.");
+            }
+        else
+            {
+            iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);
+            }
+
+        aIapId = iIapId;
+        }
+    else
+        {
+        VCXLOGLO1("Sync service request");
+        TRespStatus rv = ESucceeded;
+
+        while(iRequestRepeatCount-- > 0)
+            {
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                TRAP(err, iIptvServiceManagementClient->GetUsedIapL(aServiceId,
+                                                    aIapId,
+                                                    iapName ,
+                                                    connectionPermission,
+                                                    status) );
+
+
+                if(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(err != KErrNone)
+                {
+                VCXLOGLO2("GetUsedIapL caused a leave: %d", err);
+                rv = EGeneralError;
+                }
+            else
+            if(CIptvNetworkSelection::ESucceeded != status)
+                {
+                VCXLOGLO2("GetUsedIapL response error: %d", status);
+                rv = EGeneralError;
+                }
+            }
+
+        iSyncReturnValue = rv;
+        }
+
+     if(iSyncReturnValue == ESucceeded)
+        {
+        VCXLOGLO2("aIapId = %d",aIapId);
+        VCXLOGLO2("iapName = %S",&iapName);
+        VCXLOGLO2("connectionPermission = %d",connectionPermission);
+        VCXLOGLO2("status = %d",status);
+        }
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallGetUsedIap()");
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallSetAllIaps()
+// Sets iaplist to all services
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallSetAllIaps(
+                                    TIptvSmTestConnection aConn,
+                                    CIptvIapList& aIapList,
+                                    TBool aIgnoreReadOnlyFlag
+                                    )
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallSetAllIaps()");
+
+    TInt err = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetAllIaps");
+        return EGeneralError;
+        }
+
+
+    TRespStatus rv = ESucceeded;
+    TBuf<255> iapName;
+
+    if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;
+
+    // network selection api specific return values!!
+    if(aConn == EIptvSmTestAsync)
+        {
+        VCXLOGLO1("Async service request");
+
+        while(iRequestRepeatCount-- > 0)
+            {
+            TInt retryCount = 5;
+
+            while(retryCount-- > 0)
+                {
+                TRAP(err, iIptvServiceManagementClient->SetAllIapsReqL(aIapList, aIgnoreReadOnlyFlag) );
+
+                if(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(err != KErrNone)
+                {
+                VCXLOGLO2("SetAllIapsReqL caused a leave: %d", err);
+                VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetAllIaps");
+                rv = EGeneralError;
+                iSyncReturnValue = rv;
+                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(err, iIptvServiceManagementClient->SetAllIapsL(aIapList,
+                                                                aIgnoreReadOnlyFlag,
+                                                                rv) );
+
+                if(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(err != KErrNone)
+                {
+                VCXLOGLO2("SetAllIapsL caused a leave: %d", err);
+                rv = EGeneralError;
+                }
+            else
+            if(MIptvServiceManagementClientObserver::ESucceeded != rv)
+                {
+                VCXLOGLO2("SetAllIapsL response error: %d", rv);
+                rv = EGeneralError;
+                }
+            }
+
+        iSyncReturnValue = rv;
+        }
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetAllIaps()");
+
+    FinishRequest();
+
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallSetConnectionAllowed()
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallSetConnectionAllowed(TBool aConnectionAllowed,
+                                    TUint32 aIapId)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallSetConnectionAllowed");
+
+    TInt err = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetConnectionAllowed.");
+        return EGeneralError;
+        }
+
+    TRespStatus rv = ESucceeded;
+    TBuf<255> iapName;
+    CIptvNetworkSelection::TRespStatus status = CIptvNetworkSelection::ESucceeded;
+
+
+    VCXLOGLO1("Sync service request");
+
+    if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;
+
+    while(iRequestRepeatCount-- > 0)
+        {
+        TInt retryCount = 5;
+
+        while(retryCount-- > 0)
+            {
+            TRAP(err, iIptvServiceManagementClient->SetConnectionAllowedL(aConnectionAllowed, aIapId, status) );
+
+            if(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(err != KErrNone)
+            {
+            VCXLOGLO2("SetConnectionAllowedL caused a leave: %d", err);
+            rv = EGeneralError;
+            }
+        else
+        if(CIptvNetworkSelection::ESucceeded != status)
+            {
+            VCXLOGLO2("SetConnectionAllowedL response error: %d", status);
+            rv = EGeneralError;
+            }
+        }
+
+    iSyncReturnValue = rv;
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallSetConnectionAllowed()");
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CallIsConnectionAllowed()
+// -----------------------------------------------------------------------------
+//
+TRespStatus CIptvServiceManagementSync::CallIsConnectionAllowed(CIptvNetworkSelection::TConnectionPermission &aPermission,
+                                    TUint32 aIapId)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::CallIsConnectionAllowed");
+
+    TInt err = KErrNone;
+
+    err = PrepareForRequest();
+    if(err != KErrNone)
+        {
+        VCXLOGLO1("<<<CIptvServiceManagementSync::CallIsConnectionAllowed()");
+        return EGeneralError;
+        }
+
+    TRespStatus rv = ESucceeded;
+    TBuf<255> iapName;
+    CIptvNetworkSelection::TRespStatus status = CIptvNetworkSelection::ESucceeded;
+
+    VCXLOGLO1("Sync service request");
+
+    if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;
+
+    while(iRequestRepeatCount-- > 0)
+        {
+        TInt retryCount = 5;
+
+        while(retryCount-- > 0)
+            {
+            TRAP(err, iIptvServiceManagementClient->IsConnectionAllowedL(aIapId, aPermission, status) );
+
+            if(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(err != KErrNone)
+            {
+            VCXLOGLO2("IsConnectionAllowedL caused a leave: %d", err);
+            rv = EGeneralError;
+            }
+        else
+        if(CIptvNetworkSelection::ESucceeded != status)
+            {
+            VCXLOGLO2("IsConnectionAllowedL response error: %d", status);
+            rv = EGeneralError;
+            }
+        }
+    iSyncReturnValue = rv;
+
+    FinishRequest();
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::CallIsConnectionAllowed()");
+    return iSyncReturnValue;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::CancelRequest()
+// Cancels an outstanding request.
+// -----------------------------------------------------------------------------
+//
+/*void CIptvServiceManagementSync::CancelRequest()
+    {
+    Cancel() ; // Causes call to DoCancel()
+    }
+*/
+
+/*****************************************************/
+/***************        Utilities   ******************/
+/*****************************************************/
+
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementApiTest::ResponseStatus()
+//
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementSync::ResponseStatus(TUint8 aStatus)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementApiTest::ResponseStatus");
+    VCXLOGLO2("aStatus = %d", aStatus);
+    iSyncReturnValue = static_cast<TRespStatus>(aStatus);
+    VCXLOGLO1("<<<CIptvServiceManagementApiTest::ResponseStatus");
+    return KErrNone;
+    }
+
+/*****************************************************/
+/***************        Callbacks   ******************/
+/*****************************************************/
+
+
+// -----------------------------------------------------------------------------
+// CIptvVodContentApiTest::TimerComplete
+// ?implementation_description
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::TimerComplete(TInt aTimerId, TInt aError)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::TimerComplete");
+    VCXLOGLO2("aTimerId = %d", aTimerId);
+    VCXLOGLO2("aError = %d", aError);
+
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::TimerComplete");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::AddServiceResp()
+// iptv_client_api.dll calls this as a response to AddServiceReq()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::AddServiceResp(TRespStatus aRespStatus)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::AddServiceResp");
+    //Callback ready
+
+    ResponseStatus(aRespStatus);
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::AddServiceResp");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::UpdateServiceResp()
+// iptv_client_api.dll calls this as a response to UpdateServiceReq()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::UpdateServiceResp(TRespStatus aRespStatus)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::UpdateServiceResp");
+   //Callback ready
+
+    ResponseStatus(aRespStatus);
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::UpdateServiceResp");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::DeleteServiceResp()
+// iptv_client_api.dll calls this as a response to DeleteServiceReq()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::DeleteServiceResp(TRespStatus aRespStatus)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::DeleteServiceResp");
+    //Callback ready
+
+    ResponseStatus(aRespStatus);
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::DeleteServiceResp");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::GetServicesResp()
+// iptv_client_api.dll calls this as a response to GetServicesReq()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::GetServicesResp(TRespStatus aRespStatus, CDesC8ArraySeg* aServicesArray)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::GetServicesResp");
+
+// check this
+    ResponseStatus(aRespStatus);
+    iServicesArray = aServicesArray;
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::GetServicesResp");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::ServerShutdownResp()
+// iptv_client_api.dll calls this as a response to ServerShutdownResp()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::ServerShutdownResp(TRespStatus aRespStatus)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::ServerShutdownResp");
+    //Callback ready
+    ResponseStatus(aRespStatus);
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::ServerShutdownResp");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::GetUsedIapResp()
+// iptv_client_api.dll calls this as a response to GetUsedIapResp()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::GetUsedIapResp(TUint32 aIapId,
+                                                const TDesC& aIapName,
+                                                CIptvNetworkSelection::TConnectionPermission aConnectionPermission,
+                                                TBool   aWlanWhenGPRS,
+                                                CIptvNetworkSelection::TRespStatus aRespStatus)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::GetUsedIapResp");
+    //Callback ready
+
+    VCXLOGLO2("aRespStatus = %d", aRespStatus);
+    VCXLOGLO2("aWlanWhenGPRS = %d", aWlanWhenGPRS);
+    TRespStatus respStatus = ESucceeded;
+
+    if(CIptvNetworkSelection::ESucceeded != aRespStatus)
+        {
+        respStatus = EGeneralError;
+        iIapId = 0;
+        }
+    else
+        {
+        respStatus = ESucceeded;
+        iIapId = aIapId;
+        VCXLOGLO2("aIapId = %d",aIapId);
+        VCXLOGLO2("iapName = %S",&aIapName);
+        VCXLOGLO2("connectionPermission = %d",aConnectionPermission);
+        }
+
+    ResponseStatus(respStatus);
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::GetUsedIapResp");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::SetSpecialAction()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::SetSpecialAction(TInt aSpecialAction)
+    {
+    switch(aSpecialAction)
+        {
+        case EIptvSmNoSpecialAction:
+        default:
+            break;
+
+        case EIptvSmWaitNoEvents:
+            iWaitNoEvents = ETrue;
+            break;
+
+        case EIptvSmCancelNextAsyncRequest:
+            iSpecialAction = static_cast<TIptvSmSpecialAction>(aSpecialAction);
+            break;
+        }
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::WaitForProvisioningEvents()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::WaitForProvisioningEvents()
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::WaitForProvisioningEvents");
+
+    iProvisioningWaitGoing = ETrue;
+    do
+        {
+        iProvisioningEventReceived = EFalse;
+
+        iIptvTestTimer->CancelTimer();
+        iIptvTestTimer->After(1000000);
+        iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);
+        }
+        while (iProvisioningEventReceived);
+    iProvisioningWaitGoing = EFalse;
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::WaitForProvisioningEvents");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::RepeatNextRequest()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::RepeatNextRequest(TBool aRequestRepeatCount)
+    {
+    iRequestRepeatCount = aRequestRepeatCount;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::GetRepeatNextRequestCount()
+// -----------------------------------------------------------------------------
+//
+TUint CIptvServiceManagementSync::GetRepeatNextRequestCount()
+    {
+    if(iRequestRepeatCount < 0) iRequestRepeatCount = 1;
+    return iRequestRepeatCount;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::SetExpectedSmEvent()
+// -----------------------------------------------------------------------------//
+void CIptvServiceManagementSync::SetExpectedSmEvent(CIptvSmEvent::TEvent aEvent, TInt aEventCount)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::SetExpectedSmEvent");
+    iEventReceived = EFalse;
+
+    if(iIgnoreEvents)
+        {
+        iWaitingForEvent = EFalse;
+        VCXLOGLO1("Not waiting event flag is set for next request.");
+        }
+    else
+        {
+        VCXLOGLO1("******************************************************************");
+        switch(aEvent)
+            {
+            case CIptvSmEvent::EServiceAdded:
+                {
+                VCXLOGLO1("Event: EServiceAdded");
+                break;
+                }
+
+            case CIptvSmEvent::EServiceModified:
+                {
+                VCXLOGLO1("Event: EServiceModified");
+                break;
+                }
+
+            case CIptvSmEvent::EServiceDeleted:
+                {
+                VCXLOGLO1("Event: EServiceDeleted");
+                break;
+                }
+
+            case CIptvSmEvent::EServiceScheduleModified:
+                {
+                VCXLOGLO1("Event: EServiceScheduleModified");
+                break;
+                }
+
+            default:
+                VCXLOGLO2("Unexpected event: %d", aEvent);
+                break;
+            }
+        
+        if( iExpectedEventCount > 0 )
+            {
+            VCXLOGLO3("Already expecting %d events, adding %d to count.", iExpectedEventCount, aEventCount);
+            iExpectedEventCount += aEventCount;
+            }
+        else
+            {
+            iExpectedEventCount = aEventCount;
+            }
+        VCXLOGLO2("Expected count: %d", iExpectedEventCount);
+        
+        iWaitingForEvent = ETrue;
+        iExpectedSmEvent = aEvent;
+        }
+    VCXLOGLO1("<<<CIptvServiceManagementSync::SetExpectedSmEvent");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::HandleSmEvent()
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceManagementSync::HandleSmEvent(CIptvSmEvent& aEvent)
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::HandleSmEvent");
+    VCXLOGLO1("**********************************************************");
+	VCXLOGLO2("CIptvServiceManagementSync:: iEvent: %d", aEvent.iEvent);
+	VCXLOGLO2("CIptvServiceManagementSync:: iServiceId: %d", aEvent.iServiceId);
+
+    switch(aEvent.iEvent)
+        {
+        case CIptvSmEvent::EServiceAdded:
+            {
+            VCXLOGLO1("Event: EServiceAdded");
+            }
+            break;
+
+        case CIptvSmEvent::EServiceModified:
+            {
+            VCXLOGLO1("Event: EServiceModified");
+            }
+            break;
+
+        case CIptvSmEvent::EServiceDeleted:
+            {
+            VCXLOGLO1("Event: EServiceDeleted");
+            }
+            break;
+
+        case CIptvSmEvent::EServiceScheduleModified:
+            {
+            VCXLOGLO1("Event: EServiceScheduleModified");
+            }
+            break;
+
+		case CIptvSmEvent::EServiceSelectionModified:
+			{
+			VCXLOGLO1("Event: EServiceSelectionModified");
+			}
+			break;
+
+        default:
+            VCXLOGLO1("CIptvServiceManagementSync:: Unexpected event!");
+            break;
+        }
+
+    if(iProvisioningWaitGoing)
+        {
+        VCXLOGLO1("Wait for provisioning events going.");
+        iProvisioningEventReceived = ETrue;
+        VCXLOGLO1("<<<CIptvServiceManagementSync::HandleSmEvent");
+        return;
+        }
+
+    if(iIgnoreEvents)
+        {
+        VCXLOGLO1("Ignoring the event.");
+        VCXLOGLO1("<<<CIptvServiceManagementSync::HandleSmEvent");
+        return;
+        }
+
+    if(iWaitingForEvent)
+        {
+        iEventReceived = ETrue;
+
+        iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStop);
+        if(iIptvTestTimer)
+            {
+            iIptvTestTimer->CancelTimer();
+            }
+
+        if(aEvent.iEvent != iExpectedSmEvent)
+            {
+            // We let modified event go for added event
+            if( !(iExpectedSmEvent == CIptvSmEvent::EServiceAdded && (aEvent.iEvent == CIptvSmEvent::EServiceModified
+                || aEvent.iEvent == CIptvSmEvent::EServiceSelectionModified) ) )
+                {
+                VCXLOGLO2("* ERROR * Received an unexpected event, was waiting for %d. Leaving!", iExpectedSmEvent);
+                User::Leave(KErrUnknown);
+                }
+            else
+                {
+                VCXLOGLO1("Correct event received.");
+                }
+            }
+        
+        --iExpectedEventCount;
+        
+        if( iExpectedEventCount <= 0)
+            {
+            // stop the possible wait for event
+            iWaitingForEvent = EFalse;
+            }
+        }
+    else
+        {
+        VCXLOGLO1("* ERROR * Received an event when not waiting for one. Leaving!");
+        User::Leave(KErrUnknown);
+        }
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::HandleSmEvent");
+    }
+
+void CIptvServiceManagementSync::IncreaseExpectedEventCount( TInt aAmount )
+    {
+    iExpectedEventCount += aAmount;    
+    VCXLOGLO3("Increasing expected event count by %d, now waiting for %d events.", aAmount, iExpectedEventCount);
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::WaitForSmEvent()
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementSync::WaitForSmEvent()
+    {
+    if(iIgnoreEvents) return KErrNone;
+
+    VCXLOGLO1(">>>CIptvServiceManagementSync::WaitForSmEvent");
+    VCXLOGLO1("--------------------------------------------------");
+
+    if(!iWaitingForEvent)
+        {
+        if(!iEventReceived)
+            {
+            VCXLOGLO1("* ERROR * Not waiting for an event and no event received. Test code logic error.");
+            VCXLOGLO1("<<<CIptvServiceManagementSync::WaitForSmEvent");
+            return KErrUnknown;
+            }
+        else
+            {
+            // we got the event before call to this method so no need to wait
+            VCXLOGLO1("Event received before this method call.");
+            VCXLOGLO1("<<<CIptvServiceManagementSync::WaitForSmEvent");
+            return KErrNone;
+            }
+        }
+
+    iIptvTestTimer->After(4 * 1000000);
+    iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);
+
+    if(!iEventReceived)
+        {
+        VCXLOGLO2("* ERROR * Did not receive expected event: %d", iExpectedSmEvent);
+        VCXLOGLO1("<<<CIptvServiceManagementSync::WaitForSmEvent");
+    //  return KErrUnknown;
+        }
+
+    VCXLOGLO2("Event received ok. %d", iExpectedSmEvent);
+    VCXLOGLO1("<<<CIptvServiceManagementSync::WaitForSmEvent");
+    return KErrNone;
+    }
+
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::PrepareForRequest()
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementSync::PrepareForRequest()
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::PrepareForRequest");
+
+    if(iWaitNoEvents)
+        {
+        // special action set and we ignore all events for this request
+        iIgnoreEvents = ETrue;
+        iWaitNoEvents = EFalse;
+        }
+    else
+        {
+        // for default we check the events
+        iIgnoreEvents = EFalse;
+        }
+
+    if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;
+
+    TInt rv = KErrNone;
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::PrepareForRequest");
+    return rv;
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceManagementSync::FinishRequest()
+// -----------------------------------------------------------------------------
+//
+TInt CIptvServiceManagementSync::FinishRequest()
+    {
+    VCXLOGLO1(">>>CIptvServiceManagementSync::FinishRequest");
+
+    iIgnoreEvents = ETrue;
+    iWaitNoEvents = EFalse;
+
+    iSpecialAction = EIptvSmNoSpecialAction;
+
+    VCXLOGLO1("<<<CIptvServiceManagementSync::FinishRequest");
+    return KErrNone;
+    }
+
+
+// End of File