// Copyright (c) 2001-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:

// Implements Multipart Mixed Loading Content Handler 'CMultiPartMixedContentHandler'

// 

//

// Local includes

//

#include "CMultiPartMixedContentHandler.h"

// System includes

#include "cmultiparttextiterator.h"

#include "pushdispatcher.h"

// Constants

_LIT(KReserved, "Reserved");

void CMultiPartMixedContentHandler::CPushHandlerBase_Reserved1()

	{

	User::Panic(KReserved, KErrNotSupported);

	}

void CMultiPartMixedContentHandler::CPushHandlerBase_Reserved2()

	{

	User::Panic(KReserved, KErrNotSupported);

	}

/**

 * Constructor

 *

 * @param aFs Reference to a file session

 * @param aLibrary Reference to DLL Library Object

 * @param aIndex Index number corresponding to the Unknown App Handler Class 'EMultiPartMixedContentHandler'

 */ 

CMultiPartMixedContentHandler::CMultiPartMixedContentHandler()

: CContentHandlerBase()

	{

	}

/**

 *  This will complete initialization of the object

 */

void CMultiPartMixedContentHandler::ConstructL()

	{

	CActiveScheduler::Add(this);

	}

/** 

 * Static Factory Construction

 *

 * @param aFs Reference to a file session

 * @param aLibrary Reference to DLL Library Object

 * @param aIndex Index number corresponding to the Unknown App Handler Class 'EMultiPartMixedContentHandler'

 *

 * @return fully initialized instance of this class

 */

CMultiPartMixedContentHandler* CMultiPartMixedContentHandler::NewL()

	{

	CMultiPartMixedContentHandler* self = new(ELeave) CMultiPartMixedContentHandler;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/** 

 * Destructor

 */

CMultiPartMixedContentHandler::~CMultiPartMixedContentHandler()

	{

	 __LOG_PTR_DEBUG("CMultiPartMixedContentHandler:: Destructor"); 

	 delete iMultiMessage;

	}

/** 

 * Creates a Multipart Binary Iterator that will be used for splitting apart the binary

 * mulitpart.

 *

 * @param aPushMsg A WAP binary multipart.mixed message that will be processed

 */

void CMultiPartMixedContentHandler::LoadMultipartMsgL()

	{

	__ASSERT_DEBUG( iMessage!= 0 , User::Panic(_L("NULL CPushMessage"),0));

	TPtrC contentType;

	iMessage->GetContentType(contentType);

	if (!contentType.FindF(KMultipartText))

		iMultiMessage = CMultipartTextIterator::NewL(*iMessage);

	else if (!contentType.FindF(KMultipartBin))

		iMultiMessage = CMultipartBinIterator::NewL(*iMessage);

	else

		User::Leave(KErrCorrupt);

	iMultiMessage->FirstL();

	iState = EHandlePart;

	IdleComplete();

	}

/** 

 * The Asynchronous entry point for this plug-in to handle the CPushMessage.

 * 

 * Since we really didn't start an async event, make it look as though our

 * asynchronous request has been completed. 

 *

 * @param aPushMsg A WAP binary multipart.mixed message that will be processed

 * @param aStatus The TRequestStatus of the caller indicating that this will be used aysnchronously

 */

void CMultiPartMixedContentHandler::HandleMessageL(CPushMessage* aPushMsg, TRequestStatus& aStatus)

	{

	 __LOG_PTR_DEBUG("CMultiPartMixedContentHandler:: HandleMessage Async"); 

	iAcknowledge = ETrue;

	iMessage = aPushMsg;

	SetConfirmationStatus(aStatus);

	iState = ELoadMsgData;

	IdleComplete();

	}

/** 

 * The Synchronous entry point for this plug-in to handle the CPushMessage.

 *

 * @param aPushMsg A WAP binary multipart.mixed message that will be processed

 * @param aStatus The TRequestStatus of the caller indicating that this will be used aysnchronously

 */

void CMultiPartMixedContentHandler::HandleMessageL(CPushMessage* aPushMsg)

	{

	 __LOG_PTR_DEBUG("CMultiPartMixedContentHandler:: HandleMessage Sync");

	iAcknowledge = EFalse;

	iMessage = aPushMsg;

	iState = ELoadMsgData;

	IdleComplete();

	}

/** 

 * Cancels Asynronous requests on called handler.

 */

void CMultiPartMixedContentHandler::CancelHandleMessage()

	{

	if(iContentHandler)

		iContentHandler->CancelHandleMessage();

	}

/** 

 * Cancels Asynronous requests on caller and completes self.

 */

void CMultiPartMixedContentHandler::DoCancel()

	{

	 __LOG_PTR_DEBUG("CMultiPartMixedContentHandler:: DoCancel");

	 if (iAcknowledge)

		User::RequestComplete(iConfirmStatus,KErrCancel);

	 Complete(KErrCancel);

	}

/** 

 * State machine to step through the multipart message until it is done

 *

 * State EHandlePart: Starts the processing of each part of the multipart

 * State ENextPart: Moves the interator to point to the next part of the multipart

 * when there are no more parts, EDone will be the next state

 * State EDone: Clean up and complete

 */

void CMultiPartMixedContentHandler::RunL()

	{

	switch(iState)

		{

		case ELoadMsgData:

			LoadMultipartMsgL();

			break;

		case EHandlePart:

			HandlePartL();

			break;

		case ENextPart:

			NextPartL();

			break;

		case EDone:

			Complete(KErrNone);

			break;

		default:

			break;

		}

	}

/** 

 * Clean up

 */

TInt CMultiPartMixedContentHandler::RunError(TInt aError)

	{

	__LOG_PTR_DEBUG("CMultiPartMixedContentHandler::RunError Called"); 

	iState=EDone;

	Complete(aError);

	return KErrNone;

	}

/**

 *	Handles the Message Part returned from the Multipart iterator

 *  by creating a new handler based on the Content-Type, then dispatches it

 *  synchronously.

 */

void CMultiPartMixedContentHandler::HandlePartL()

	{

	 __LOG_PTR_DEBUG("CMultiPartMixedContentHandler:: HandlePart"); 

	CPushMessage* msgPart = iMultiMessage->PartL();

	CleanupStack::PushL(msgPart);

	TPtrC contentType;

	msgPart->GetContentType(contentType);

	CContentHandlerBase& contentHandler = PushContentTypeDispatcher::GetHandlerL(contentType, *iLog, *iManager);

	iContentHandler = &contentHandler;

	CleanupStack::Pop(msgPart);

	// treat as an acknowledged message always to ensure 

	// sequential creation of handlers

	iContentHandler->HandleMessageL(msgPart, iStatus);

	iState = ENextPart;

	SetActive();

	}

/**

 *	Moves multipart iterator to the next part. If there is none,

 *  State: EDone will be set to complete this handler

 */

void CMultiPartMixedContentHandler::NextPartL()

	{

	 __LOG_PTR_DEBUG("CMultiPartMixedContentHandler:: NextPartL");

	if (iMultiMessage->NextL())

		iState = EHandlePart;

	else 

		iState = EDone;

	IdleComplete();

	}