// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// This file contains all the code for the retrieval classes which retrieve variable length 

// buffers from the TSY, such as MBMS monitor service list and MBMS sessions. 

// 

//

/**

 @file

*/

#include "pcktretrieve.h"

#include <pcktcs.h>

#include <etelext.h>

//

//

// Retrieve a list of MBMS monitored service entries 

//

//

EXPORT_C CRetrievePcktMbmsMonitoredServices* CRetrievePcktMbmsMonitoredServices::NewL(RPacketService& aService)

/** Creates an instance of the CActive derived CRetrievePcktMbmsMonitoredServices 

 * class.

 * @param aService An instance of RPacketService over which the list retrieval class operates.

 * @return The newly created CRetrievePcktMbmsMonitoredServices class. 

 * @capability None

 */

	{

	CRetrievePcktMbmsMonitoredServices* self = new(ELeave) CRetrievePcktMbmsMonitoredServices(aService);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CRetrievePcktMbmsMonitoredServices::CRetrievePcktMbmsMonitoredServices(RPacketService& aService) 

:	CAsyncRetrieveWithClientIds(aService.SessionHandle().Handle(), aService.SubSessionHandle()),

	iService(aService)

/**

 * Standard constructor; initialises the data members. 

 */

	{

	}

void CRetrievePcktMbmsMonitoredServices::ConstructL()

/**

 * Part of 2 phase construction, assigns the IPCs to be used 

 * in 2 phase retrieval mechanism.

 */

	{

	iIpcPhase1=EPacketGetMbmsMonitoredServicesPhase1;

	iIpcPhase2=EPacketGetMbmsMonitoredServicesPhase2;

	iIpcCancel=EPacketGetMbmsMonitoredServicesCancel;

	}

EXPORT_C CRetrievePcktMbmsMonitoredServices::~CRetrievePcktMbmsMonitoredServices()

/** 

 * The destructor frees all resources owned by the object, prior to its destruction.

 */

	{

	Cancel();

	delete iResults;

	}

EXPORT_C CPcktMbmsMonitoredServiceList* CRetrievePcktMbmsMonitoredServices::RetrieveListL()

/** 

 * Provides the client with a handle to the appropriate 

 * MBMS service availability list class retrieved. The client will call this function 

 * once Start() has completed.

 * The ownership of the list object is transferred to the client and the client 

 * is responsible for eventual deletion of this object.	 

 *

 * @leave KErrNotFound If there is no valid list object to return to the client.

 * @return A handle to the list class retrieved from the store. If there are no entries in 

 * the list then a handle to an empty list is returned.

 * @capability ReadDeviceData

 */

	{

	if (iResults)

		{

		// Give ownership of list to caller of this method

		CPcktMbmsMonitoredServiceList* ptr=iResults;

		iResults = NULL;

		return ptr;

		}

	else

		{

		User::Leave(KErrNotFound);

		return NULL;

		}

	}

EXPORT_C void CRetrievePcktMbmsMonitoredServices::Start(TRequestStatus& aReqStatus)

/** Starts the two-phase list retrieval of all entries within the store.

 * 

 * @param aReqStatus On completion, the status of the request; KErrNone if successful, 

 * KErrNotSupported if the phone does not support access to an MBMS service availability list  

 * and KErrNotFound if the list does not exist. If the list is empty then KErrNone

 * is returned.

 * @capability ReadDeviceData

 */

	{

	if (!CompleteIfInUse(aReqStatus))

		{

	   	delete iResults;

		iResults = NULL;

		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId);

		}

	}

void CRetrievePcktMbmsMonitoredServices::RestoreListL()

/**

 * Restores a list from a buffer that contains the streamed version of the list

 */

	{

	iResults=CPcktMbmsMonitoredServiceList::NewL();

	iResults->RestoreL(iResultsPtr);

	FreeBuffer();

	}

void CRetrievePcktMbmsMonitoredServices::CancelReq(TInt aIpc1, TInt aIpc2)

/**

 *  Cancels previously issued request

 */

	{

	iService.CancelReq(aIpc1, aIpc2);

	}

void CRetrievePcktMbmsMonitoredServices::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2)

/** 

 * Sends a request through the sub-session this object was created with.

 */

	{

	iService.Get(aIpc, aReqStatus, aDes1, aDes2);

	}

CAsyncRetrieveWithClientIds::CAsyncRetrieveWithClientIds(TInt aSessionHandle, TInt aSubSessionHandle)

	{

	iId().iSessionHandle = aSessionHandle;

	iId().iSubSessionHandle = aSubSessionHandle;

	}

EXPORT_C CRetrievePcktMbmsSessionList* CRetrievePcktMbmsSessionList::NewL(RPacketMbmsContext& aPcktMbmsContext, RPacketMbmsContext::CMbmsSession& aSessionIdList)

/**

 * Standard 2 phase constructor.

 * @param aPcktMbmsContext Reference to an open MBMS packet context object.

 * @param aSessionIdList On completion this holds the list of MBMS sessions.

 * @return Pointer instance of the class.

 */

	{

	return new (ELeave)CRetrievePcktMbmsSessionList(aPcktMbmsContext, aSessionIdList);

	}

EXPORT_C void CRetrievePcktMbmsSessionList::Start(TRequestStatus& aReqStatus)

/**

 * Starts the 2 phase retrieval. Assigns the IPCs to be used for the 2-phase retrieval mechanism.

 * @param aReqStatus On return, KErrNone if successful.

 * @capability ReadDeviceData

 */

	{

	if (!CompleteIfInUse(aReqStatus))

		{

		iIpcPhase1=EPacketGetMbmsSessionListPhase1;

		iIpcPhase2=EPacketGetMbmsSessionListPhase2;

		iIpcCancel=EPacketGetMbmsSessionListCancel;

		CAsyncRetrieveVariableLengthBufferV2::Start(aReqStatus,&iId,&iId); 

		}

	}

void CRetrievePcktMbmsSessionList::Get(TInt aIpc, TRequestStatus& aReqStatus, TDes8& aDes1, TDes8& aDes2)

/**

 * Issues requested IPC to the ETEL/TSY

 */

	{

	iPcktMbmsContext.Get(aIpc, aReqStatus, aDes1, aDes2);

	}

void CRetrievePcktMbmsSessionList::CancelReq(TInt aIpc1, TInt aIpc2)

/**

 * Cancels previously issued request

 */

	{

	iPcktMbmsContext.CancelReq(aIpc1,aIpc2);

	}

void CRetrievePcktMbmsSessionList::RestoreListL()

/**

 * Overload of base class virtual method; de-serializes data retrieved from TSY to 

 * provided data structure.

 */

	{

	iSessionIdList.InternalizeL(iResultsPtr);

	FreeBuffer();

	}

CRetrievePcktMbmsSessionList::CRetrievePcktMbmsSessionList(RPacketMbmsContext& aPcktMbmsContext,RPacketMbmsContext::CMbmsSession& aSessionIdList)

:iPcktMbmsContext(aPcktMbmsContext),iSessionIdList(aSessionIdList)

/**

 * Standard constructor; initialises data members and the base class

 */	

	{

	iId().iSessionHandle=iPcktMbmsContext.SessionHandle().Handle();

	iId().iSubSessionHandle=iPcktMbmsContext.SubSessionHandle();

	}