--- /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