/*

* 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:    Provides interface to Service Management and Network Selection*

*/

// INCLUDE FILES

#include <e32svr.h>

#include "IptvDebug.h"

#include "IptvClientServerCommon.h"

#include "CIptvService.h"

#include "CIptvServices.h"

#include "CIptvServiceManagementClient.h"

#include "MIptvServiceManagementClientObserver.h"

#include "CIptvServiceManager.h"

#include "IptvServer.pan"

#include "CIptvSmEvent.h"

#include "CIptvEventListener.h"

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

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::NewL()

// Two-phased constructor.

// -----------------------------------------------------------------------------

EXPORT_C CIptvServiceManagementClient* CIptvServiceManagementClient::NewL(MIptvServiceManagementClientObserver& aClient)

    {

    CIptvServiceManagementClient* self =

        new ( ELeave ) CIptvServiceManagementClient(aClient);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return( self ) ;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::ConstructL()

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CIptvServiceManagementClient::ConstructL()

    {

    User::LeaveIfError( iSession.Connect() );

    iMsg = NULL;

    CIptvSmEvent* event = CIptvSmEvent::NewL();

    CleanupStack::PushL(event); // 1->

    iEventListener = CIptvEventListener::NewL( *this,

                                               event /* ownership moves */,

                                               EIptvEngineSmGetEventSizeReq,

                                               EIptvEngineSmGetEventData,

                                               EIptvEngineSmCancelGetEventSizeReq );

    CleanupStack::Pop(event); // <-1

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::CIptvServiceManagementClient()

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

// -----------------------------------------------------------------------------

EXPORT_C CIptvServiceManagementClient::CIptvServiceManagementClient(MIptvServiceManagementClientObserver& aClient)

: CIptvClientBase(), iClient(aClient), iMsgPtr((unsigned char*)0, 0) 

    {

    CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::~CIptvServiceManagementClient()

// Destructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CIptvServiceManagementClient::~CIptvServiceManagementClient()

    {

    IPTVLOGSTRING_LOW_LEVEL("~CIptvServiceManagementClient()");

    delete iEventListener;

    Cancel(); // Causes call to DoCancel() if there is message pending

    iSession.Close();

    delete iMsg;

    iMsg = NULL;

    IPTVLOGSTRING_LOW_LEVEL("~CIptvServiceManagementClient() exit");    	

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::AddServiceReq()

// Adds a service to Service data base.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvServiceManagementClient::AddServiceReqL(CIptvService& aService)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::AddServiceReq()");

    if ( IsActive() )

        {

        return KErrNotReady;

        }

    BuildAddServiceReqL( aService );

    //send it

    iSession.SendRequest( EIptvEngineSmAddServiceReq, iMsgPtr, iStatus );

    SetActive();

    iRequestPendingFor = EServiceManagerRequestPending;

    iResponseMsgId = EIptvEngineSmAddServiceResp;

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::AddServiceReq() exit");

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::AddServiceL()

// -----------------------------------------------------------------------------

//	

EXPORT_C TInt CIptvServiceManagementClient::AddServiceL(

    CIptvService& aService,

	MIptvServiceManagementClientObserver::TRespStatus& aRespStatus)

    {

    BuildAddServiceReqL( aService );

    TInt err = iSession.SendRequest( EIptvEngineSmAddServiceReq, iMsgPtr );

    if ( err == KErrNone )

        {

        aRespStatus = GetRespStatusL();

        }

    else

        {

        aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

        }

    return err;    

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::UpdateServiceReqL()

// -----------------------------------------------------------------------------

//	

EXPORT_C TInt CIptvServiceManagementClient::UpdateServiceReqL(CIptvService& aService)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::UpdateServiceReq()");

    if(IsActive())

        {

        return KErrNotReady;

        }

    BuildUpdateServiceReqL(aService);

    //send it

    iSession.SendRequest(EIptvEngineSmUpdateServiceReq, iMsgPtr, iStatus);

    SetActive();

    iRequestPendingFor = EServiceManagerRequestPending;

    iResponseMsgId     = EIptvEngineSmUpdateServiceResp;

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::UpdateServiceReq() exit");

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::UpdateServiceL()

// -----------------------------------------------------------------------------

//	

EXPORT_C TInt CIptvServiceManagementClient::UpdateServiceL(CIptvService& aService,

                                                          MIptvServiceManagementClientObserver::TRespStatus& aRespStatus)

    {

    BuildUpdateServiceReqL(aService);

    TInt err = iSession.SendRequest(EIptvEngineSmUpdateServiceReq, iMsgPtr);

    if(err == KErrNone)

        {

        aRespStatus = GetRespStatusL();

        }

    else

        {

        aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

        }

    delete iMsg;

    iMsg = NULL;

    return err;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::GetServicesReq()

// Requests services from the database. The request is done in 2 phases, first

// request gets only data size, second transaction gets the data.

// -----------------------------------------------------------------------------

//	

EXPORT_C TInt CIptvServiceManagementClient::GetServicesReqL(TUint32 aSearchLimitFlags,

                                                            TOrder aOrder)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::GetServicesReqL(aSearchLimitFlags, aOrder)");

    if(IsActive())

        {

        return KErrNotReady;

        }

    BuildGetServicesSizeReqL(aSearchLimitFlags, aOrder);

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: Sending EIptvEngineGetServicesSizeReq");                

    iSession.SendRequest(EIptvEngineSmGetServicesSizeReq, iMsgPtr, iStatus);

    SetActive();

    iRequestPendingFor = EServiceManagerRequestPending;

    iResponseMsgId     = EIptvEngineSmGetServicesSizeResp;

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::GetServicesReqL(aSearchLimitFlags, aOrder) exit");

    return KErrNone;

    }

EXPORT_C TInt CIptvServiceManagementClient::GetServicesL(

    TUint32 aSearchLimitFlags,

    TOrder aOrder,

    CDesC8ArraySeg*& aServicesArray,

    MIptvServiceManagementClientObserver::TRespStatus& aRespStatus )

    {    

    BuildGetServicesSizeReqL( aSearchLimitFlags, aOrder );

    TInt err = iSession.SendRequest( EIptvEngineSmGetServicesSizeReq, iMsgPtr );

    if ( err != KErrNone )

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: GetServicesL() error when requesting size");

        aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

        return err;

        }

    else

        {

        RDesReadStream readStream;

        readStream.Open( iMsgPtr);

        CleanupClosePushL( readStream );

        TUint8  status = readStream.ReadUint8L();

        TUint32 size   = readStream.ReadUint32L();    

        CleanupStack::PopAndDestroy( &readStream );

        if ( status != MIptvServiceManagementClientObserver::ESucceeded )

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: GetServicesL() error when requesting size");

            aRespStatus = ( MIptvServiceManagementClientObserver::TRespStatus )status;

            return KErrGeneral;

            }

        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManagementClient:: Size: %d", size);

        if ( iMsg )

            {

            delete iMsg;

            iMsg = NULL;

            }

        iMsg = HBufC8::NewL( size );

        iMsgPtr.Set( iMsg->Des() );

        err = iSession.SendRequest( EIptvEngineSmGetServicesDataReq, iMsgPtr );

        if ( err != KErrNone )

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmGetServicesDataReq failed");

            aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

            return err;

            }

        else

            {

            CDesC8ArraySeg* services = NULL;

            TRAPD( err, services = InternalizeGetServicesDataRespL() );

            if ( err != KErrNone )

                {

                IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: failed to internalize GetServicesDataResp ipc msg");

                aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

                return err;

                }

            aRespStatus    = MIptvServiceManagementClientObserver::ESucceeded;

            aServicesArray = services;

            return KErrNone;

            }

        }

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::GetServicesReqL()

// Gets service entries from Services database. Request is done asynchronously.

// GetServicesResp is the callback function.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvServiceManagementClient::GetServicesReqL(TUint32 aStartId, TUint32 aEndId)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::GetServicesReqL(aStartId, aEndId)");

    if(IsActive())

        {

        return KErrNotReady;

        }

    BuildGetServicesUsingIndexSizeReqL(aStartId, aEndId);

    IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: Sending EIptvEngineGetServicesUsingIdSizeReq");

    iSession.SendRequest(EIptvEngineSmGetServicesUsingIdSizeReq, iMsgPtr, iStatus);

    SetActive();

    iRequestPendingFor = EServiceManagerRequestPending;

    iResponseMsgId     = EIptvEngineSmGetServicesUsingIdSizeResp;

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::GetServicesReqL(aStartId, aEndId) exit");

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::GetServices()

// -----------------------------------------------------------------------------

//    		

EXPORT_C TInt CIptvServiceManagementClient::GetServicesL(TUint32 aStartId,

                                                         TUint32 aEndId,

                                                         CDesC8ArraySeg*& aServicesArray,

                                                         MIptvServiceManagementClientObserver::TRespStatus& aRespStatus)

    {

    BuildGetServicesUsingIndexSizeReqL(aStartId, aEndId);

    TInt err = iSession.SendRequest(EIptvEngineSmGetServicesUsingIdSizeReq, iMsgPtr);

    if (err != KErrNone)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: Error in SendRequest");

        aRespStatus    = MIptvServiceManagementClientObserver::EGeneralError;

        aServicesArray = NULL;

        return err;

        }

    TUint8  status;

    TUint32 size;

    RDesReadStream readStream;

    readStream.Open(iMsgPtr);

    CleanupClosePushL( readStream );

    status = readStream.ReadUint8L();

    if(status != MIptvServiceManagementClientObserver::ESucceeded)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: Error");

        iClient.GetServicesResp((MIptvServiceManagementClientObserver::TRespStatus)status, NULL);

        CleanupStack::PopAndDestroy( &readStream );

        return KErrGeneral;

        }

    size = readStream.ReadUint32L();    

    CleanupStack::PopAndDestroy( &readStream );

    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManagementClient:: Size: %d", size);

    if (iMsg)

        {

        delete iMsg;

        iMsg = NULL;

        }

    iMsg = HBufC8::NewL(size);

    iMsgPtr.Set(iMsg->Des());

    err = iSession.SendRequest(EIptvEngineSmGetServicesUsingIdDataReq, iMsgPtr);

    if (err != KErrNone)

        {

        IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmGetServicesUsingIdDataReq failed");

        aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

        return err;

        }

    else

        {

        CDesC8ArraySeg* services = NULL;

        TRAPD(err, services = InternalizeGetServicesDataRespL());

        if (err != KErrNone)

            {

            IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient:: failed to internalize GetServicesDataResp ipc msg");

            aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

            return err;

            }

        aRespStatus    = MIptvServiceManagementClientObserver::ESucceeded;

        aServicesArray = services;

        return KErrNone;

        }

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::DeleteServiceReqL()

// Deletes a service from the database.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvServiceManagementClient::DeleteServiceReqL(TUint32 aId)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::DeleteServiceReqL()");

    if(IsActive())

        {

        return KErrNotReady;

        }

    BuildDeleteServiceReqL(aId);

    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManagementClient:: Making delete request for ID: %d", aId);

    iSession.SendRequest(EIptvEngineSmDeleteServiceReq, iMsgPtr, iStatus);

    SetActive();

    iRequestPendingFor = EServiceManagerRequestPending;

    iResponseMsgId     = EIptvEngineSmDeleteServiceResp;

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::DeleteServiceReq() exit");

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::DeleteServiceL()

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvServiceManagementClient::DeleteServiceL(TUint32 aId,

                                                          MIptvServiceManagementClientObserver::TRespStatus& aRespStatus)

    {

    BuildDeleteServiceReqL(aId);

    IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManagementClient:: Making delete request for ID: %d", aId);

    TInt err = iSession.SendRequest(EIptvEngineSmDeleteServiceReq, iMsgPtr);

    if (err != KErrNone)

        {

        aRespStatus = MIptvServiceManagementClientObserver::EGeneralError;

        }

    else

        {

        aRespStatus = GetRespStatusL();

        }

    return err;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::ServerShutDownReq()

// Requests server to shutdown itself.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CIptvServiceManagementClient::ServerShutdownReq()

    {

    if(IsActive())

        {

        return KErrNotReady;

        }

    iSession.SendRequest(EIptvEngineServerShutdownReq, iStatus);

    SetActive();

    iRequestPendingFor = EServerRequestPending;

    iResponseMsgId     = EIptvEngineShutdownResp;

    return KErrNone;

    }

EXPORT_C TInt CIptvServiceManagementClient::ServerShutdown(MIptvServiceManagementClientObserver::TRespStatus& /*aRespStatus*/)

    {

    return KErrNotSupported;

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::CancelRequest()

// Cancels an outstanding request.

// -----------------------------------------------------------------------------

//

EXPORT_C void CIptvServiceManagementClient::CancelRequest()

    {

    Cancel() ; // Causes call to DoCancel() if there is message pending

    }

// -----------------------------------------------------------------------------

// CIptvServiceManagementClient::RunL()

// Invoked to handle responses from Iptv server.

// -----------------------------------------------------------------------------

//

void CIptvServiceManagementClient::RunL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvServiceManagementClient::RunL()");

    iRequestPendingFor = ENoRequestPending;

    TInt error = iStatus.Int();

    if(error != KErrNone)

        {

        IPTVLOGSTRING2_LOW_LEVEL("CIptvServiceManagementClient:: error received from server: %d", error);

        }

    switch ( iResponseMsgId )

        {

        case EIptvEngineShutdownResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineShutdownResp");

            iClient.ServerShutdownResp(GetRespStatusL());

            break;

        case EIptvEngineSmGetServicesSizeResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmGetServicesSizeResp");

            HandleGetServicesSizeRespL(EIptvEngineSmGetServicesSizeResp);

            break;

        case EIptvEngineSmGetServicesDataResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmGetServicesDataResp");

            HandleGetServicesDataRespL(EIptvEngineSmGetServicesDataResp);

            break;

        case EIptvEngineSmGetServicesUsingIdSizeResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmGetServicesUsingIdSizeResp");

            HandleGetServicesSizeRespL(EIptvEngineSmGetServicesUsingIdSizeResp);

            break;

        case EIptvEngineSmGetServicesUsingIdDataResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmGetServicesUsingIdDataResp");

            HandleGetServicesDataRespL(EIptvEngineSmGetServicesUsingIdDataResp);

            break;

        case EIptvEngineSmAddServiceResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmAddServiceResp");

            iClient.AddServiceResp(GetRespStatusL());

            break;

        case EIptvEngineSmDeleteServiceResp:

            IPTVLOGSTRING_HIGH_LEVEL("CIptvServiceManagementClient:: EIptvEngineSmDeleteServiceResp");

            iClient.DeleteServiceResp(GetRespStatusL());

            break;