1 /*

     2 * Copyright (c) 2005-2006 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:    Handles messages from client*

    15 */

    16 

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include "IptvDebug.h"

    23 #include <bautils.h>

    24 

    25 #include "IptvClientServerCommon.h"

    26 #include "CIptvSmEvent.h"

    27 #include "CIptvService.h"

    28 #include "CIptvServices.h"

    29 #include "CIptvServiceMsgHandler.h"

    30 #include "CIptvServer.h"

    31 #include "MIptvServiceManagementClientObserver.h"

    32 #include "CIptvEpgManagerImpl.h"

    33 #include "CIptvEpgSession.h"

    34 #include "CIptvEventGenerator.h"

    35 

    36 // EXTERNAL DATA STRUCTURES

    37 // EXTERNAL FUNCTION PROTOTYPES  

    38 // CONSTANTS

    39 // MACROS

    40 // LOCAL CONSTANTS AND MACROS

    41 // MODULE DATA STRUCTURES

    42 // LOCAL FUNCTION PROTOTYPES

    43 

    44 // FORWARD DECLARATIONS

    45 

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

    47 

    48 // -----------------------------------------------------------------------------

    49 // CIptvServiceMsgHandler::CIptvServiceMsgHandler

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

    51 // might leave.

    52 // -----------------------------------------------------------------------------

    53 //

    54 CIptvServiceMsgHandler::CIptvServiceMsgHandler(CIptvServer& aServer)

    55 : iServer(aServer)

    56     {

    57     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::CIptvServiceMsgHandler()");

    58     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::CIptvServiceMsgHandler() exit");

    59     }

    60 

    61 // -----------------------------------------------------------------------------

    62 // CIptvServiceMsgHandler::ConstructL

    63 // Symbian 2nd phase constructor can leave.

    64 // -----------------------------------------------------------------------------

    65 //

    66 void CIptvServiceMsgHandler::ConstructL()

    67     {

    68     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::ConstructL()");

    69 

    70     CIptvSmEvent* eventProto = CIptvSmEvent::NewL();

    71     CleanupStack::PushL(eventProto); // 1->

    72     iEventGenerator = CIptvEventGenerator::NewL(eventProto /* ownership moves */);

    73     CleanupStack::Pop(eventProto); // <-1

    74     iServer.iServiceManager->RegisterObserver(this);

    75 

    76     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::ConstructL() exit");

    77     }

    78 

    79 // -----------------------------------------------------------------------------

    80 // CIptvServiceMsgHandler::NewL

    81 // Two-phased constructor.

    82 // -----------------------------------------------------------------------------

    83 //

    84 CIptvServiceMsgHandler* CIptvServiceMsgHandler::NewL(CIptvServer& aServer)

    85     {

    86     CIptvServiceMsgHandler* self = new( ELeave ) CIptvServiceMsgHandler(aServer);

    87     

    88     CleanupStack::PushL( self );

    89     self->ConstructL();

    90     CleanupStack::Pop(self);

    91 

    92     return self;

    93     }

    94 

    95     

    96 // Destructor

    97 CIptvServiceMsgHandler::~CIptvServiceMsgHandler()

    98     {

    99     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::~CIptvServiceMsgHandler()");

   100     delete iServicesDataRespIpcMsg;

   101     delete iServicesSizeRespIpcMsg;

   102     delete iServices;

   103     delete iEventGenerator;

   104     iServer.iServiceManager->DeRegisterObserver(this);

   105     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::~CIptvServiceMsgHandler() exit");

   106     }

   107 

   108 // ------------------------------------------------------------------

   109 // CIptvServiceMsgHandler::HandleServiceManagerMsgL

   110 // Handles messages meant for Service Manager.

   111 // ------------------------------------------------------------------

   112 //

   113 void CIptvServiceMsgHandler::HandleServiceManagerMsgL(const RMessage2& aMessage)

   114     {

   115     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleServiceManagerMsgL()");

   116 

   117     switch(aMessage.Function())

   118         {

   119         case EIptvEngineSmGetServicesSizeReq: //get services from database, return size

   120             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesSizeReq");

   121             HandleGetServicesSizeReqL(aMessage);

   122             break;

   123             

   124         case EIptvEngineSmGetServicesDataReq: //get services from database, return data

   125             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesDataReq");

   126             HandleGetServicesDataReqL(aMessage);

   127             break;

   128         	

   129         case EIptvEngineSmGetServicesUsingIdSizeReq:

   130             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesUsingIdSizeReq");

   131             HandleGetServicesUsingIdSizeReqL(aMessage);

   132             break;

   133             

   134         case EIptvEngineSmGetServicesUsingIdDataReq:

   135             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesUsingIdDataReq");

   136             HandleGetServicesUsingIdDataReqL(aMessage);

   137             break;

   138         	        	        	        	        	

   139         case EIptvEngineSmAddServiceReq:

   140             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmAddServiceReq");

   141             HandleAddServiceReqL(aMessage);

   142             break;

   143         	

   144         case EIptvEngineSmDeleteServiceReq:

   145             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmDeleteServiceReq");

   146             HandleDeleteServiceReqL(aMessage);

   147             break;

   148     	

   149         case EIptvEngineSmUpdateServiceReq:

   150             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmUpdateServiceReq");

   151             HandleUpdateServiceReqL(aMessage);

   152             break;

   153         

   154         case EIptvEngineSmGetServiceSizeUsingProviderId:

   155             HandleGetServiceSizeUsingProviderIdL(aMessage);

   156             break;

   157             

   158         case EIptvEngineSmGetServiceDataUsingProviderId:

   159             HandleGetServiceDataUsingProviderIdL(aMessage);

   160             break;

   161     

   162         case EIptvEngineSmCancel:

   163             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmCancel");

   164             //All messages are currently processed synchronously in server side -> no need to do anything

   165             aMessage.Complete(KErrNone);

   166             break;

   167         

   168         case EIptvEngineSmGetEventSizeReq:

   169             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineGetEventSizeReq");

   170             if (iEventGenerator)

   171                 {

   172                 iEventGenerator->SizeRequestL(aMessage);

   173                 }

   174             break;

   175             

   176         case EIptvEngineSmGetEventData:

   177             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineGetEventData");

   178             if (iEventGenerator)

   179                 {

   180                 iEventGenerator->DataRequestL(aMessage);

   181                 }

   182             break;

   183 

   184         case EIptvEngineSmCancelGetEventSizeReq:

   185             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmCancelGetEventSizeReq");

   186             delete iEventGenerator;

   187             iEventGenerator = NULL;

   188             aMessage.Complete(KErrNone);

   189             break;

   190 

   191         }

   192     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleServiceManagerMsg() exit");

   193     }

   194 

   195 // ------------------------------------------------------------------

   196 // CIptvServiceMsgHandler::HandleGetServicesSizeReqL

   197 // ------------------------------------------------------------------

   198 //

   199 void CIptvServiceMsgHandler::HandleGetServicesSizeReqL(const RMessage2& aMessage)

   200     {

   201     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesSizeReqL()");

   202                 

   203     //fetch data from the client address space

   204     TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);

   205     HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);

   206     CleanupStack::PushL(ipcMsg);

   207     ipcMsg->Des().Zero();

   208     TPtr8 ipcMsgPtr(ipcMsg->Des());

   209     aMessage.ReadL(0, ipcMsgPtr, 0);

   210 

   211     RDesReadStream readStream;

   212     readStream.Open(ipcMsgPtr);

   213     CleanupClosePushL( readStream );

   214     //See CIptvServiceManagementClient::TSearchLimitFlag

   215     TUint32 searchLimitFlags;

   216     TUint8 order;

   217     

   218     searchLimitFlags = readStream.ReadUint32L();

   219     order            = readStream.ReadUint8L();

   220     

   221     CleanupStack::PopAndDestroy( &readStream );

   222     CleanupStack::PopAndDestroy(ipcMsg);

   223     

   224     if ( iServices )

   225         {

   226         delete iServices;

   227         iServices = NULL;

   228         }

   229                 

   230     TRAPD(err, iServices = iServer.iServiceManager->GetServicesL(searchLimitFlags,

   231                                                                 static_cast<CIptvServiceManagementClient::TOrder>(order),

   232                                                                 0 /* 0 = use latest version */));

   233     if(err != KErrNone)

   234         {

   235         IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: Failed to get services from DB!");

   236 

   237         SendStatusRespL( aMessage,

   238                          MIptvServiceManagementClientObserver::EGeneralError,

   239                          err );

   240         }

   241     else

   242         {        

   243 	      //build iServicesSizeRespIpcMsg and iServicesDataRespIpcMsg from iServicesArray

   244         BuildServiceIpcMsgRespsL();

   245 				

   246         aMessage.WriteL(0, iServicesSizeRespIpcMsg->Des(), 0);

   247 

   248         aMessage.Complete(err);

   249 		

   250         delete iServicesSizeRespIpcMsg;

   251         iServicesSizeRespIpcMsg = NULL;

   252         }

   253         

   254     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesSizeReqL() exit");

   255     }

   256 

   257 // ---------------------------------------------------------------------------

   258 // CIptvServiceMsgHandler::HandleGetServicesDataReqL

   259 // ---------------------------------------------------------------------------

   260 //	    

   261 void CIptvServiceMsgHandler::HandleGetServicesDataReqL(const RMessage2& aMessage)

   262     {

   263     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesDataReqL()");

   264 

   265     aMessage.WriteL(0, iServicesDataRespIpcMsg->Des(), 0);

   266 

   267     aMessage.Complete(KErrNone);

   268         	

   269     delete iServicesDataRespIpcMsg;

   270     iServicesDataRespIpcMsg = NULL;

   271 

   272     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesDataReqL() exit");

   273     }

   274 

   275 // ---------------------------------------------------------------------------

   276 // CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL

   277 // ---------------------------------------------------------------------------

   278 //	

   279 void CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL(const RMessage2& aMessage)

   280     {

   281     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL()");

   282 

   283     //fetch data from the client address space

   284     TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);

   285     HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);

   286     CleanupStack::PushL(ipcMsg);  

   287     ipcMsg->Des().Zero();

   288     TPtr8 ipcMsgPtr(ipcMsg->Des());

   289     aMessage.ReadL(0, ipcMsgPtr, 0);

   290 

   291     //get start and end indexes

   292     TUint32 startIndex;

   293     TUint32 endIndex;

   294 

   295     RDesReadStream readStream;

   296     readStream.Open(ipcMsgPtr);

   297     CleanupClosePushL( readStream );

   298     startIndex = readStream.ReadUint32L();

   299     endIndex   = readStream.ReadUint32L();

   300     CleanupStack::PopAndDestroy( &readStream );

   301 

   302     //Make the db query

   303     if(iServices)

   304         {

   305         delete iServices;

   306         iServices = NULL;

   307         }        

   308     TRAPD(err, iServices = iServer.iServiceManager->GetServicesUsingIdL(startIndex, endIndex, ETrue /* do open/close */));

   309 

   310     if(err != KErrNone)

   311         {

   312         IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: Failed to get services from DB!");

   313 

   314         delete iServices;

   315         iServices = NULL;

   316         SendStatusRespL( aMessage,

   317                          MIptvServiceManagementClientObserver::EGeneralError,

   318                          err );

   319         }

   320     else

   321         {

   322         //build iServicesSizeRespIpcMsg and iServicesDataRespIpcMsg from iServices

   323         BuildServiceIpcMsgRespsL();

   324 

   325         aMessage.WriteL(0, iServicesSizeRespIpcMsg->Des(), 0);

   326         aMessage.Complete(err);

   327     

   328         delete iServicesSizeRespIpcMsg;

   329         iServicesSizeRespIpcMsg = NULL;

   330         }

   331         

   332     CleanupStack::PopAndDestroy(ipcMsg);

   333     

   334     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL() exit");

   335     }

   336 

   337 // ---------------------------------------------------------------------------

   338 // CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL

   339 // ---------------------------------------------------------------------------

   340 //	

   341 void CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL(const RMessage2& aMessage)

   342     {

   343     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL()");

   344 

   345     aMessage.WriteL(0, iServicesDataRespIpcMsg->Des(), 0);

   346     aMessage.Complete(KErrNone);

   347     

   348     delete iServicesDataRespIpcMsg;

   349     iServicesDataRespIpcMsg = NULL;

   350     

   351     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL() exit");

   352     }

   353     

   354 // ---------------------------------------------------------------------------

   355 // Used for EIptvEngineGetServicesSizeReq and EIptvEngineGetServicesUsingIdSizeReq.

   356 // Builds size (= iServicesSizeRespIpcMsg) and data (= iServicesDataRespIpcMsg)

   357 // messages from iServices.

   358 // iServicesSizeRespIpcMsg message contains iServicesDataRespIpcMsg length. 

   359 // ---------------------------------------------------------------------------

   360 //	

   361 void CIptvServiceMsgHandler::BuildServiceIpcMsgRespsL()

   362     {

   363     if(iServicesSizeRespIpcMsg)

   364         {

   365         delete iServicesSizeRespIpcMsg;

   366         iServicesSizeRespIpcMsg = NULL;

   367         }

   368         

   369     const TInt KServicesSizeRespLength = 1/*status*/+4/*data size*/;

   370     iServicesSizeRespIpcMsg = HBufC8::NewL(KServicesSizeRespLength);		

   371     TPtr8 servicesSizeRespIpcMsgPtr(iServicesSizeRespIpcMsg->Des());

   372 

   373     //count iServicesDataRespIpcMsg size

   374     TInt32 dataSize;

   375 

   376     dataSize = 1 /* message status */ + iServices->CountExternalizeSize();

   377 		

   378     //build iServicesSizeRespIpcMsg

   379     RDesWriteStream writeStream;

   380     writeStream.Open(servicesSizeRespIpcMsgPtr);

   381     CleanupClosePushL( writeStream );

   382     writeStream.WriteUint8L(MIptvServiceManagementClientObserver::ESucceeded);

   383     writeStream.WriteUint32L(dataSize);

   384     CleanupStack::PopAndDestroy( &writeStream );

   385 

   386     //build iServicesDataRespIpcMsg

   387     if(iServicesDataRespIpcMsg)

   388         {

   389         delete iServicesDataRespIpcMsg;

   390         iServicesDataRespIpcMsg = NULL;

   391         }

   392 

   393     IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler:: allocating %d bytes", dataSize);

   394              

   395     iServicesDataRespIpcMsg = HBufC8::NewL(dataSize);

   396     TPtr8 servicesDataRespIpcMsgPtr(iServicesDataRespIpcMsg->Des());

   397     writeStream.Open(servicesDataRespIpcMsgPtr);

   398     writeStream.WriteUint8L(MIptvServiceManagementClientObserver::ESucceeded);    

   399     iServices->ExternalizeL(writeStream);

   400     writeStream.Close();

   401             

   402     delete iServices;

   403     iServices = NULL;    

   404     }

   405 

   406 // ---------------------------------------------------------------------------

   407 // CIptvServiceMsgHandler::HandleAddServiceReqL

   408 // ---------------------------------------------------------------------------

   409 //	

   410 void CIptvServiceMsgHandler::HandleAddServiceReqL(const RMessage2& aMessage)

   411     {

   412     

   413     //fetch data from the client address space

   414     TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);

   415     HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);

   416     CleanupStack::PushL(ipcMsg);  

   417     ipcMsg->Des().Zero();

   418     TPtr8 ipcMsgPtr(ipcMsg->Des());

   419     aMessage.ReadL(0, ipcMsgPtr, 0);

   420 

   421     //create CIptvService class from the IPC msg

   422     RDesReadStream readStream;

   423     readStream.Open(ipcMsgPtr);

   424     CleanupClosePushL( readStream );

   425     CIptvService* iptvService = CIptvService::NewL();

   426     CleanupStack::PushL(iptvService);  

   427     iptvService->InternalizeL(readStream);

   428      

   429     //add CIptvService to db    		       

   430     iServer.iServiceManager->AddServiceL(*iptvService, ETrue /* do open/close */);

   431     

   432     SendStatusRespL( aMessage,

   433                      MIptvServiceManagementClientObserver::ESucceeded,

   434                      KErrNone );

   435 		

   436     CleanupStack::PopAndDestroy(iptvService);

   437     CleanupStack::PopAndDestroy( &readStream );

   438     CleanupStack::PopAndDestroy(ipcMsg);            

   439     }

   440 

   441 // ---------------------------------------------------------------------------

   442 // CIptvServiceMsgHandler::HandleDeleteServiceReqL

   443 // ---------------------------------------------------------------------------

   444 //	

   445 void CIptvServiceMsgHandler::HandleDeleteServiceReqL( const RMessage2& aMessage )

   446     {

   447     TUint32 ipcMsgSize( aMessage.GetDesLengthL( 0 ) );

   448     HBufC8* readIpcMsg = HBufC8::NewL( ipcMsgSize );

   449     CleanupStack::PushL( readIpcMsg ); //1->

   450     TPtr8 readIpcMsgPtr( readIpcMsg->Des() );

   451 

   452     aMessage.ReadL( 0, readIpcMsgPtr, 0 );

   453     

   454     RDesReadStream readStream;

   455     readStream.Open( readIpcMsgPtr );

   456     CleanupClosePushL( readStream );

   457     TUint32 serviceId = readStream.ReadUint32L();

   458     CleanupStack::PopAndDestroy( &readStream );

   459     CleanupStack::PopAndDestroy( readIpcMsg ); // <-1

   460 

   461     // Read service for type

   462     CIptvService* service = iServer.iServiceManager->

   463         GetServiceL( serviceId, ETrue /* do open/close */ );

   464     

   465     if ( service )

   466         {

   467         CIptvService::TServiceType serviceType( service->GetType() );

   468         TUint32 groupId( service->GetGroupId() );

   469         delete service;

   470 

   471         TInt err( KErrNone );

   472         if ( serviceType == CIptvService::EServiceGroup )

   473             {

   474             // All items in service group need to be deleted also 

   475             err = DeleteGroupL( groupId ); 

   476             }

   477         else

   478             {

   479             err = DeleteServiceL( serviceId, serviceType );

   480             }

   481 

   482         // Returns KErrNone even when no services are deleted   

   483         if ( err != KErrNone )

   484             {

   485             SendStatusRespL( aMessage,

   486                 MIptvServiceManagementClientObserver::EGeneralError, err );

   487             }

   488         else

   489             {

   490             SendStatusRespL( aMessage,

   491                 MIptvServiceManagementClientObserver::ESucceeded, err );

   492             }                       

   493         }

   494     else

   495         {

   496         SendStatusRespL( aMessage,

   497             MIptvServiceManagementClientObserver::EServiceNotFound, KErrNone );

   498         }

   499     }

   500 

   501 // ---------------------------------------------------------------------------

   502 // CIptvServiceMsgHandler::HandleUpdateServiceReqL

   503 // ---------------------------------------------------------------------------

   504 //	

   505 void CIptvServiceMsgHandler::HandleUpdateServiceReqL(const RMessage2& aMessage)

   506     {

   507 

   508     //fetch data from the client address space

   509     TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);

   510     HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);

   511     CleanupStack::PushL(ipcMsg);  

   512     ipcMsg->Des().Zero();

   513     TPtr8 ipcMsgPtr(ipcMsg->Des());

   514     aMessage.ReadL(0, ipcMsgPtr, 0);

   515 

   516     //create CIptvService class from the IPC msg

   517     CIptvService* iptvService = CIptvService::NewL();

   518     CleanupStack::PushL(iptvService);  

   519     RDesReadStream readStream;

   520     readStream.Open(ipcMsgPtr);

   521     CleanupClosePushL( readStream );

   522     iptvService->InternalizeL(readStream);

   523     CleanupStack::PopAndDestroy( &readStream );

   524      

   525     TRAPD( err, SetEpgLastUpdateTimeL( iptvService->GetId(), 

   526             iptvService->GetEpgUpdateTimeL() ) )

   527     IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler::HandleUpdateServiceReqL Service db LastUpdate updated, err=%d", err);

   528     

   529     //add CIptvService to db    		       

   530     TRAP(err, iServer.iServiceManager->UpdateServiceL(*iptvService));

   531     if(err != KErrNone)

   532         {        

   533         if(err == KErrNotFound)

   534             {

   535             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: returning EServiceNotFound.");

   536             SendStatusRespL( aMessage,

   537                              MIptvServiceManagementClientObserver::EServiceNotFound,

   538                              KErrNone );

   539             }

   540         else

   541             {

   542             IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: returning EGeneralError.");

   543             SendStatusRespL( aMessage,

   544                              MIptvServiceManagementClientObserver::EGeneralError,

   545                              err );

   546             }

   547         }

   548     else

   549         {

   550         SendStatusRespL( aMessage,

   551                          MIptvServiceManagementClientObserver::ESucceeded,

   552                          KErrNone );

   553         }

   554 		

   555     CleanupStack::PopAndDestroy(iptvService);

   556     CleanupStack::PopAndDestroy(ipcMsg);

   557             

   558     }

   559 

   560 // ---------------------------------------------------------------------------

   561 // 

   562 // ---------------------------------------------------------------------------

   563 //

   564 void CIptvServiceMsgHandler::SetEpgLastUpdateTimeL( TUint32 aServiceId, TTime& aLastUpdate )

   565     {

   566     CIptvEpgManagerImpl& epgManager = iServer.GetEpgManager();

   567     TInt temp( KErrNone );

   568     CIptvEpgSession* epgSession = 

   569         epgManager.CreateSessionL( aServiceId, NULL, temp, EFalse );    

   570     CleanupStack::PushL( epgSession );

   571     epgSession->SetLastUpdateTimeL( aLastUpdate );

   572     CleanupStack::PopAndDestroy( epgSession );             

   573     }

   574 

   575 // ---------------------------------------------------------------------------

   576 // CIptvServiceMsgHandler::SendStatusRespL

   577 // ---------------------------------------------------------------------------

   578 //	

   579 void CIptvServiceMsgHandler::SendStatusRespL(

   580         const RMessage2& aMessage,

   581         MIptvServiceManagementClientObserver::TRespStatus aError,

   582         TInt aGlobalError )

   583     {

   584     const TInt KStatusRespLength = 2;

   585     TBuf8<KStatusRespLength> resp;

   586     resp.Zero();

   587     RDesWriteStream writeStream;

   588     

   589     writeStream.Open(resp);

   590     CleanupClosePushL(writeStream); // 1->

   591     writeStream.WriteUint8L(aError);

   592     CleanupStack::PopAndDestroy(&writeStream); // <-1

   593     aMessage.WriteL(0, resp, 0);

   594     

   595     aMessage.Complete(aGlobalError);

   596     }

   597  

   598 // ---------------------------------------------------------------------------

   599 // CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderIdL

   600 // ---------------------------------------------------------------------------

   601 //	

   602 void CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderIdL(const RMessage2& aMessage)

   603     {

   604     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderId()");

   605 

   606     HBufC8* ipcMsg = GetDataFromClientAddrSpaceLC(aMessage); // 1->

   607     TPtr8 ipcMsgPtr(ipcMsg->Des());

   608 

   609     if ( iServices )

   610         {

   611         IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: iService already in use, aborting");

   612         aMessage.Complete(KErrServerBusy);

   613         CleanupStack::PopAndDestroy(ipcMsg);     // <-1

   614         aMessage.Complete(KErrServerBusy);

   615         return;   

   616         }

   617 

   618     //read data from the message

   619     RDesReadStream readStream;

   620     readStream.Open(ipcMsgPtr);

   621     CleanupClosePushL( readStream );

   622     TUint32 providerIdLength = readStream.ReadUint32L();

   623     HBufC* providerId = HBufC::NewL(providerIdLength);

   624     TPtr providerIdPtr(providerId->Des());

   625     CleanupStack::PushL(providerId); // 2->

   626     TInt i;

   627     for(i = 0; i < providerIdLength; i++)

   628         {

   629         providerId->Des().Append(readStream.ReadInt16L());

   630         }

   631     readStream.Close();

   632 

   633     IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler:: provider id: %S", &providerIdPtr);

   634         

   635     //get services from service manager    

   636     iServices = iServer.iServiceManager->GetServicesL(providerId->Des(), ETrue /* do open/close */);

   637     CleanupStack::PopAndDestroy(providerId); // <-2

   638     CleanupStack::PopAndDestroy( &readStream );

   639     if ( ! iServices )

   640         {

   641         IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: Could not get any services.");

   642         aMessage.Complete(KErrNotFound);

   643         CleanupStack::PopAndDestroy(ipcMsg);     // <-1

   644         return;

   645         }

   646             

   647     //write size to ipc msg

   648     ipcMsg->Des().Zero();

   649     RDesWriteStream writeStream;

   650     writeStream.Open(ipcMsgPtr);

   651     CleanupClosePushL(writeStream); // 1->

   652     writeStream.WriteUint32L(iServices->CountExternalizeSize());

   653     CleanupStack::PopAndDestroy(&writeStream); // <-1

   654     

   655     //write to client addr space

   656     aMessage.WriteL(0, ipcMsgPtr, 0);

   657     aMessage.Complete(KErrNone);

   658     

   659     CleanupStack::PopAndDestroy(ipcMsg);     // <-1

   660         

   661     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderId() exit");    

   662     }

   663 

   664 // ---------------------------------------------------------------------------

   665 // CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL

   666 // ---------------------------------------------------------------------------

   667 //

   668 void CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL(const RMessage2& aMessage)

   669     {

   670     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL()");

   671 

   672     if ( ! iServices )

   673         {

   674         IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: iService = NULL, can't return anything");

   675         aMessage.Complete(KErrNotFound);

   676         return;    

   677         }

   678 

   679     HBufC8* ipcMsg = HBufC8::NewL(iServices->CountExternalizeSize());

   680     CleanupStack::PushL(ipcMsg); // 1->

   681     TPtr8 ipcMsgPtr(ipcMsg->Des());

   682     ipcMsgPtr.Zero();

   683 

   684     //write services to ipc msg

   685     RDesWriteStream writeStream;

   686     writeStream.Open(ipcMsgPtr);

   687     CleanupClosePushL( writeStream );

   688     iServices->ExternalizeL(writeStream);

   689     CleanupStack::PopAndDestroy( &writeStream );

   690 

   691     delete iServices;

   692     iServices = NULL;

   693     

   694     //write to client addr space

   695     aMessage.WriteL(0, ipcMsgPtr, 0);

   696     aMessage.Complete(KErrNone);

   697     CleanupStack::PopAndDestroy(ipcMsg);     // <-1

   698     

   699     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL() exit");

   700     }

   701 

   702 // ---------------------------------------------------------------------------

   703 // CIptvServiceMsgHandler::GetDataFromClientAddrSpaceLC

   704 // ---------------------------------------------------------------------------

   705 //

   706 HBufC8* CIptvServiceMsgHandler::GetDataFromClientAddrSpaceLC(const RMessage2& aMessage)

   707     {

   708     //fetch data from the client address space

   709     TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);

   710     HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);

   711     CleanupStack::PushL(ipcMsg);     // 1->

   712     TPtr8 ipcMsgPtr(ipcMsg->Des());

   713     ipcMsgPtr.Zero();

   714     aMessage.ReadL(0, ipcMsgPtr, 0);

   715     return ipcMsg;

   716     }

   717 

   718 // ---------------------------------------------------------------------------

   719 // CIptvServiceMsgHandler::HandleSmEvent

   720 // ---------------------------------------------------------------------------

   721 //

   722 void CIptvServiceMsgHandler::HandleSmEvent(CIptvSmEvent& aEvent)

   723     {

   724     TRAPD(err, HandleSmEventL(aEvent));

   725     if (err != KErrNone)

   726         {

   727         IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler::HandleSmEventL() leaved, err = %d", err);

   728         }

   729     }

   730 

   731 // ---------------------------------------------------------------------------

   732 // CIptvServiceMsgHandler::HandleSmEventL

   733 // ---------------------------------------------------------------------------

   734 //    

   735 void CIptvServiceMsgHandler::HandleSmEventL(CIptvSmEvent& aEvent)

   736     {

   737     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleSmEvent()");

   738 

   739     if (iEventGenerator)

   740         {

   741         iEventGenerator->AddEventL( aEvent );

   742         }

   743 

   744     IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleSmEvent() exit");

   745     }

   746     

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

   748 // CIptvServiceMsgHandler::DeleteGroupL

   749 // ---------------------------------------------------------------------------

   750 //  

   751 TInt CIptvServiceMsgHandler::DeleteGroupL( const TUint32 aGroupId )

   752     {

   753     // Get all services

   754     CIptvServices* services = iServer.iServiceManager->GetServicesL(

   755         CIptvServiceManagementClient::TSearchLimitFlag( 0 ),

   756         CIptvServiceManagementClient::EDisplayOrderDescending,

   757         0 /*Latest*/ );

   758 

   759     if ( services != NULL )

   760         {

   761         CleanupStack::PushL( services );

   762         RFs fs;

   763         CleanupClosePushL( fs );

   764         User::LeaveIfError( fs.Connect() );

   765         

   766         // Find all services matching to group.

   767         for ( TInt i( 0 ); i < services->Count(); i++ )

   768             {

   769             CIptvService* tempService = services->GetServiceL( i );

   770             CleanupStack::PushL( tempService );

   771             

   772             if ( aGroupId == tempService->GetGroupId() )

   773                 {

   774                 // Delete icon file if downloaded and exist

   775                 if ( tempService->GetIconPath() != KIptvEmptyDes )

   776                     {

   777                     if ( BaflUtils::FileExists( fs, tempService->GetIconPath() ) )

   778                         {

   779                         fs.Delete( tempService->GetIconPath() );

   780                         }

   781                     }

   782                 

   783                 // Delete service

   784                 DeleteServiceL( tempService->GetId(), tempService->GetType() );

   785                 }

   786     

   787             CleanupStack::PopAndDestroy( tempService );

   788             }

   789 

   790         CleanupStack::PopAndDestroy( &fs );

   791         CleanupStack::PopAndDestroy( services );

   792         return KErrNone;

   793         }

   794     

   795     return KErrNotFound;

   796     }

   797 

   798 // ---------------------------------------------------------------------------

   799 // CIptvServiceMsgHandler::DeleteServiceL

   800 // ---------------------------------------------------------------------------

   801 //  

   802 TInt CIptvServiceMsgHandler::DeleteServiceL(

   803     const TUint32 aServiceId,

   804     const CIptvService::TServiceType aServiceType )

   805     {

   806     // Delete also the EPG DB file for service types that have a DB.

   807     if ( aServiceType == CIptvService::EVod ||

   808          aServiceType == CIptvService::EVodCast ||

   809          aServiceType == CIptvService::ELiveTv )

   810         {

   811         TRAP_IGNORE( // Ignore problems with Epg Manager.

   812             {

   813             CIptvEpgManagerImpl& epgManager = iServer.GetEpgManager();

   814             TInt temp( KErrNone );

   815             CIptvEpgSession* epgSession = 

   816                 epgManager.CreateSessionL( aServiceId, NULL, temp, EFalse );    

   817 

   818             CleanupStack::PushL( epgSession );

   819             epgSession->DeleteDatabaseFile();

   820             CleanupStack::PopAndDestroy( epgSession );             

   821             } );

   822         }

   823 

   824     return iServer.iServiceManager->DeleteServiceL( aServiceId );

   825     }

   826 

   827 //  End of File