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

/**
@file
@internalComponent
*/

#include <mtp/cmtptypeservicepropdesclist.h>
#include <mtp/mtpdatatypeconstants.h>
#include <mtp/mtpprotocolconstants.h>

#include "mtpdatatypespanic.h"

// Dataset constants

const TUint CMTPTypeServicePropDesc::KFlat1ChunkSize(6);
const TUint CMTPTypeServicePropDesc::KNumChunksWithoutForm(EIdFlat1Chunk + 1);
const TUint CMTPTypeServicePropDesc::KNumChunksWithForm(EIdFormChunk + 1);

//Dataset element metadata    
const CMTPTypeCompoundBase::TElementInfo CMTPTypeServicePropDesc::iElementMetaData[CMTPTypeServicePropDesc::ENumElements] = 
    {
        {EIdFlat1Chunk,       EMTPTypeFlat,       {EMTPTypeUINT16,    0,                  KMTPTypeUINT16Size}},   // EServicePropertyCode
        {EIdFlat1Chunk,       EMTPTypeFlat,       {EMTPTypeUINT16,    2,                  KMTPTypeUINT16Size}},   // EDataType1
        {EIdFlat1Chunk,       EMTPTypeFlat,       {EMTPTypeUINT8,     4,                  KMTPTypeUINT8Size}},   // EGetSet1
        {EIdFlat1Chunk,       EMTPTypeFlat,       {EMTPTypeUINT8,     5,                  KMTPTypeUINT8Size}},    // EFormFlag
        {EIdFormChunk,        EMTPTypeReference,  {EMTPTypeUndefined, KMTPNotApplicable,  KMTPNotApplicable}},    // EForm
    };



EXPORT_C CMTPTypeServicePropDescList* CMTPTypeServicePropDescList::NewL()
    {
    CMTPTypeServicePropDescList* self = CMTPTypeServicePropDescList::NewLC(); 
    CleanupStack::Pop(self);
    return self;  
    }


EXPORT_C CMTPTypeServicePropDescList* CMTPTypeServicePropDescList::NewLC()
    {
    CMTPTypeServicePropDescList* self = new(ELeave) CMTPTypeServicePropDescList();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

/**
Destructor.
*/
EXPORT_C CMTPTypeServicePropDescList::~CMTPTypeServicePropDescList()
    {
    
    }

CMTPTypeServicePropDescList::CMTPTypeServicePropDescList() :
CMTPTypeList(EMTPTypeServicePropDescList,EMTPTypeServicePropDesc)
    {
    }

void CMTPTypeServicePropDescList::ConstructL()
    {
    InitListL();
    }

EXPORT_C void CMTPTypeServicePropDescList::AppendL(CMTPTypeServicePropDesc* aElement)
    {
    CMTPTypeList::AppendL(aElement);
    }

EXPORT_C CMTPTypeServicePropDesc& CMTPTypeServicePropDescList::ElementL(TUint aIndex) const
    {
    return static_cast<CMTPTypeServicePropDesc&>( CMTPTypeList::ElementL(aIndex) );
    }

/**
MTP Service Object Property Extension FORM dataset factory method. This method is used to 
create an empty MTP Service Object Property Extension FORM  of the specified Datatype. 
@return A pointer to the form type. Ownership IS 
transfered.
@leave One of the system wide error codes, if unsuccessful.
*/ 
EXPORT_C  CMTPTypeServicePropDesc* CMTPTypeServicePropDesc::NewL()
    {
    CMTPTypeServicePropDesc* self = CMTPTypeServicePropDesc::NewLC();
    CleanupStack::Pop(self); 
    return self;
    }
/**
MTP DevicePropDesc  Service Object Property Extension FORM  factory method. This method is used to 
create an empty MTP Service Object Property Extension FORM  of the specified Datatype. 
@return A pointer to the form type. Ownership IS 
transfered.
@leave One of the system wide error codes, if unsuccessful.
*/
EXPORT_C  CMTPTypeServicePropDesc* CMTPTypeServicePropDesc::NewLC()
    {
    CMTPTypeServicePropDesc* self = new(ELeave) CMTPTypeServicePropDesc();
    CleanupStack::PushL(self);
    const TUint16 KUndefinedCode = 0; 
    self->ConstructL( KUndefinedCode , EMTPTypeUndefined,CMTPTypeObjectPropDesc::EReadOnly , CMTPTypeObjectPropDesc::ENone, NULL );
    return self;
    }
   
EXPORT_C  CMTPTypeServicePropDesc* CMTPTypeServicePropDesc::NewL( const TUint16  aServicePropCode, const TUint16 aDataType, const TUint8 aGetSet, const TUint8 aFormFlag, const MMTPType* aForm )
    {
    CMTPTypeServicePropDesc* self = CMTPTypeServicePropDesc::NewLC( aServicePropCode, aDataType, aGetSet, aFormFlag, aForm );
    CleanupStack::Pop(self); 
    return self;
    }
   
  
EXPORT_C  CMTPTypeServicePropDesc* CMTPTypeServicePropDesc::NewLC( const TUint16  aServicePropCode, const TUint16 aDataType, const TUint8 aGetSet, const TUint8 aFormFlag, const MMTPType* aForm)
    {
    CMTPTypeServicePropDesc* self = new(ELeave) CMTPTypeServicePropDesc();
    CleanupStack::PushL(self);
    self->ConstructL( aServicePropCode, aDataType, aGetSet, aFormFlag, aForm );
    return self;
    }


/**
Destructor.
*/
EXPORT_C CMTPTypeServicePropDesc::~CMTPTypeServicePropDesc()
    {
    iChunkFlat1.Close();
    iChunkForm.Close();
    }

CMTPTypeServicePropDesc::CMTPTypeServicePropDesc() : 
    CMTPTypeCompoundBase((KJustInTimeConstruction), KNumChunksWithoutForm),
    iElementInfo(iElementMetaData, ENumElements),
    iChunkFlat1(KFlat1ChunkSize, *this)
    {

    }

EXPORT_C TUint CMTPTypeServicePropDesc::Type() const
    {
    return EMTPTypeServicePropDesc;
    } 



EXPORT_C TInt CMTPTypeServicePropDesc::FirstWriteChunk(TPtr8& aChunk)
    {
    /* 
    Reset the type in preparation for the data stream, by deleting all
    except the first chunk.
    */
    for (TUint i(ChunkCount() - 1); (i >= (EIdFlat1Chunk + 1)); i--)
      {
      ChunkRemove(i);
      }
      
    // Setup the write chunk pointer.
       TInt err(CMTPTypeCompoundBase::FirstWriteChunk(aChunk));
       switch (err)
           {
       case KMTPChunkSequenceCompletion:
           err = KErrNone;
           // Don't break, fall through to set the write sequence state.
           
       case KErrNone:
           // Set the write sequence state.
           iWriteSequenceState = EFormChunk;
           iWriteSequenceCompletionState = EFormChunk;
           break;
           
       default:
           break;
           }
      
    return  err;
    }

EXPORT_C TInt CMTPTypeServicePropDesc::NextWriteChunk(TPtr8& /*aChunk*/)
    {
        return KMTPChunkSequenceCompletion;
    }


EXPORT_C TBool CMTPTypeServicePropDesc::CommitRequired() const
    {
    return ETrue;
    }


EXPORT_C MMTPType* CMTPTypeServicePropDesc::CommitChunkL(TPtr8& aChunk)
    {
        switch (iWriteSequenceState)
            {
        case EFormChunk:
            {
            iChunkForm.Close();
            TUint8 flag(Uint8L(EFormFlag));
            TUint16 type(Uint16L(EDataType1));
            iChunkForm.SetMeta(flag, type);
            if (HasFormField(flag))
                {
                iChunkForm.OpenL(iElementInfo[EForm].iType);
                ChunkAppendL(iChunkForm);
                SetExpectedChunkCount(KNumChunksWithForm);
                }
            else
                {
                // Adjust the write sequence completion state.            
                iWriteSequenceCompletionState = EFormChunk;
                }   
            }
            break;
            
        case EIdle:
            // Completing the last element in the write sequence.
            break;
            
        default:
            Panic(EMTPTypeBadStorage);
            break;
            }
        
    if ( (iWriteSequenceState != EIdle ) && (iWriteSequenceState < iWriteSequenceCompletionState) )
        {
        iWriteSequenceState++;
        }
    else
        {
        iWriteSequenceState = EIdle;
        }

        
    if (CMTPTypeCompoundBase::CommitRequired())
        {
        CMTPTypeCompoundBase::CommitChunkL(aChunk);
        }
    return NULL;
    }


TBool CMTPTypeServicePropDesc::HasFormField(TUint8 aFormFlag) const
    {
    return ((aFormFlag != CMTPTypeObjectPropDesc::EDateTimeForm) && (aFormFlag != CMTPTypeObjectPropDesc::ENone)&&(aFormFlag != CMTPTypeObjectPropDesc::EObjectIDForm));
    }


const CMTPTypeCompoundBase::TElementInfo& CMTPTypeServicePropDesc::ElementInfo(TInt aElementId) const
    {
    __ASSERT_ALWAYS((aElementId < ENumElements), Panic(EMTPTypeBoundsError));
    
    return iElementInfo[aElementId];  
    }

void CMTPTypeServicePropDesc::ConstructL( const TUint16  aServicePropCode, const TUint16 aDataType, const TUint8 aGetSet, const TUint8 aFormFlag, const MMTPType* aForm )
    {  
    for (TUint i(0); (i < ENumElements); i++)
       {
       const TElementInfo& element(iElementInfo[i]);
       if (ChunkCount() <= element.iChunkId)
           {
           MMTPType* chunk(NULL);
           switch (element.iChunkId)
               {
           case EIdFlat1Chunk:
               iChunkFlat1.OpenL();
               chunk = &iChunkFlat1;
               break;
               
           case EIdFormChunk:
               iChunkForm.SetMeta(aFormFlag, aDataType);
               if (HasFormField(aFormFlag))
                   {
                   iChunkForm.OpenL(element.iType);
                   chunk = &iChunkForm;
                   SetExpectedChunkCount(KNumChunksWithForm);
                   }
               break;
               
           default:
               Panic(EMTPTypeBoundsError);
               break;
               }
           if (chunk)
               {
               ChunkAppendL(*chunk);   
               }
           }
       }
    
    // Set the construction values.
    SetUint16L( EServicePropertyCode, aServicePropCode );
    SetUint16L( EDataType1, aDataType );
    SetUint8L( EGetSet1, aGetSet );
    SetUint8L(EFormFlag, aFormFlag);
    
    if (aForm)
        {
        if (!HasFormField(aFormFlag))
            { 
            User::Leave(KMTPDataTypeInvalid);
            } 
        else
            {
            SetL(EForm, *aForm); 
            }
        }
    }