// 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:
//

/**
 @internalComponent
*/

#include "ptpipdatatypes.h"
#include "cptpipdatacontainer.h"

// Dataset constants
const TUint CPTPIPDataContainer::KFlatChunkSize(12);

// Dataset element metadata.
const CMTPTypeCompoundBase::TElementInfo CPTPIPDataContainer::iElementMetaData[CPTPIPDataContainer::ENumElements] = 
    {
		{EIdFlatChunk,      EMTPTypeFlat,       {EMTPTypeUINT32,    0,                  KMTPTypeUINT32Size}},   // EContainerLength
        {EIdFlatChunk,      EMTPTypeFlat,       {EMTPTypeUINT32,    4,                  KMTPTypeUINT32Size}},   // EContainerType
        {EIdFlatChunk,      EMTPTypeFlat,       {EMTPTypeUINT32,    8,                  KMTPTypeUINT32Size}},   // ETransactionId
		{EIdPayloadChunk,   EMTPTypeUndefined,  {EMTPTypeUndefined, KMTPNotApplicable,  KMTPNotApplicable}}     // EPayload
    };

/**
 Generic Container's factory method. 
 This is used to create an empty MTP PTPIP data container dataset type. 
 @return  Ownership IS transfered.
 @leave One of the system wide error codes, if unsuccessful.
 */
EXPORT_C CPTPIPDataContainer* CPTPIPDataContainer::NewL()
	{
	CPTPIPDataContainer* self = new (ELeave) CPTPIPDataContainer();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/**
 Destructor.
 */
EXPORT_C CPTPIPDataContainer::~CPTPIPDataContainer()
	{
	iChunkHeader.Close();
	}

/**
 Constructor.
 */
CPTPIPDataContainer::CPTPIPDataContainer( ) :
	CMTPTypeCompoundBase((!KJustInTimeConstruction), EIdNumChunks), iChunkHeader(
			KFlatChunkSize, *this),
			iElementInfo(iElementMetaData, ENumElements),iIsNextHeader(EFalse)
	{
	
	}

/**
 Second phase constructor.
 */
void CPTPIPDataContainer::ConstructL( )
	{
	iChunkHeader.OpenL ( );
	ChunkAppendL (iChunkHeader );
	}

/**
 Provides the bulk container payload.
 @return The bulk container payload.
 */
EXPORT_C MMTPType* CPTPIPDataContainer::Payload() const
	{
	return iPayload;
	}

/**
 Sets the bulk container payload.
 @param aPayload The new bulk container payload.
 */
EXPORT_C void CPTPIPDataContainer::SetPayloadL(MMTPType* aPayload)
	{
	if (iPayload)
		{
		// Remove the existing payload from the super class.
		ChunkRemove(iElementMetaData[EPayload].iChunkId);
		}

	if (aPayload)
		{
		// Pass the payload to the super class for management.
		ChunkAppendL(*aPayload);
		}
	iPayload = aPayload;
	iIsNextHeader = EFalse; 
	}

EXPORT_C TUint CPTPIPDataContainer::Type() const
	{
	return EPTPIPTypeDataContainer;
	}

const CMTPTypeCompoundBase::TElementInfo& CPTPIPDataContainer::ElementInfo(
		TInt aElementId ) const
	{
	__ASSERT_DEBUG((aElementId < ENumElements), User::Invariant());
	return iElementInfo[aElementId];
	}
	
/**
  Over-ridden implementation of FirstWriteChunk() derived from CMTPTypeCompoundBase.
  This sets the Write Sequence-State to EInProgressNext, forcing the headers, from the second 
  PTP/IP packet onwards,to be ignored
  @param aChunk The data that is currently given by Initiator
 **/
EXPORT_C TInt CPTPIPDataContainer::FirstWriteChunk(TPtr8& aChunk)
	        {
	        TInt err(KErrNone);	        
	        
	        aChunk.Set(NULL, 0, 0);
	        
	        
	        if (iChunks.Count() == 0)
	            {
	            err = KErrNotFound;            
	            }
	        else
	            {
	            iWriteChunk = 0;
	            
	            TInt iWriteErr = iChunks[iWriteChunk]->FirstWriteChunk(aChunk);
	            
	            if ((iIsNextHeader) && (iWriteErr == KMTPChunkSequenceCompletion))
	            	iWriteErr = KErrNone;
	            
		        switch (iWriteErr)
		            {
		        case KMTPChunkSequenceCompletion:
		            if ((iWriteChunk + 1) < iChunks.Count()) 
		                {
		                iWriteSequenceState = EInProgressFirst;
		                err = KErrNone;
		                }
		            else
		                {
		                iWriteSequenceState = EIdle;                 
		                }
		            break;
		            
		        case KErrNone:
		            iWriteSequenceState = EInProgressNext;
		            break;
		            
		        default:
		            break;                      
	           } 
	            } 
	        
	        iIsNextHeader = ETrue;
	        
	        return err;
	        }

/**
  Over-ridden implementation of CommitChunkL() derived from CMTPTypeCompoundBase.
  This increments the number of chunks read only after, the first header is read
  @param aChunk The data that is currently given by Initiator
 **/
EXPORT_C MMTPType* CPTPIPDataContainer::CommitChunkL(TPtr8& aChunk)
	    {       
	    MMTPType *chunk(iChunks[iWriteChunk]);
	    MMTPType* res = NULL;
	    if (chunk->CommitRequired())
	        {
	        res = chunk->CommitChunkL(aChunk);
	        }
	        
	    
	    if (iWriteChunk == 0)
	        {
	        iWriteChunk++;            
	        }

	    return res;
	    }