1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include "CIptvServiceManagementSync.h"

    23 #include "CIptvServiceManagementClient.h"

    24 #include "CIptvTestUtilities.h"

    25 #include "CIptvService.h"

    26 #include "VCXTestLog.h"

    27 #include "CIptvTestTimer.h"

    28 #include "CIptvTestActiveWait.h"

    29 

    30 #include <f32file.h>

    31 #include <S32FILE.H>

    32 #include <BAUTILS.H>

    33 //#include <CIptvSmEvent.h>

    34 

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

    36 

    37 // -----------------------------------------------------------------------------

    38 // CIptvServiceManagementSync::NewL()

    39 // Two-phased constructor.

    40 // -----------------------------------------------------------------------------

    41 CIptvServiceManagementSync* CIptvServiceManagementSync::NewL()

    42     {

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

    44     CIptvServiceManagementSync* self = new (ELeave) CIptvServiceManagementSync;

    45 

    46     CleanupStack::PushL( self );

    47     self->ConstructL();

    48 

    49     CleanupStack::Pop();

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

    51     return( self ) ;

    52     }

    53 

    54 // -----------------------------------------------------------------------------

    55 // CIptvServiceManagementSync::ConstructL()

    56 // Symbian 2nd phase constructor can leave.

    57 // -----------------------------------------------------------------------------

    58 //

    59 void CIptvServiceManagementSync::ConstructL()

    60     {

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

    62 

    63     iActiveWait = CIptvTestActiveWait::NewL();

    64 

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

    66 

    67     iIptvServiceManagementClient = CIptvServiceManagementClient::NewL(*this);

    68 

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

    70     if(err != KErrNone)

    71         {

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

    73         User::Leave(KErrGeneral);

    74         }

    75 

    76 

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

    78     }

    79 

    80 // -----------------------------------------------------------------------------

    81 // CIptvServiceManagementSync::CIptvServiceManagementSync()

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

    83 // -----------------------------------------------------------------------------

    84 CIptvServiceManagementSync::CIptvServiceManagementSync()

    85     {

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

    87 

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

    89     }

    90 

    91 // -----------------------------------------------------------------------------

    92 // CIptvServiceManagementSync::~CIptvServiceManagementSync()

    93 // Destructor.

    94 // -----------------------------------------------------------------------------

    95 //

    96 CIptvServiceManagementSync::~CIptvServiceManagementSync()

    97     {

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

    99 

   100     if(iServicesArray)

   101         {

   102         iServicesArray->Reset();

   103         delete iServicesArray;

   104         iServicesArray = NULL;

   105         }

   106 

   107     delete iIptvServiceManagementClient;

   108     iIptvServiceManagementClient = NULL;

   109 

   110     delete iIptvTestTimer;

   111     iIptvTestTimer = NULL;

   112 

   113     delete iIptvTestUtilities;

   114     iIptvTestUtilities = NULL;

   115 

   116     delete iActiveWait;

   117     iActiveWait = NULL;

   118 

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

   120     }

   121 

   122 // -----------------------------------------------------------------------------

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

   124 // Adds a service to Service data base.

   125 // -----------------------------------------------------------------------------

   126 //

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

   128     {

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

   130 

   131     TInt err = KErrNone, err2 = KErrNone;

   132 

   133     err = PrepareForRequest();

   134     if(err != KErrNone)

   135         {

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

   137         return EGeneralError;

   138         }

   139 

   140     if(aConn == EIptvSmTestAsync)

   141         {

   142         VCXLOGLO1("Async service request");

   143 

   144         while(iRequestRepeatCount-- > 0)

   145             {

   146             SetExpectedSmEvent(CIptvSmEvent::EServiceAdded, 1);

   147 

   148             TInt retryCount = 5;

   149 

   150             while(retryCount-- > 0)

   151                 {

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

   153 

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

   155                     {

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

   157                     iIptvTestTimer->After(1 * 1000000);

   158                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   159                     }

   160                 else

   161                     {

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

   163                     }

   164                 }

   165 

   166             if(err2 != KErrNone)

   167                 {

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

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

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

   171                 return EGeneralError;

   172                 }

   173             if(err != KErrNone)

   174                 {

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

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

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

   178                 return EGeneralError;

   179                 }

   180           }

   181 

   182         if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   183             {

   184             iIptvServiceManagementClient->CancelRequest();

   185             VCXLOGLO1("Canceling request to server.");

   186             }

   187         else

   188             {

   189             iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   190             if(WaitForSmEvent() != KErrNone)

   191                 {

   192                 iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

   193                 }

   194             }

   195         }

   196     else

   197         {

   198         VCXLOGLO1("Sync service request");

   199         TRespStatus rv = ESucceeded;

   200 

   201         while(iRequestRepeatCount-- > 0)

   202             {

   203             SetExpectedSmEvent(CIptvSmEvent::EServiceAdded, 1);

   204 

   205             TInt retryCount = 5;

   206 

   207             while(retryCount-- > 0)

   208                 {

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

   210 

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

   212                     {

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

   214                     iIptvTestTimer->After(1 * 1000000);

   215                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   216                     }

   217                 else

   218                     {

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

   220                     }

   221                 }

   222 

   223             if(err2 != KErrNone)

   224                 {

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

   226                 rv = EGeneralError;

   227                 }

   228             else

   229             if(err != KErrNone)

   230                 {

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

   232                 rv = EGeneralError;

   233                 }

   234             else

   235             if(MIptvServiceManagementClientObserver::ESucceeded != rv)

   236                {

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

   238                }

   239             else

   240             if(WaitForSmEvent() != KErrNone)

   241                 {

   242                 iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

   243                 }

   244             }

   245 

   246         iSyncReturnValue = rv;

   247         }

   248 

   249     FinishRequest();

   250 

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

   252     return iSyncReturnValue;

   253     }

   254 

   255 // -----------------------------------------------------------------------------

   256 // CIptvServiceManagementSync::UpdateServiceReq()

   257 // Updates a service to Service data base.

   258 // -----------------------------------------------------------------------------

   259 //

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

   261     {

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

   263 

   264     TInt err = KErrNone, err2 = KErrNone;

   265 

   266     err = PrepareForRequest();

   267     if(err != KErrNone)

   268         {

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

   270         return EGeneralError;

   271         }

   272 

   273     if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;

   274 

   275     if(aConn == EIptvSmTestAsync)

   276         {

   277         VCXLOGLO1("Async service request");

   278 

   279         while(iRequestRepeatCount-- > 0)

   280             {

   281             SetExpectedSmEvent(aExpectedEvent, 1);

   282 

   283             TInt retryCount = 5;

   284 

   285             while(retryCount-- > 0)

   286                 {

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

   288 

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

   290                     {

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

   292                     iIptvTestTimer->After(1 * 1000000);

   293                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   294                     }

   295                 else

   296                     {

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

   298                     }

   299                 }

   300 

   301             if(err2 != KErrNone)

   302                 {

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

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

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

   306                 return EGeneralError;

   307                 }

   308             if(err != KErrNone)

   309                 {

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

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

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

   313                 return EGeneralError;

   314                 }

   315             }

   316 

   317         if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   318             {

   319             iIptvServiceManagementClient->CancelRequest();

   320             VCXLOGLO1("Canceling request to server.");

   321             }

   322         else

   323             {

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

   325             if(WaitForSmEvent() != KErrNone)

   326                 {

   327                 iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

   328                 }

   329             }

   330 

   331         }

   332     else

   333         {

   334         VCXLOGLO1("Sync service request");

   335         TRespStatus rv = ESucceeded;

   336 

   337         while(iRequestRepeatCount-- > 0)

   338             {

   339             SetExpectedSmEvent(aExpectedEvent, 1);

   340 

   341             TInt retryCount = 5;

   342 

   343             while(retryCount-- > 0)

   344                 {

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

   346 

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

   348                     {

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

   350                     iIptvTestTimer->After(1 * 1000000);

   351                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   352                     }

   353                 else

   354                     {

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

   356                     }

   357                 }

   358 

   359             if(err2 != KErrNone)

   360                 {

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

   362                 rv = EGeneralError;

   363                 }

   364             else

   365             if(err != KErrNone)

   366                 {

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

   368                 rv = EGeneralError;

   369                 }

   370             else

   371             if(MIptvServiceManagementClientObserver::ESucceeded != rv)

   372                {

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

   374                }

   375             else

   376             if(WaitForSmEvent() != KErrNone)

   377                 {

   378                 iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

   379                 }

   380 

   381             }

   382 

   383         iSyncReturnValue = rv;

   384         }

   385 

   386     FinishRequest();

   387 

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

   389     return iSyncReturnValue;

   390     }

   391 

   392 // -----------------------------------------------------------------------------

   393 // CIptvServiceManagementSync::CallGetServices()

   394 // Gets service entries from Services database.

   395 // -----------------------------------------------------------------------------

   396 //

   397 TRespStatus CIptvServiceManagementSync::CallGetServices(

   398                                     TIptvSmTestConnection aConn,

   399                                     TUint32 aStartId,

   400                                     TUint32 aEndId,

   401                                     CDesC8ArraySeg** aServicesArray

   402                                     )

   403     {

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

   405 

   406     TInt err = KErrNone, err2 = KErrNone;

   407 

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

   409     if(iServicesArray)

   410         {

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

   412         iServicesArray->Reset();

   413         delete iServicesArray;

   414         iServicesArray = NULL;

   415         }

   416 

   417     err = PrepareForRequest();

   418     if(err != KErrNone)

   419         {

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

   421         return EGeneralError;

   422         }

   423 

   424     if(aConn == EIptvSmTestAsync)

   425         {

   426         VCXLOGLO1("Async service request");

   427 

   428         while(iRequestRepeatCount-- > 0)

   429             {

   430 

   431             TInt retryCount = 5;

   432 

   433             while(retryCount-- > 0)

   434                 {

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

   436 

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

   438                     {

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

   440                     iIptvTestTimer->After(1 * 1000000);

   441                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   442                     }

   443                 else

   444                     {

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

   446                     }

   447                 }

   448 

   449             if(err2 != KErrNone)

   450                 {

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

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

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

   454                 return EGeneralError;

   455                 }

   456             if(err != KErrNone)

   457                 {

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

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

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

   461                 return EGeneralError;

   462                 }

   463 

   464             }

   465         if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   466             {

   467             iIptvServiceManagementClient->CancelRequest();

   468             VCXLOGLO1("Canceling request to server.");

   469             }

   470         else

   471             {

   472             iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   473             }

   474         }

   475     else

   476         {

   477         VCXLOGLO1("Sync service request");

   478         TRespStatus rv = ESucceeded;

   479 

   480         while(iRequestRepeatCount-- > 0)

   481             {

   482             TInt retryCount = 5;

   483 

   484             while(retryCount-- > 0)

   485                 {

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

   487 

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

   489                     {

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

   491                     iIptvTestTimer->After(1 * 1000000);

   492                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   493                     }

   494                 else

   495                     {

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

   497                     }

   498                 }

   499 

   500             if(err2 != KErrNone)

   501                 {

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

   503                 rv = EGeneralError;

   504                 }

   505             else

   506             if(err != KErrNone)

   507                 {

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

   509                 rv = EGeneralError;

   510                 }

   511             else

   512             if(MIptvServiceManagementClientObserver::ESucceeded != rv)

   513                {

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

   515                }

   516             }

   517 

   518         iSyncReturnValue = rv;

   519         }

   520 

   521     if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   522         {

   523         if(iServicesArray == NULL)

   524             {

   525             iServicesArray  = new (ELeave) CDesC8ArraySeg(10);

   526             }

   527         }

   528 

   529     FinishRequest();

   530 

   531     *aServicesArray = iServicesArray;

   532     iServicesArray = NULL; // we don't need this anymore, ownership moves

   533 

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

   535     return iSyncReturnValue;

   536     }

   537 

   538 // -----------------------------------------------------------------------------

   539 // CIptvServiceManagementSync::GetAllSelectedServicesReq()

   540 // Requests all filtered services from the database.

   541 // -----------------------------------------------------------------------------

   542 //

   543 TRespStatus CIptvServiceManagementSync::CallGetServicesFiltered(

   544                                             TUint32 aSearchLimitFlags,

   545                                             CIptvServiceManagementClient::TOrder aOrder,

   546                                             TIptvSmTestConnection aConn,

   547                                             CDesC8ArraySeg** aServicesArray

   548                                             )

   549     {

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

   551 

   552     TInt err = KErrNone, err2 = KErrNone;

   553 

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

   555     if(iServicesArray)

   556         {

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

   558         iServicesArray->Reset();

   559         delete iServicesArray;

   560         iServicesArray = NULL;

   561         }

   562 

   563     err = PrepareForRequest();

   564     if(err != KErrNone)

   565         {

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

   567         return EGeneralError;

   568         }

   569 

   570     if(aConn == EIptvSmTestAsync)

   571         {

   572         VCXLOGLO1("Async service request");

   573 

   574         while(iRequestRepeatCount-- > 0)

   575             {

   576             TInt retryCount = 5;

   577 

   578             while(retryCount-- > 0)

   579                 {

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

   581 

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

   583                     {

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

   585                     iIptvTestTimer->After(1 * 1000000);

   586                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   587                     }

   588                 else

   589                     {

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

   591                     }

   592                 }

   593 

   594             if(err2 != KErrNone)

   595                 {

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

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

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

   599                 return EGeneralError;

   600                 }

   601             if(err != KErrNone)

   602                 {

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

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

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

   606                 return EGeneralError;

   607                 }

   608             }

   609 

   610         if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   611             {

   612             //removed: iIptvTestTimer->After(5 * 1000000);

   613 

   614             iIptvServiceManagementClient->CancelRequest();

   615             VCXLOGLO1("Canceling request to server.");

   616             }

   617         else

   618             {

   619             iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   620             }

   621 

   622         }

   623     else

   624         {

   625         VCXLOGLO1("Sync service request");

   626 

   627         TRespStatus rv = ESucceeded;

   628 

   629         while(iRequestRepeatCount-- > 0)

   630             {

   631             TInt retryCount = 5;

   632 

   633             while(retryCount-- > 0)

   634                 {

   635                 TRAP(err2, err = iIptvServiceManagementClient->GetServicesL(aSearchLimitFlags, aOrder, iServicesArray, rv)  );

   636 

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

   638                     {

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

   640                     iIptvTestTimer->After(1 * 1000000);

   641                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   642                     }

   643                 else

   644                     {

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

   646                     }

   647                 }

   648 

   649             if(err2 != KErrNone)

   650                 {

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

   652                 rv = EGeneralError;

   653                 }

   654             if(err != KErrNone)

   655                 {

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

   657                 rv = EGeneralError;

   658                 }

   659             }

   660 

   661             iSyncReturnValue = rv;

   662         }

   663 

   664 

   665     if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   666         {

   667         if(iServicesArray == NULL)

   668             {

   669             iServicesArray  = new (ELeave) CDesC8ArraySeg(10);

   670             }

   671         }

   672 

   673     *aServicesArray = iServicesArray;

   674     iServicesArray = NULL; // ownership moves

   675 

   676     FinishRequest();

   677 

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

   679     return iSyncReturnValue;

   680     }

   681 

   682 // -----------------------------------------------------------------------------

   683 // CIptvServiceManagementSync::GetGetServicesByProviderId()

   684 // Requests all filtered services from the database.

   685 // -----------------------------------------------------------------------------

   686 //

   687 TRespStatus CIptvServiceManagementSync::CallGetServicesByProviderId(

   688                                             TDesC& aProviderId,

   689                                             CIptvServices& aServices

   690                                             )

   691     {

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

   693 

   694     TInt err = KErrNone, err2 = KErrNone;

   695 

   696     err = PrepareForRequest();

   697     if(err != KErrNone)

   698         {

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

   700         return EGeneralError;

   701         }

   702 

   703     VCXLOGLO1("Sync service request");

   704 

   705     TInt retryCount = 5;

   706 

   707     while(retryCount-- > 0)

   708         {

   709         TRAP(err2, err = iIptvServiceManagementClient->GetServicesL(aProviderId, aServices)  );

   710 

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

   712             {

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

   714             iIptvTestTimer->After(1 * 1000000);

   715             iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   716             }

   717         else

   718             {

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

   720             }

   721         }

   722 

   723     if(err2 != KErrNone)

   724         {

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

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

   727         return EGeneralError;

   728         }

   729     if(err != KErrNone)

   730         {

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

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

   733         return EGeneralError;

   734         }

   735 

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

   737 

   738     FinishRequest();

   739 

   740     return iSyncReturnValue;

   741     }

   742 

   743 

   744 // -----------------------------------------------------------------------------

   745 // CIptvServiceManagementSync::CallDeleteService()

   746 // Deletes a service from the database.

   747 // -----------------------------------------------------------------------------

   748 //

   749 TRespStatus CIptvServiceManagementSync::CallDeleteService(TIptvSmTestConnection aConn, TUint32 aId)

   750     {

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

   752 

   753     TInt err = KErrNone, err2 = KErrNone;

   754 

   755     err = PrepareForRequest();

   756     if(err != KErrNone)

   757         {

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

   759         return EGeneralError;

   760         }

   761 

   762     if(aConn == EIptvSmTestAsync)

   763         {

   764         VCXLOGLO1("Async service request");

   765 

   766         while(iRequestRepeatCount-- > 0)

   767             {

   768             TInt retryCount = 5;

   769 

   770             while(retryCount-- > 0)

   771                 {

   772                 SetExpectedSmEvent(CIptvSmEvent::EServiceDeleted, 1);

   773                 TRAP(err2, err = iIptvServiceManagementClient->DeleteServiceReqL(aId) );

   774                 iIptvTestTimer->After(2 * 1000000);

   775                 iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   776 

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

   778                     {

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

   780                     iIptvTestTimer->After(1 * 1000000);

   781                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   782                     }

   783                 else

   784                     {

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

   786                     }

   787                 }

   788 

   789             if(err2 != KErrNone)

   790                 {

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

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

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

   794                 return EGeneralError;

   795                 }

   796             if(err != KErrNone)

   797                 {

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

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

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

   801                 return EGeneralError;

   802                 }

   803             }

   804 

   805         if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   806             {

   807             iIptvServiceManagementClient->CancelRequest();

   808             VCXLOGLO1("Canceling request to server.");

   809             }

   810         else

   811             {

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

   813             if(WaitForSmEvent() != KErrNone)

   814                 {

   815                 iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

   816                 }

   817             }

   818         }

   819     else

   820         {

   821         VCXLOGLO1("Sync service request");

   822         TRespStatus rv = ESucceeded;

   823 

   824         while(iRequestRepeatCount-- > 0)

   825             {

   826             SetExpectedSmEvent(CIptvSmEvent::EServiceDeleted, 1);

   827 

   828             TInt retryCount = 5;

   829 

   830             while(retryCount-- > 0)

   831                 {

   832                 TRAP(err2, err = iIptvServiceManagementClient->DeleteServiceL(aId + iRequestRepeatCount, rv) );

   833 

   834                 VCXLOGLO1("Request done.");

   835 

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

   837                     {

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

   839                     iIptvTestTimer->After(1 * 1000000);

   840                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   841                     }

   842                 else

   843                     {

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

   845                     }

   846                 }

   847 

   848             VCXLOGLO1("Checking errors.");

   849 

   850             if(err2 != KErrNone)

   851                 {

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

   853                 rv = EGeneralError;

   854                 }

   855             else

   856             if(err != KErrNone)

   857                 {

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

   859                 rv = EGeneralError;

   860                 }

   861             else

   862             if(MIptvServiceManagementClientObserver::ESucceeded != rv)

   863                {

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

   865                }

   866             else

   867             if(WaitForSmEvent() != KErrNone)

   868                 {

   869                 iSyncReturnValue = MIptvServiceManagementClientObserver::EGeneralError;

   870                 }

   871             }

   872         iSyncReturnValue = rv;

   873         }

   874 

   875     FinishRequest();

   876 

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

   878     return iSyncReturnValue;

   879     }

   880 

   881 // -----------------------------------------------------------------------------

   882 // CIptvServiceManagementSync::CallShutdownServer()

   883 // Requests server to shutdown itself.

   884 // -----------------------------------------------------------------------------

   885 //

   886 TRespStatus CIptvServiceManagementSync::CallShutdownServer(TIptvSmTestConnection aConn )

   887     {

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

   889 

   890     TInt err = KErrNone;

   891 

   892     if(aConn == EIptvSmTestAsync)

   893         {

   894         VCXLOGLO1("Async service request");

   895         err = iIptvServiceManagementClient->ServerShutdownReq();

   896         if(err != KErrNone)

   897             {

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

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

   900             return EGeneralError;

   901             }

   902 

   903         if(iSpecialAction == EIptvSmCancelNextAsyncRequest)

   904             {

   905             iIptvServiceManagementClient->CancelRequest();

   906             VCXLOGLO1("Canceling request to server.");

   907             }

   908         else

   909             {

   910             iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   911             }

   912 

   913         }

   914     else

   915         {

   916         VCXLOGLO1("Sync service request");

   917         TRespStatus rv = ESucceeded;

   918         err = iIptvServiceManagementClient->ServerShutdown(rv);

   919         if(err != KErrNone)

   920             {

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

   922             rv = EGeneralError;

   923             }

   924         else

   925         if(MIptvServiceManagementClientObserver::ESucceeded != rv)

   926            {

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

   928            }

   929 

   930         iSyncReturnValue = rv;

   931         }

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

   933 

   934     return iSyncReturnValue;

   935     }

   936 

   937 // -----------------------------------------------------------------------------

   938 // CIptvServiceManagementSync::CallSetUsedIap()

   939 // Sets used Iap

   940 // -----------------------------------------------------------------------------

   941 //

   942 TRespStatus CIptvServiceManagementSync::CallSetUsedIap(TUint32 aIapId,

   943                                   TUint32 aServiceId,

   944                                   TBool aSetToDefaultForService

   945                                   )

   946     {

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

   948     TRespStatus rv = ESucceeded;

   949     CIptvNetworkSelection::TRespStatus status = CIptvNetworkSelection::ESucceeded;

   950 

   951     TInt err = KErrNone;

   952 

   953     err = PrepareForRequest();

   954     if(err != KErrNone)

   955         {

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

   957         return EGeneralError;

   958         }

   959 

   960     VCXLOGLO1("Sync service request");

   961 

   962     TInt timeOut = 30;

   963 

   964     if(iRequestRepeatCount <= 0)

   965         iRequestRepeatCount = 1; // do once if repeat not set

   966     else

   967         timeOut = 0; // don't wait server to get ready if repeat is set

   968 

   969     while(iRequestRepeatCount-- > 0)

   970         {

   971 

   972         do // try again if server busy

   973             {

   974 

   975             TInt retryCount = 5;

   976 

   977             while(retryCount-- > 0)

   978                 {

   979                 TRAP(err, iIptvServiceManagementClient->SetUsedIapL(aIapId, aServiceId, aSetToDefaultForService, status) );

   980 

   981                 if(err == KErrNotReady)

   982                     {

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

   984                     iIptvTestTimer->After(1 * 1000000);

   985                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

   986                     }

   987                 else

   988                     {

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

   990                     }

   991                 }

   992 

   993             if(err == KErrNone || err != KErrNotReady) break; // request ok

   994 

   995             timeOut -= 2;

   996             }

   997         while (timeOut > 0);

   998 

   999         if(err != KErrNone)

  1000             {

  1001             VCXLOGLO2("SetUsedIapL caused a leave: %d", err);

  1002             rv = EGeneralError;

  1003             if(err == KErrNotReady)

  1004                 {

  1005                 VCXLOGLO1(" - previous request still on server. Not ready");

  1006                 }

  1007             }

  1008         else

  1009         if(CIptvNetworkSelection::ESucceeded != status)

  1010            {

  1011            VCXLOGLO2("SetUsedIapL response error: %d", status);

  1012            rv = EGeneralError;

  1013            }

  1014         }

  1015 

  1016     // network selection api specific return values!!

  1017 

  1018     FinishRequest();

  1019 

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

  1021     return rv;

  1022     }

  1023 

  1024 // -----------------------------------------------------------------------------

  1025 // CIptvServiceManagementSync::CallClearUsedIap()

  1026 // Sets used Iap

  1027 // -----------------------------------------------------------------------------

  1028 //

  1029 TRespStatus CIptvServiceManagementSync::CallClearUsedIap()

  1030     {

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

  1032     TRespStatus rv = ESucceeded;

  1033 

  1034     TInt err = KErrNone;

  1035 

  1036     err = PrepareForRequest();

  1037     if(err != KErrNone)

  1038         {

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

  1040         return EGeneralError;

  1041         }

  1042 

  1043     VCXLOGLO1("Sync service request");

  1044 

  1045     if(iRequestRepeatCount <= 0)

  1046         iRequestRepeatCount = 1; // do once if repeat not set

  1047 

  1048     while(iRequestRepeatCount-- > 0)

  1049         {

  1050 

  1051         TInt retryCount = 5;

  1052 

  1053         while(retryCount-- > 0)

  1054             {

  1055             err = iIptvServiceManagementClient->ClearUsedIap();

  1056 

  1057             if(err == KErrNotReady)

  1058                 {

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

  1060                 iIptvTestTimer->After(1 * 1000000);

  1061                 iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

  1062                 }

  1063             else

  1064                 {

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

  1066                 }

  1067             }

  1068 

  1069         if(err != KErrNone)

  1070             {

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

  1072             rv = EGeneralError;

  1073             }

  1074         }

  1075 

  1076     FinishRequest();

  1077 

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

  1079     return rv;

  1080     }

  1081 

  1082 // -----------------------------------------------------------------------------

  1083 // CIptvServiceManagementSync::CallGetUsedIap()

  1084 // Gets used iap

  1085 // -----------------------------------------------------------------------------

  1086 //

  1087 TRespStatus CIptvServiceManagementSync::CallGetUsedIap(

  1088                                   TIptvSmTestConnection aConn,

  1089                                   TUint32 aServiceId,

  1090                                   TUint32& aIapId

  1091                                   )

  1092     {

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

  1094 

  1095     TInt err = KErrNone;

  1096 

  1097     err = PrepareForRequest();

  1098     if(err != KErrNone)

  1099         {

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

  1101         return EGeneralError;

  1102         }

  1103 

  1104 

  1105     TRespStatus rv = ESucceeded;

  1106     TBuf<256> iapName;

  1107     CIptvNetworkSelection::TRespStatus status = CIptvNetworkSelection::ESucceeded;

  1108     CIptvNetworkSelection::TConnectionPermission connectionPermission;

  1109 

  1110     if(iRequestRepeatCount <= 0) iRequestRepeatCount = 1;

  1111 

  1112     // network selection api specific return values!!

  1113     if(aConn == EIptvSmTestAsync)

  1114         {

  1115 

  1116         VCXLOGLO1("Async service request");

  1117 

  1118         while(iRequestRepeatCount-- > 0)

  1119             {

  1120 

  1121             TInt retryCount = 5;

  1122 

  1123             while(retryCount-- > 0)

  1124                 {

  1125                 TRAP(err, iIptvServiceManagementClient->GetUsedIapReqL(aServiceId) );

  1126 

  1127                 if(err == KErrNotReady)

  1128                     {

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

  1130                     iIptvTestTimer->After(1 * 1000000);

  1131                     iActiveWait->ActiveWait(CIptvTestActiveWait::EActiveWaitStart);

  1132                     }

  1133                 else

  1134                     {

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