diff -r 000000000000 -r 96612d01cf9f videofeeds/server/IptvServiceManager/src/CIptvServiceMsgHandler.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videofeeds/server/IptvServiceManager/src/CIptvServiceMsgHandler.cpp	Mon Jan 18 20:21:12 2010 +0200
@@ -0,0 +1,827 @@
+/*
+* Copyright (c) 2005-2006 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:    Handles messages from client*
+*/
+
+
+
+
+
+// INCLUDE FILES
+#include "IptvDebug.h"
+#include <bautils.h>
+
+#include "IptvClientServerCommon.h"
+#include "CIptvSmEvent.h"
+#include "CIptvService.h"
+#include "CIptvServices.h"
+#include "CIptvServiceMsgHandler.h"
+#include "CIptvServer.h"
+#include "MIptvServiceManagementClientObserver.h"
+#include "CIptvEpgManagerImpl.h"
+#include "CIptvEpgSession.h"
+#include "CIptvEventGenerator.h"
+
+// EXTERNAL DATA STRUCTURES
+// EXTERNAL FUNCTION PROTOTYPES  
+// CONSTANTS
+// MACROS
+// LOCAL CONSTANTS AND MACROS
+// MODULE DATA STRUCTURES
+// LOCAL FUNCTION PROTOTYPES
+
+// FORWARD DECLARATIONS
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CIptvServiceMsgHandler::CIptvServiceMsgHandler
+// C++ default constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CIptvServiceMsgHandler::CIptvServiceMsgHandler(CIptvServer& aServer)
+: iServer(aServer)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::CIptvServiceMsgHandler()");
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::CIptvServiceMsgHandler() exit");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceMsgHandler::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CIptvServiceMsgHandler::ConstructL()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::ConstructL()");
+
+    CIptvSmEvent* eventProto = CIptvSmEvent::NewL();
+    CleanupStack::PushL(eventProto); // 1->
+    iEventGenerator = CIptvEventGenerator::NewL(eventProto /* ownership moves */);
+    CleanupStack::Pop(eventProto); // <-1
+    iServer.iServiceManager->RegisterObserver(this);
+
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::ConstructL() exit");
+    }
+
+// -----------------------------------------------------------------------------
+// CIptvServiceMsgHandler::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CIptvServiceMsgHandler* CIptvServiceMsgHandler::NewL(CIptvServer& aServer)
+    {
+    CIptvServiceMsgHandler* self = new( ELeave ) CIptvServiceMsgHandler(aServer);
+    
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop(self);
+
+    return self;
+    }
+
+    
+// Destructor
+CIptvServiceMsgHandler::~CIptvServiceMsgHandler()
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::~CIptvServiceMsgHandler()");
+    delete iServicesDataRespIpcMsg;
+    delete iServicesSizeRespIpcMsg;
+    delete iServices;
+    delete iEventGenerator;
+    iServer.iServiceManager->DeRegisterObserver(this);
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::~CIptvServiceMsgHandler() exit");
+    }
+
+// ------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleServiceManagerMsgL
+// Handles messages meant for Service Manager.
+// ------------------------------------------------------------------
+//
+void CIptvServiceMsgHandler::HandleServiceManagerMsgL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleServiceManagerMsgL()");
+
+    switch(aMessage.Function())
+        {
+        case EIptvEngineSmGetServicesSizeReq: //get services from database, return size
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesSizeReq");
+            HandleGetServicesSizeReqL(aMessage);
+            break;
+            
+        case EIptvEngineSmGetServicesDataReq: //get services from database, return data
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesDataReq");
+            HandleGetServicesDataReqL(aMessage);
+            break;
+        	
+        case EIptvEngineSmGetServicesUsingIdSizeReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesUsingIdSizeReq");
+            HandleGetServicesUsingIdSizeReqL(aMessage);
+            break;
+            
+        case EIptvEngineSmGetServicesUsingIdDataReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmGetServicesUsingIdDataReq");
+            HandleGetServicesUsingIdDataReqL(aMessage);
+            break;
+        	        	        	        	        	
+        case EIptvEngineSmAddServiceReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmAddServiceReq");
+            HandleAddServiceReqL(aMessage);
+            break;
+        	
+        case EIptvEngineSmDeleteServiceReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmDeleteServiceReq");
+            HandleDeleteServiceReqL(aMessage);
+            break;
+    	
+        case EIptvEngineSmUpdateServiceReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmUpdateServiceReq");
+            HandleUpdateServiceReqL(aMessage);
+            break;
+        
+        case EIptvEngineSmGetServiceSizeUsingProviderId:
+            HandleGetServiceSizeUsingProviderIdL(aMessage);
+            break;
+            
+        case EIptvEngineSmGetServiceDataUsingProviderId:
+            HandleGetServiceDataUsingProviderIdL(aMessage);
+            break;
+    
+        case EIptvEngineSmCancel:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmCancel");
+            //All messages are currently processed synchronously in server side -> no need to do anything
+            aMessage.Complete(KErrNone);
+            break;
+        
+        case EIptvEngineSmGetEventSizeReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineGetEventSizeReq");
+            if (iEventGenerator)
+                {
+                iEventGenerator->SizeRequestL(aMessage);
+                }
+            break;
+            
+        case EIptvEngineSmGetEventData:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineGetEventData");
+            if (iEventGenerator)
+                {
+                iEventGenerator->DataRequestL(aMessage);
+                }
+            break;
+
+        case EIptvEngineSmCancelGetEventSizeReq:
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: EIptvEngineSmCancelGetEventSizeReq");
+            delete iEventGenerator;
+            iEventGenerator = NULL;
+            aMessage.Complete(KErrNone);
+            break;
+
+        }
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleServiceManagerMsg() exit");
+    }
+
+// ------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleGetServicesSizeReqL
+// ------------------------------------------------------------------
+//
+void CIptvServiceMsgHandler::HandleGetServicesSizeReqL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesSizeReqL()");
+                
+    //fetch data from the client address space
+    TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);
+    HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);
+    CleanupStack::PushL(ipcMsg);
+    ipcMsg->Des().Zero();
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+    aMessage.ReadL(0, ipcMsgPtr, 0);
+
+    RDesReadStream readStream;
+    readStream.Open(ipcMsgPtr);
+    CleanupClosePushL( readStream );
+    //See CIptvServiceManagementClient::TSearchLimitFlag
+    TUint32 searchLimitFlags;
+    TUint8 order;
+    
+    searchLimitFlags = readStream.ReadUint32L();
+    order            = readStream.ReadUint8L();
+    
+    CleanupStack::PopAndDestroy( &readStream );
+    CleanupStack::PopAndDestroy(ipcMsg);
+    
+    if ( iServices )
+        {
+        delete iServices;
+        iServices = NULL;
+        }
+                
+    TRAPD(err, iServices = iServer.iServiceManager->GetServicesL(searchLimitFlags,
+                                                                static_cast<CIptvServiceManagementClient::TOrder>(order),
+                                                                0 /* 0 = use latest version */));
+    if(err != KErrNone)
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: Failed to get services from DB!");
+
+        SendStatusRespL( aMessage,
+                         MIptvServiceManagementClientObserver::EGeneralError,
+                         err );
+        }
+    else
+        {        
+	      //build iServicesSizeRespIpcMsg and iServicesDataRespIpcMsg from iServicesArray
+        BuildServiceIpcMsgRespsL();
+				
+        aMessage.WriteL(0, iServicesSizeRespIpcMsg->Des(), 0);
+
+        aMessage.Complete(err);
+		
+        delete iServicesSizeRespIpcMsg;
+        iServicesSizeRespIpcMsg = NULL;
+        }
+        
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesSizeReqL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleGetServicesDataReqL
+// ---------------------------------------------------------------------------
+//	    
+void CIptvServiceMsgHandler::HandleGetServicesDataReqL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesDataReqL()");
+
+    aMessage.WriteL(0, iServicesDataRespIpcMsg->Des(), 0);
+
+    aMessage.Complete(KErrNone);
+        	
+    delete iServicesDataRespIpcMsg;
+    iServicesDataRespIpcMsg = NULL;
+
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesDataReqL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL()");
+
+    //fetch data from the client address space
+    TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);
+    HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);
+    CleanupStack::PushL(ipcMsg);  
+    ipcMsg->Des().Zero();
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+    aMessage.ReadL(0, ipcMsgPtr, 0);
+
+    //get start and end indexes
+    TUint32 startIndex;
+    TUint32 endIndex;
+
+    RDesReadStream readStream;
+    readStream.Open(ipcMsgPtr);
+    CleanupClosePushL( readStream );
+    startIndex = readStream.ReadUint32L();
+    endIndex   = readStream.ReadUint32L();
+    CleanupStack::PopAndDestroy( &readStream );
+
+    //Make the db query
+    if(iServices)
+        {
+        delete iServices;
+        iServices = NULL;
+        }        
+    TRAPD(err, iServices = iServer.iServiceManager->GetServicesUsingIdL(startIndex, endIndex, ETrue /* do open/close */));
+
+    if(err != KErrNone)
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: Failed to get services from DB!");
+
+        delete iServices;
+        iServices = NULL;
+        SendStatusRespL( aMessage,
+                         MIptvServiceManagementClientObserver::EGeneralError,
+                         err );
+        }
+    else
+        {
+        //build iServicesSizeRespIpcMsg and iServicesDataRespIpcMsg from iServices
+        BuildServiceIpcMsgRespsL();
+
+        aMessage.WriteL(0, iServicesSizeRespIpcMsg->Des(), 0);
+        aMessage.Complete(err);
+    
+        delete iServicesSizeRespIpcMsg;
+        iServicesSizeRespIpcMsg = NULL;
+        }
+        
+    CleanupStack::PopAndDestroy(ipcMsg);
+    
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdSizeReqL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL()");
+
+    aMessage.WriteL(0, iServicesDataRespIpcMsg->Des(), 0);
+    aMessage.Complete(KErrNone);
+    
+    delete iServicesDataRespIpcMsg;
+    iServicesDataRespIpcMsg = NULL;
+    
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServicesUsingIdDataReqL() exit");
+    }
+    
+// ---------------------------------------------------------------------------
+// Used for EIptvEngineGetServicesSizeReq and EIptvEngineGetServicesUsingIdSizeReq.
+// Builds size (= iServicesSizeRespIpcMsg) and data (= iServicesDataRespIpcMsg)
+// messages from iServices.
+// iServicesSizeRespIpcMsg message contains iServicesDataRespIpcMsg length. 
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::BuildServiceIpcMsgRespsL()
+    {
+    if(iServicesSizeRespIpcMsg)
+        {
+        delete iServicesSizeRespIpcMsg;
+        iServicesSizeRespIpcMsg = NULL;
+        }
+        
+    const TInt KServicesSizeRespLength = 1/*status*/+4/*data size*/;
+    iServicesSizeRespIpcMsg = HBufC8::NewL(KServicesSizeRespLength);		
+    TPtr8 servicesSizeRespIpcMsgPtr(iServicesSizeRespIpcMsg->Des());
+
+    //count iServicesDataRespIpcMsg size
+    TInt32 dataSize;
+
+    dataSize = 1 /* message status */ + iServices->CountExternalizeSize();
+		
+    //build iServicesSizeRespIpcMsg
+    RDesWriteStream writeStream;
+    writeStream.Open(servicesSizeRespIpcMsgPtr);
+    CleanupClosePushL( writeStream );
+    writeStream.WriteUint8L(MIptvServiceManagementClientObserver::ESucceeded);
+    writeStream.WriteUint32L(dataSize);
+    CleanupStack::PopAndDestroy( &writeStream );
+
+    //build iServicesDataRespIpcMsg
+    if(iServicesDataRespIpcMsg)
+        {
+        delete iServicesDataRespIpcMsg;
+        iServicesDataRespIpcMsg = NULL;
+        }
+
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler:: allocating %d bytes", dataSize);
+             
+    iServicesDataRespIpcMsg = HBufC8::NewL(dataSize);
+    TPtr8 servicesDataRespIpcMsgPtr(iServicesDataRespIpcMsg->Des());
+    writeStream.Open(servicesDataRespIpcMsgPtr);
+    writeStream.WriteUint8L(MIptvServiceManagementClientObserver::ESucceeded);    
+    iServices->ExternalizeL(writeStream);
+    writeStream.Close();
+            
+    delete iServices;
+    iServices = NULL;    
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleAddServiceReqL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::HandleAddServiceReqL(const RMessage2& aMessage)
+    {
+    
+    //fetch data from the client address space
+    TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);
+    HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);
+    CleanupStack::PushL(ipcMsg);  
+    ipcMsg->Des().Zero();
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+    aMessage.ReadL(0, ipcMsgPtr, 0);
+
+    //create CIptvService class from the IPC msg
+    RDesReadStream readStream;
+    readStream.Open(ipcMsgPtr);
+    CleanupClosePushL( readStream );
+    CIptvService* iptvService = CIptvService::NewL();
+    CleanupStack::PushL(iptvService);  
+    iptvService->InternalizeL(readStream);
+     
+    //add CIptvService to db    		       
+    iServer.iServiceManager->AddServiceL(*iptvService, ETrue /* do open/close */);
+    
+    SendStatusRespL( aMessage,
+                     MIptvServiceManagementClientObserver::ESucceeded,
+                     KErrNone );
+		
+    CleanupStack::PopAndDestroy(iptvService);
+    CleanupStack::PopAndDestroy( &readStream );
+    CleanupStack::PopAndDestroy(ipcMsg);            
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleDeleteServiceReqL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::HandleDeleteServiceReqL( const RMessage2& aMessage )
+    {
+    TUint32 ipcMsgSize( aMessage.GetDesLengthL( 0 ) );
+    HBufC8* readIpcMsg = HBufC8::NewL( ipcMsgSize );
+    CleanupStack::PushL( readIpcMsg ); //1->
+    TPtr8 readIpcMsgPtr( readIpcMsg->Des() );
+
+    aMessage.ReadL( 0, readIpcMsgPtr, 0 );
+    
+    RDesReadStream readStream;
+    readStream.Open( readIpcMsgPtr );
+    CleanupClosePushL( readStream );
+    TUint32 serviceId = readStream.ReadUint32L();
+    CleanupStack::PopAndDestroy( &readStream );
+    CleanupStack::PopAndDestroy( readIpcMsg ); // <-1
+
+    // Read service for type
+    CIptvService* service = iServer.iServiceManager->
+        GetServiceL( serviceId, ETrue /* do open/close */ );
+    
+    if ( service )
+        {
+        CIptvService::TServiceType serviceType( service->GetType() );
+        TUint32 groupId( service->GetGroupId() );
+        delete service;
+
+        TInt err( KErrNone );
+        if ( serviceType == CIptvService::EServiceGroup )
+            {
+            // All items in service group need to be deleted also 
+            err = DeleteGroupL( groupId ); 
+            }
+        else
+            {
+            err = DeleteServiceL( serviceId, serviceType );
+            }
+
+        // Returns KErrNone even when no services are deleted   
+        if ( err != KErrNone )
+            {
+            SendStatusRespL( aMessage,
+                MIptvServiceManagementClientObserver::EGeneralError, err );
+            }
+        else
+            {
+            SendStatusRespL( aMessage,
+                MIptvServiceManagementClientObserver::ESucceeded, err );
+            }                       
+        }
+    else
+        {
+        SendStatusRespL( aMessage,
+            MIptvServiceManagementClientObserver::EServiceNotFound, KErrNone );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleUpdateServiceReqL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::HandleUpdateServiceReqL(const RMessage2& aMessage)
+    {
+
+    //fetch data from the client address space
+    TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);
+    HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);
+    CleanupStack::PushL(ipcMsg);  
+    ipcMsg->Des().Zero();
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+    aMessage.ReadL(0, ipcMsgPtr, 0);
+
+    //create CIptvService class from the IPC msg
+    CIptvService* iptvService = CIptvService::NewL();
+    CleanupStack::PushL(iptvService);  
+    RDesReadStream readStream;
+    readStream.Open(ipcMsgPtr);
+    CleanupClosePushL( readStream );
+    iptvService->InternalizeL(readStream);
+    CleanupStack::PopAndDestroy( &readStream );
+     
+    TRAPD( err, SetEpgLastUpdateTimeL( iptvService->GetId(), 
+            iptvService->GetEpgUpdateTimeL() ) )
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler::HandleUpdateServiceReqL Service db LastUpdate updated, err=%d", err);
+    
+    //add CIptvService to db    		       
+    TRAP(err, iServer.iServiceManager->UpdateServiceL(*iptvService));
+    if(err != KErrNone)
+        {        
+        if(err == KErrNotFound)
+            {
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: returning EServiceNotFound.");
+            SendStatusRespL( aMessage,
+                             MIptvServiceManagementClientObserver::EServiceNotFound,
+                             KErrNone );
+            }
+        else
+            {
+            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: returning EGeneralError.");
+            SendStatusRespL( aMessage,
+                             MIptvServiceManagementClientObserver::EGeneralError,
+                             err );
+            }
+        }
+    else
+        {
+        SendStatusRespL( aMessage,
+                         MIptvServiceManagementClientObserver::ESucceeded,
+                         KErrNone );
+        }
+		
+    CleanupStack::PopAndDestroy(iptvService);
+    CleanupStack::PopAndDestroy(ipcMsg);
+            
+    }
+
+// ---------------------------------------------------------------------------
+// 
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceMsgHandler::SetEpgLastUpdateTimeL( TUint32 aServiceId, TTime& aLastUpdate )
+    {
+    CIptvEpgManagerImpl& epgManager = iServer.GetEpgManager();
+    TInt temp( KErrNone );
+    CIptvEpgSession* epgSession = 
+        epgManager.CreateSessionL( aServiceId, NULL, temp, EFalse );    
+    CleanupStack::PushL( epgSession );
+    epgSession->SetLastUpdateTimeL( aLastUpdate );
+    CleanupStack::PopAndDestroy( epgSession );             
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::SendStatusRespL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::SendStatusRespL(
+        const RMessage2& aMessage,
+        MIptvServiceManagementClientObserver::TRespStatus aError,
+        TInt aGlobalError )
+    {
+    const TInt KStatusRespLength = 2;
+    TBuf8<KStatusRespLength> resp;
+    resp.Zero();
+    RDesWriteStream writeStream;
+    
+    writeStream.Open(resp);
+    CleanupClosePushL(writeStream); // 1->
+    writeStream.WriteUint8L(aError);
+    CleanupStack::PopAndDestroy(&writeStream); // <-1
+    aMessage.WriteL(0, resp, 0);
+    
+    aMessage.Complete(aGlobalError);
+    }
+ 
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderIdL
+// ---------------------------------------------------------------------------
+//	
+void CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderIdL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderId()");
+
+    HBufC8* ipcMsg = GetDataFromClientAddrSpaceLC(aMessage); // 1->
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+
+    if ( iServices )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: iService already in use, aborting");
+        aMessage.Complete(KErrServerBusy);
+        CleanupStack::PopAndDestroy(ipcMsg);     // <-1
+        aMessage.Complete(KErrServerBusy);
+        return;   
+        }
+
+    //read data from the message
+    RDesReadStream readStream;
+    readStream.Open(ipcMsgPtr);
+    CleanupClosePushL( readStream );
+    TUint32 providerIdLength = readStream.ReadUint32L();
+    HBufC* providerId = HBufC::NewL(providerIdLength);
+    TPtr providerIdPtr(providerId->Des());
+    CleanupStack::PushL(providerId); // 2->
+    TInt i;
+    for(i = 0; i < providerIdLength; i++)
+        {
+        providerId->Des().Append(readStream.ReadInt16L());
+        }
+    readStream.Close();
+
+    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler:: provider id: %S", &providerIdPtr);
+        
+    //get services from service manager    
+    iServices = iServer.iServiceManager->GetServicesL(providerId->Des(), ETrue /* do open/close */);
+    CleanupStack::PopAndDestroy(providerId); // <-2
+    CleanupStack::PopAndDestroy( &readStream );
+    if ( ! iServices )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: Could not get any services.");
+        aMessage.Complete(KErrNotFound);
+        CleanupStack::PopAndDestroy(ipcMsg);     // <-1
+        return;
+        }
+            
+    //write size to ipc msg
+    ipcMsg->Des().Zero();
+    RDesWriteStream writeStream;
+    writeStream.Open(ipcMsgPtr);
+    CleanupClosePushL(writeStream); // 1->
+    writeStream.WriteUint32L(iServices->CountExternalizeSize());
+    CleanupStack::PopAndDestroy(&writeStream); // <-1
+    
+    //write to client addr space
+    aMessage.WriteL(0, ipcMsgPtr, 0);
+    aMessage.Complete(KErrNone);
+    
+    CleanupStack::PopAndDestroy(ipcMsg);     // <-1
+        
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceSizeUsingProviderId() exit");    
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL(const RMessage2& aMessage)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL()");
+
+    if ( ! iServices )
+        {
+        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler:: iService = NULL, can't return anything");
+        aMessage.Complete(KErrNotFound);
+        return;    
+        }
+
+    HBufC8* ipcMsg = HBufC8::NewL(iServices->CountExternalizeSize());
+    CleanupStack::PushL(ipcMsg); // 1->
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+    ipcMsgPtr.Zero();
+
+    //write services to ipc msg
+    RDesWriteStream writeStream;
+    writeStream.Open(ipcMsgPtr);
+    CleanupClosePushL( writeStream );
+    iServices->ExternalizeL(writeStream);
+    CleanupStack::PopAndDestroy( &writeStream );
+
+    delete iServices;
+    iServices = NULL;
+    
+    //write to client addr space
+    aMessage.WriteL(0, ipcMsgPtr, 0);
+    aMessage.Complete(KErrNone);
+    CleanupStack::PopAndDestroy(ipcMsg);     // <-1
+    
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleGetServiceDataUsingProviderIdL() exit");
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::GetDataFromClientAddrSpaceLC
+// ---------------------------------------------------------------------------
+//
+HBufC8* CIptvServiceMsgHandler::GetDataFromClientAddrSpaceLC(const RMessage2& aMessage)
+    {
+    //fetch data from the client address space
+    TUint32 ipcMsgSize = aMessage.GetDesLengthL(0);
+    HBufC8* ipcMsg = HBufC8::NewL(ipcMsgSize);
+    CleanupStack::PushL(ipcMsg);     // 1->
+    TPtr8 ipcMsgPtr(ipcMsg->Des());
+    ipcMsgPtr.Zero();
+    aMessage.ReadL(0, ipcMsgPtr, 0);
+    return ipcMsg;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleSmEvent
+// ---------------------------------------------------------------------------
+//
+void CIptvServiceMsgHandler::HandleSmEvent(CIptvSmEvent& aEvent)
+    {
+    TRAPD(err, HandleSmEventL(aEvent));
+    if (err != KErrNone)
+        {
+        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceMsgHandler::HandleSmEventL() leaved, err = %d", err);
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::HandleSmEventL
+// ---------------------------------------------------------------------------
+//    
+void CIptvServiceMsgHandler::HandleSmEventL(CIptvSmEvent& aEvent)
+    {
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleSmEvent()");
+
+    if (iEventGenerator)
+        {
+        iEventGenerator->AddEventL( aEvent );
+        }
+
+    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceMsgHandler::HandleSmEvent() exit");
+    }
+    
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::DeleteGroupL
+// ---------------------------------------------------------------------------
+//  
+TInt CIptvServiceMsgHandler::DeleteGroupL( const TUint32 aGroupId )
+    {
+    // Get all services
+    CIptvServices* services = iServer.iServiceManager->GetServicesL(
+        CIptvServiceManagementClient::TSearchLimitFlag( 0 ),
+        CIptvServiceManagementClient::EDisplayOrderDescending,
+        0 /*Latest*/ );
+
+    if ( services != NULL )
+        {
+        CleanupStack::PushL( services );
+        RFs fs;
+        CleanupClosePushL( fs );
+        User::LeaveIfError( fs.Connect() );
+        
+        // Find all services matching to group.
+        for ( TInt i( 0 ); i < services->Count(); i++ )
+            {
+            CIptvService* tempService = services->GetServiceL( i );
+            CleanupStack::PushL( tempService );
+            
+            if ( aGroupId == tempService->GetGroupId() )
+                {
+                // Delete icon file if downloaded and exist
+                if ( tempService->GetIconPath() != KIptvEmptyDes )
+                    {
+                    if ( BaflUtils::FileExists( fs, tempService->GetIconPath() ) )
+                        {
+                        fs.Delete( tempService->GetIconPath() );
+                        }
+                    }
+                
+                // Delete service
+                DeleteServiceL( tempService->GetId(), tempService->GetType() );
+                }
+    
+            CleanupStack::PopAndDestroy( tempService );
+            }
+
+        CleanupStack::PopAndDestroy( &fs );
+        CleanupStack::PopAndDestroy( services );
+        return KErrNone;
+        }
+    
+    return KErrNotFound;
+    }
+
+// ---------------------------------------------------------------------------
+// CIptvServiceMsgHandler::DeleteServiceL
+// ---------------------------------------------------------------------------
+//  
+TInt CIptvServiceMsgHandler::DeleteServiceL(
+    const TUint32 aServiceId,
+    const CIptvService::TServiceType aServiceType )
+    {
+    // Delete also the EPG DB file for service types that have a DB.
+    if ( aServiceType == CIptvService::EVod ||
+         aServiceType == CIptvService::EVodCast ||
+         aServiceType == CIptvService::ELiveTv )
+        {
+        TRAP_IGNORE( // Ignore problems with Epg Manager.
+            {
+            CIptvEpgManagerImpl& epgManager = iServer.GetEpgManager();
+            TInt temp( KErrNone );
+            CIptvEpgSession* epgSession = 
+                epgManager.CreateSessionL( aServiceId, NULL, temp, EFalse );    
+
+            CleanupStack::PushL( epgSession );
+            epgSession->DeleteDatabaseFile();
+            CleanupStack::PopAndDestroy( epgSession );             
+            } );
+        }
+
+    return iServer.iServiceManager->DeleteServiceL( aServiceId );
+    }
+
+//  End of File