/*

* 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:    Implements VoD ECG content API.*

*/

#include <e32svr.h>

#include <s32mem.h> 

#include "IptvDebug.h"

#include "CIptvMediaContent.h"

#include "MIptvVodContentClientObserver.h"

#include "CIptvVodContentClient.h"

#include "IptvClientServerCommon.h"

#include "IptvServer.pan"

#include "CIptvVodContentCategoryBriefDetails.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvVodContentUpdateObserver.h"

#include "CIptvMyVideosGlobalFileId.h"

#include "TIptvRssSearchQuery.h"

const TInt KTUint32SizeInBytes( 4 );

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

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

// CIptvVodContentClient::CIptvVodContentClient

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

// might leave.

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

CIptvVodContentClient::CIptvVodContentClient(TIptvServiceId aServiceId, MIptvVodContentClientObserver& aClientObserver) : 

    CActive( EPriorityStandard ), 

    iClientObserver( aClientObserver ), 

    iMsg(NULL), 

    iMsgPtr((unsigned char*)0, 0), 

    iServiceId(aServiceId), 

    iObserver(NULL)

    {

    CActiveScheduler::Add(this);

    }

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

// CIptvVodContentClient::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIptvVodContentClient::ConstructL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::ConstructL");         

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

    iObserver = CIptvVodContentUpdateObserver::NewL(iClientObserver, iSession, iServiceId);

    TRequestStatus status;

    SendRequestL(EIptvEngineVodContentServiceId, iServiceId, status);

    if (status.Int() != KErrNone)    

        {

        User::Leave(status.Int());

        }

    }

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

// CIptvVodContentClient::NewL

// Two-phased constructor.

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

//

EXPORT_C CIptvVodContentClient* CIptvVodContentClient::NewL(TIptvServiceId aServiceId, MIptvVodContentClientObserver& aClientObserver)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::NewL");         

	CIptvVodContentClient* self = new ( ELeave ) CIptvVodContentClient(aServiceId, aClientObserver);

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

    }

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

// CIptvVodContentClient::NewLC

// Two-phased constructor.

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

//

EXPORT_C CIptvVodContentClient *CIptvVodContentClient::NewLC(TIptvServiceId aServiceId, MIptvVodContentClientObserver& aClientObserver)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::NewLC");         

	CIptvVodContentClient* self = new ( ELeave ) CIptvVodContentClient(aServiceId, aClientObserver);

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

    }

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

// CIptvVodContentClient::~CIptvVodContentClient

// Destructor.

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

//

CIptvVodContentClient::~CIptvVodContentClient()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::~CIptvVodContentClient");         

    Cancel();         

    SendCancelRequest();

    delete iMsg;

    delete iObserver;   

    iSession.Close();                    

    }

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

// CIptvVodContentClient::CleanupL

// 

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

//

void CIptvVodContentClient::CleanupL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::CleanupL");

    delete iMsg;

    iMsg = NULL;

    }

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

// CIptvVodContentClient::GetEcgCategoryList

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

EXPORT_C TInt CIptvVodContentClient::GetEcgCategoryListL(TIptvCategoryId aParentCategoryId, RPointerArray<CIptvVodContentCategoryBriefDetails>& aCategoryList)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL");

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {        

        SendSizeRequestL(EIptvEngineVodContentGetEcgCategoryListSizeReq, aParentCategoryId, status);        

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {

            HandleVodContentGetEcgCategoryListSizeReqL();

            HandleVodContentGetEcgCategoryListDataReqL(aCategoryList);

            }

        }

#ifdef _DEBUG

    TInt count = aCategoryList.Count();

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL ----------------------------------------------------");

    IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL Parent id = %d", aParentCategoryId);

    IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL Category count = %d", count);

    for (TInt i = 0; i < count; i++)

        {

        TDesC& name = aCategoryList[i]->iName;

        IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL Category name = %S", &name);        

        IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL Category ID = %d", aCategoryList[i]->iCategoryId);        

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgCategoryListL ----------------------------------------------------");

#endif

    return status.Int();

    }

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

// CIptvVodContentClient::GetCategoryDetails

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

EXPORT_C TInt CIptvVodContentClient::GetCategoryDetailsL(TIptvCategoryId aCategoryId, CIptvVodContentCategoryBriefDetails& aCategory)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetCategoryDetailsL");         

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {       

        SendSizeRequestL(EIptvEngineVodContentGetCategoryDetailsSizeReq, aCategoryId, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();            

            }

        else

            {

            HandleVodContentGetCategoryDetailsSizeReqL();

            HandleVodContentGetCategoryDetailsDataReqL(aCategory);

            }

        }    

    return status.Int();

    }

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

// CIptvVodContentClient::GetParentCategory

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

EXPORT_C TInt CIptvVodContentClient::GetParentCategoryL(TIptvCategoryId aCategoryId, TIptvCategoryId& aParentId)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetParentCategoryL");         

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {        

        SendRequestL(EIptvEngineVodContentGetParentCategoryReq, aCategoryId, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {

            HandleVodContentGetParentCategoryReqL(aParentId);

            }

        }    

    return status.Int();

    }

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

// CIptvVodContentClient::GetEcgList

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

EXPORT_C TInt CIptvVodContentClient::GetEcgListL(TIptvCategoryId aCategoryId, TDesC& aSearchString, TUint32 aFrom, TUint32 aAmount, TUint32& aTotalAmount, RPointerArray<CIptvVodContentContentBriefDetails>& aEcgList)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgListL");         

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {        

        SendSizeRequestL(EIptvEngineVodContentGetEcgListSizeReq, aCategoryId, aFrom, aAmount, aSearchString, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {

            HandleVodContentGetEcgListSizeReqL();

            HandleVodContentGetEcgListDataReqL(aTotalAmount, aEcgList);

            }  

        }

#ifdef _DEBUG

    TInt count = aEcgList.Count();

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgListL ----------------------------------------------------");

    IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgListL Content info for category = %d", aCategoryId);

    IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgListL Item count = %d", count);

    for (TInt i = 0; i < count; i++)

        {

        TDesC& name = aEcgList[i]->iName;

        IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgListL Name = %S", &name);

        IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgListL GFID = %d", aEcgList[i]->iFileId->iFileId);                    

        IPTVLOGSTRING2_LOW_LEVEL("CIptvVodContentClient::GetEcgListL GDID = %d", aEcgList[i]->iFileId->iDrive);                    

        }

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgListL ----------------------------------------------------");

#endif

    return status.Int();  

    }

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

// CIptvVodContentClient::GetEcgAllList

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

EXPORT_C TInt CIptvVodContentClient::GetEcgAllListL(TDesC& aSearchString, TUint32 aFrom, TUint32 aAmount, TUint32& aTotalAmount, RPointerArray<CIptvVodContentContentBriefDetails>& aEcgList)

    {    

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetEcgAllListL");         

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {

        SendSizeRequestL(EIptvEngineVodContentGetEcgAllListSizeReq, aFrom, aAmount, aSearchString, status);    

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {            

            HandleVodContentGetEcgAllListSizeReqL();

            HandleVodContentGetEcgAllListDataReqL(aTotalAmount, aEcgList);

            }

        }

    return status.Int();

    }

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

// CIptvVodContentClient::GetContentDetails

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

EXPORT_C TInt CIptvVodContentClient::GetContentDetailsL(TIptvContentId aContentId, CIptvVodContentContentFullDetails& aContentFullDetails)

    {    

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetContentDetailsL");         

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {                

        SendSizeRequestL(EIptvEngineVodContentGetContentDetailsSizeReq, aContentId, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {            

            HandleVodContentGetContentDetailsSizeReqL();

            HandleVodContentGetContentDetailsDataReqL(aContentFullDetails);

            }

        }

    return status.Int();

    }

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

// CIptvVodContentClient::SetIapL

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

EXPORT_C TInt CIptvVodContentClient::SetIapL(const TUint32 aIap)

    {           

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::SetIapL");         

    TRequestStatus status(KErrNone);

    if (!IsActive())

        { 

        SendSizeRequestL(EIptvEngineVodContentSetIap, aIap, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        }

    return status.Int();

    }

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

// CIptvVodContentClient::UpdateEcg

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

EXPORT_C TInt CIptvVodContentClient::UpdateEcgL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::UpdateEcgL");

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {        

        SendRequestL(EIptvEngineVodContentUpdateEcg, 0, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        }

    return status.Int();

    }

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

// CIptvVodContentClient::CheckGroupL

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

EXPORT_C TInt CIptvVodContentClient::CheckGroupL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::CheckGroupL");

    TRequestStatus status( KErrNone );

    if ( !IsActive() )

        {        

        SendRequestL( EIptvEngineVodContentCheckGroup, 0, status );

        if ( status.Int() != KErrNone )

            {

            CleanupL();

            }

        }

    return status.Int();

    }

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

// CIptvVodContentClient::GetUpdateTimeL

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

EXPORT_C TInt CIptvVodContentClient::GetUpdateTimeL(TTime& aTime)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetUpdateTimeL");

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {

        SendUpdateTimeRequestL(status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {

            HandleVodContentGetUpdateTimeL(aTime);

            }

        }

    return status.Int();

    }

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

// CIptvVodContentClient::GetContentAccessListL

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

EXPORT_C TInt CIptvVodContentClient::GetContentAccessListL(TUint32 aContentId, RPointerArray<CIptvMediaContent>& aCAList)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetContentAccessListL");

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {        

        SendSizeRequestL(EIptvEngineVodContentGetCAListSizeReq, aContentId, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        else

            {

            HandleVodContentGetCAListSizeReqL();

            HandleVodContentGetCAListDataReqL(aCAList);

            }

        }   

    return status.Int();

    }

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

// CIptvVodContentClient::SetLastPositionL

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

EXPORT_C TInt CIptvVodContentClient::SetLastPositionL(TUint32 aContentId, TUint32 aIndex, TUint32 aPosition)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::GetContentAccessListL");

    TRequestStatus status(KErrNone);

    if (!IsActive())

        {        

        SendLastPositionL(EIptvEngineVodContentSetLastPosition, aContentId, aIndex, aPosition, status);

        if (status.Int() != KErrNone)

            {

            CleanupL();

            }

        }

    return status.Int();    

    }

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

// CIptvVodContentClient::SetMpxIdL

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

EXPORT_C TInt CIptvVodContentClient::SetMpxIdL( TUint32 aContentId,

                                                TUint32 aCaIndex,

                                                TUint32 aMpxId )

    {

    TRequestStatus status( KErrServerBusy );

    if ( !IsActive() )

        {        

        SendMpxIdL( EIptvEngineVodContentSetMpxId, aContentId, aCaIndex, aMpxId, status );

        if ( status.Int() != KErrNone )

            {

            CleanupL();

            }

        }

    return status.Int();    

    }

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

// CIptvVodContentClient::SendLastPositionL

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

void CIptvVodContentClient::SendLastPositionL(TInt aMessage, TUint32 aContentId, TUint32 aIndex, TUint32 aPosition, TRequestStatus& aStatus)

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::SendLastPositionL");

    delete iMsg;

    iMsg = NULL;

    iMsg = HBufC8::NewL(KIptvVodSendLastPositionSize);

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

    RDesWriteStream stream;

    stream.Open(iMsgPtr);

    CleanupClosePushL( stream );

    stream.WriteUint32L(aContentId);

    stream.WriteUint32L(aIndex);

    stream.WriteUint32L(aPosition);

    CleanupStack::PopAndDestroy( &stream );

    iSession.SendRequest(aMessage, iMsgPtr, aStatus);

    User::WaitForRequest(aStatus);

    }

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

// CIptvVodContentClient::SendMpxIdL

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

void CIptvVodContentClient::SendMpxIdL( TInt aMessage,

                                        TUint32 aContentId,

                                        TUint32 aCaIndex,

                                        TUint32 aMpxId,

                                        TRequestStatus& aStatus )

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::SendMpxIdL");

    delete iMsg;

    iMsg = NULL;

    iMsg = HBufC8::NewL( KIptvVodSendMpxIdSize );

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

    RDesWriteStream stream;

    stream.Open( iMsgPtr );

    CleanupClosePushL( stream );

    stream.WriteUint32L( aContentId );

    stream.WriteUint32L( aCaIndex);

    stream.WriteUint32L( aMpxId );

    CleanupStack::PopAndDestroy( &stream );

    iSession.SendRequest( aMessage, iMsgPtr, aStatus );

    User::WaitForRequest( aStatus );

    }

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

// CIptvVodContentClient::RunL

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

void CIptvVodContentClient::RunL()

    {

    IPTVLOGSTRING_LOW_LEVEL("CIptvVodContentClient::RunL");            

    }

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

// CIptvVodContentClient::DoCancel

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