/*

* 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