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