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

// GsmuMsgAdditionalAttributes.cpp

// 

//

#include "gsmumsgadditionalattributes.h"

#include "smsstacklog.h"

CSmsMessageAdditionalAttributes* CSmsMessageAdditionalAttributes::NewL()

    {

	CSmsMessageAdditionalAttributes* additionalAttributes=new(ELeave) CSmsMessageAdditionalAttributes();

	CleanupStack::PushL(additionalAttributes);

	additionalAttributes->ConstructL();

	CleanupStack::Pop();

	return additionalAttributes;

    } // CSmsMessageAdditionalAttributes::NewL

CSmsMessageAdditionalAttributes::CSmsMessageAdditionalAttributes()

    {

    // NOP

    } // CSmsMessageAdditionalAttributes::CSmsMessageAdditionalAttributes

CSmsMessageAdditionalAttributes::~CSmsMessageAdditionalAttributes()

    {

	iSmsPDUArray.ResetAndDestroy();

    for (TInt category = 0; category < TSmsInformationElementCategories::ENumberOfCategories; category++)

        {

        if (iCollectionOfPointersToIEArrays[category] != NULL)

            {

            iCollectionOfPointersToIEArrays[category]->ResetAndDestroy();

            }

        delete iCollectionOfPointersToIEArrays[category];

        }

    delete iHyperLinkOperations;

    delete iReplyAddressOperations;

    delete iSpecialSMSMessageOperations;

    delete iEnhancedVoiceMailOperations;

    delete iSMSCCtrlParameterOperations;

    delete iTPSRROperations;

    delete iStatusReportScheme;

    delete iIncompleteClass0MessageInfo;

    } // CSmsMessageAdditionalAttributes::CSmsMessageAdditionalAttributes

void CSmsMessageAdditionalAttributes::ConstructL()

    {

    iStatusReportScheme = new (ELeave) CSmsMessageAdditionalAttributes::CDefaultScheme();

    for (TInt category = 0; category < TSmsInformationElementCategories::ENumberOfCategories; category++)

        {

        iCollectionOfPointersToIEArrays[category] = new (ELeave) CArrayOfPointersToControlInformationElements(8);

        }

    } // CSmsMessageAdditionalAttributes::ConstructL

void CSmsMessageAdditionalAttributes::AddControlInformationElementL(CSmsInformationElement* aIE)

    {

    TSmsInformationElementCategories::TInformationElementCategory category;

    if (aIE != NULL)

        {

        if (TSmsInformationElementCategories::GetCategoryDefinition(aIE->Identifier(), category))

        	{

        	AddControlInformationElementL(category,aIE);

        	}

        else

            {

            User::Leave(KErrArgument);

            }

        }

    else

        {

        User::Leave(KErrArgument);

        }

    } // CSmsMessageAdditionalAttributes::AddControlInformationElementL

TBool CSmsMessageAdditionalAttributes::Find1stInstanceOfControlInformationElement(TInformationElementId aId, TUint& aIndex) const

    {

    TBool rc = EFalse;

    TSmsInformationElementCategories::TInformationElementCategory category;

    if (TSmsInformationElementCategories::GetCategoryDefinition(aId, category))

    	{

		TInt count=iCollectionOfPointersToIEArrays[category]->Count();

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

		    {

		    if (iCollectionOfPointersToIEArrays[category]->operator[](i)->Identifier()==aId)

		        {

		        aIndex=i;

		        rc=ETrue;

		        break;

		        }

		    }

        }

    return rc;

    } // CSmsMessageAdditionalAttributes::Find1stInstanceOfControlInformationElement

TBool CSmsMessageAdditionalAttributes::FindNextInstanceOfControlInformationElement(TInformationElementId aId, TUint aStartIndex, TUint& aIndex) const

    {

    TBool rc = EFalse;

    TSmsInformationElementCategories::TInformationElementCategory category;

	if (TSmsInformationElementCategories::GetCategoryDefinition(aId, category))

		{

	    TInt count=iCollectionOfPointersToIEArrays[category]->Count();

		for (TInt i =aStartIndex + 1; i<count; i++)

		    {

		    if (iCollectionOfPointersToIEArrays[category]->operator[](i)->Identifier()==aId)

		        {

				aIndex=i;

				rc=ETrue;

	            break;

				}

		    }

		}

    return rc;

    } // CSmsMessageAdditionalAttributes::FindNextInstanceOfControlInformationElement

CSmsInformationElement& CSmsMessageAdditionalAttributes::GetControlInformationElementL(TInformationElementId aId, TUint aIndex) const

    {

    TSmsInformationElementCategories::TInformationElementCategory category;

    if (TSmsInformationElementCategories::GetCategoryDefinition(aId, category) == EFalse)

    	{

    	User::Leave(KErrArgument);

    	}

    if (aIndex >= iCollectionOfPointersToIEArrays[category]->Count())

        {

        User::Leave(KErrArgument);

        }

    if (iCollectionOfPointersToIEArrays[category]->operator[](aIndex) == NULL)

        {

        User::Leave(KErrArgument);

        }

    if (iCollectionOfPointersToIEArrays[category]->operator[](aIndex)->Identifier()!=aId)

        {

        User::Leave(KErrArgument);

        }

    CSmsInformationElement* ie = iCollectionOfPointersToIEArrays[category]->operator[](aIndex);

    return *ie;

    } // CSmsMessageAdditionalAttributes::GetControlInformationElementL

TBool CSmsMessageAdditionalAttributes::RemoveControlInformationElement(TInformationElementId aId, TUint aIndex, CSmsInformationElementPtr& aIE)

    {

    TBool rc = EFalse;

    TSmsInformationElementCategories::TInformationElementCategory category;

	if (TSmsInformationElementCategories::GetCategoryDefinition(aId, category))

		{

		if ((iCollectionOfPointersToIEArrays[category]->Count() > aIndex) &&

		    (iCollectionOfPointersToIEArrays[category]->operator[](aIndex)->Identifier()==aId))

		        {

		        aIE = iCollectionOfPointersToIEArrays[category]->operator[](aIndex);

		        iCollectionOfPointersToIEArrays[category]->Delete(aIndex);

		        rc = ETrue;

		        }

		}

    return rc;

    } // CSmsMessageAdditionalAttributes::RemoveControlInformationElement

void CSmsMessageAdditionalAttributes::AddControlInformationElementL(TCategory aCategory, CSmsInformationElementPtr aIE)

    {

    if ((aIE != NULL) &&

        (aCategory < TSmsInformationElementCategories::ENumberOfCategories))

        {

        iCollectionOfPointersToIEArrays[aCategory]->AppendL(aIE);

        }

    else

        {

        User::Leave(KErrArgument);

        }

    } // CSmsMessageAdditionalAttributes::AddControlInformationElementL

TBool CSmsMessageAdditionalAttributes::RemoveNextControlInformationElement(TCategory aCategory, CSmsInformationElementPtr& aIEPtr)

    {

    TBool rc = EFalse;

    if (aCategory < TSmsInformationElementCategories::ENumberOfCategories)

        {

        TInt tailIndex;

        if ((tailIndex = (iCollectionOfPointersToIEArrays[aCategory]->Count() - 1)) >= 0)

            {

            aIEPtr = (*iCollectionOfPointersToIEArrays[aCategory])[tailIndex];

            iCollectionOfPointersToIEArrays[aCategory]->Delete(tailIndex);

            rc = ETrue;

            }

        }

    return rc;

    } // CSmsMessageAdditionalAttributes::RemoveNextControlInformationElement

CSmsInformationElement& CSmsMessageAdditionalAttributes::GetControlInformationElementL(TCategory aCategory, TUint aIndex) const

    {

    if ((aCategory >= TSmsInformationElementCategories::ENumberOfCategories) ||

        (aIndex    >= iCollectionOfPointersToIEArrays[aCategory]->Count()))

        {

        User::Leave(KErrArgument);

        }

    if  ((iCollectionOfPointersToIEArrays[aCategory])->operator[](aIndex) == NULL)

        {

        User::Leave(KErrCorrupt);

        }

    return *(iCollectionOfPointersToIEArrays[aCategory]->operator[](aIndex));

    } // CSmsMessageAdditionalAttributes::GetControlInformationElementL

void CSmsMessageAdditionalAttributes::DeleteControlInformationElement(TCategory aCategory, TUint8 aIndex)

    {

    if (aCategory < TSmsInformationElementCategories::ENumberOfCategories)

        {

        TInt count = iCollectionOfPointersToIEArrays[aCategory]->Count();

        if (aIndex < count)

            {

            CSmsInformationElement* iE = iCollectionOfPointersToIEArrays[aCategory]->operator[](aIndex);

            iCollectionOfPointersToIEArrays[aCategory]->Delete(aIndex);

			// The element being deleted has been removed from iCollectionOfPointersToIEArrays. So, next time it cannot be deleted again.

			// coverity[double_free]

            delete iE;

            }

        }

    } // CSmsMessageAdditionalAttributes::DeleteControlInformationElement

TUint CSmsMessageAdditionalAttributes::NumberOfControlInformationElements(TCategory aCategory) const

    {

    TUint count = 0;

    if (aCategory < TSmsInformationElementCategories::ENumberOfCategories)

    {

      count = iCollectionOfPointersToIEArrays[aCategory]->Count();

    }

    return count;

    } // CSmsMessageAdditionalAttributes::NumberOfControlInformationElements

void CSmsMessageAdditionalAttributes::ExternalizeL(RWriteStream& aStream, TInt aVersion) const

    {

	if(aVersion == CSmsMessage::ESmsIncompleteClass0MessageV)

		{

		iIncompleteClass0MessageInfo->ExternalizeL(aStream);

		return;

		}

    for (TInt category = 0; category < TSmsInformationElementCategories::ENumberOfCategories; category++)

        {

        TUint32 count = iCollectionOfPointersToIEArrays[category]->Count();

		aStream.WriteUint32L(count);

        for (TUint32 j = 0; j < count; j++)

            {

            iCollectionOfPointersToIEArrays[category]->operator[](j)->ExternalizeL(aStream);

            }

        }

    if (aVersion == CSmsMessage::ESmsMessageV2  ||

    	aVersion == CSmsMessage::ESmsMessageV3  ||

    	aVersion == CSmsMessage::ESmsMessageV4)	// Status Report Scheme

		{

		aStream.WriteInt16L(iStatusReportScheme->Id());			//The Scheme

		if(iStatusReportScheme->Id() == ETPSRRScheme)

			{

			CTPSRRScheme* scheme = (CTPSRRScheme*)iStatusReportScheme;

			TUint32 count = (scheme->iTPSRRStatusReport).Count();	// TPSRR Array Count

			aStream << count;

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

				{

				aStream.WriteUint16L((scheme->iTPSRRStatusReport[ii]).iSegmentSequenceNum);	// Segment number

				aStream.WriteInt16L((scheme->iTPSRRStatusReport[ii]).iTPSRRStatus);			// TPSRR Bit

				}

			aStream.WriteInt16L(scheme->iDefaultStatusReport);		// Default

			aStream.WriteInt16L(scheme->iNumOfPDUs);

			}

		if(iStatusReportScheme->Id() == EControlParametersScheme)

			{

			CControlParametersScheme* scheme = (CControlParametersScheme*)iStatusReportScheme;

			TUint32 count = (scheme->iControlParametersStatusReport).Count();	// Control Params Array Count

			aStream << count;

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

				{

				aStream.WriteUint16L((scheme->iControlParametersStatusReport[ii]).iSegmentSequenceNum);	// Segment number

				aStream.WriteInt8L((scheme->iControlParametersStatusReport[ii]).iSelectiveStatus);			// Selective Status

				}

			aStream.WriteInt8L(scheme->iDefaultStatusReport);		// Default

			aStream.WriteInt16L(scheme->iNumOfPDUs);

			}	

		}

    // CSmsMessage::ESmsMessageV3 is the same as CSmsMessage::ESmsIncompleteClass0MessageV!

    if (aVersion == CSmsMessage::ESmsMessageV4)	// National language 7bit encoding support

		{

		aStream.WriteInt32L(iAlternative7bitEncoding);

		}

	}

void CSmsMessageAdditionalAttributes::InternalizeL(RReadStream& aStream, TInt aVersion)

    {

	if(aVersion == CSmsMessage::ESmsIncompleteClass0MessageV)

		{

		iIncompleteClass0MessageInfo->InternalizeL(aStream);

		return;

		}

    for (TInt category = 0; category < TSmsInformationElementCategories::ENumberOfCategories; category++)

        {

        TUint32 count = aStream.ReadInt32L();

        iCollectionOfPointersToIEArrays[category]->ResetAndDestroy();

        for (TInt32 j = 0; j < count; j++)

            {

            CSmsInformationElement* informationElement = CSmsInformationElement::NewL();

            CleanupStack::PushL(informationElement);

            aStream >> *informationElement;

            iCollectionOfPointersToIEArrays[category]->AppendL(informationElement);

            CleanupStack::Pop();

            }	

    	}

    if (aVersion == CSmsMessage::ESmsMessageV2  ||

    	aVersion == CSmsMessage::ESmsMessageV3  ||

    	aVersion == CSmsMessage::ESmsMessageV4)	// Status Report Scheme

		{

		TSmsStatusReportScheme schemeId = static_cast<TSmsStatusReportScheme>(aStream.ReadInt16L());

		if(schemeId == ETPSRRScheme)

			{

			SetStatusReportSchemeL(ETPSRRScheme);

			CTPSRRScheme* scheme = (CTPSRRScheme*)iStatusReportScheme;

			TUint32 count = aStream.ReadInt32L();

			CSmsMessageAdditionalAttributes::CTPSRRScheme::TSmsTPSRRStatus tpsrrStatus;

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

				{

				tpsrrStatus.iSegmentSequenceNum = aStream.ReadUint16L();	// Segment number

				tpsrrStatus.iTPSRRStatus = static_cast<TSmsFirstOctet::TSmsStatusReportRequest>(aStream.ReadInt16L());	// TPSRR Bit

				(scheme->iTPSRRStatusReport).AppendL(tpsrrStatus);

				}

			scheme->iDefaultStatusReport = static_cast<TSmsFirstOctet::TSmsStatusReportRequest>(aStream.ReadInt16L());

			scheme->iNumOfPDUs = aStream.ReadInt16L();

			}

		if(schemeId == EControlParametersScheme)

			{

			SetStatusReportSchemeL(EControlParametersScheme);

			CControlParametersScheme* scheme = (CControlParametersScheme*)iStatusReportScheme;

			TUint32 count = aStream.ReadInt32L();

			CSmsMessageAdditionalAttributes::CControlParametersScheme::TSmsSMSCCtrlParameterStatus smscCtrlParameterStatus;

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

				{

				smscCtrlParameterStatus.iSegmentSequenceNum = aStream.ReadUint16L();	// Segment number

				smscCtrlParameterStatus.iSelectiveStatus = aStream.ReadInt8L();			// Selective Status	

				(scheme->iControlParametersStatusReport).AppendL(smscCtrlParameterStatus);

				}

			scheme->iDefaultStatusReport = aStream.ReadInt8L();

			scheme->iNumOfPDUs = aStream.ReadInt16L();

			}

		}

	else

		{

		SetStatusReportSchemeL(EDefaultScheme);

		}

    // CSmsMessage::ESmsMessageV3 is the same as CSmsMessage::ESmsIncompleteClass0MessageV!

    if (aVersion == CSmsMessage::ESmsMessageV4)	// National language 7bit encoding support

		{

		iAlternative7bitEncoding = (TSmsEncoding) aStream.ReadInt32L();

		}

    } // CSmsMessageAdditionalAttributes::InternalizeL

void CSmsMessageAdditionalAttributes::ResetAttributesL()

    {

    for (TInt category = 0; category < TSmsInformationElementCategories::ENumberOfCategories; category++)

        {

        iCollectionOfPointersToIEArrays[category]->ResetAndDestroy();

        }

    if(iStatusReportScheme != NULL)

    	{

    	delete iStatusReportScheme;

    	iStatusReportScheme = NULL;

    	}

    iStatusReportScheme = new (ELeave) CSmsMessageAdditionalAttributes::CDefaultScheme();

    iAlternative7bitEncoding = ESmsEncodingNone;

    } // CSmsMessageAdditionalAttributes::ResetAttributesL

CSmsIEOperation& CSmsMessageAdditionalAttributes::GetIEOperationL(TInformationElementId aId) const

    {

    CSmsIEOperation* operation = NULL;

    switch(aId)

        {

        case CSmsInformationElement::ESmsHyperLinkFormat:

            operation = iHyperLinkOperations;

            break;

        case CSmsInformationElement::ESmsReplyAddressFormat:

            operation = iReplyAddressOperations;

            break;

        case CSmsInformationElement::ESmsEnhanceVoiceMailInformation:

            operation = iEnhancedVoiceMailOperations;

            break;

        case CSmsInformationElement::ESmsIEISpecialSMSMessageIndication:

            operation = iSpecialSMSMessageOperations;

            break;

        case CSmsInformationElement::ESmsIEISMSCControlParameters:

            operation = iSMSCCtrlParameterOperations;

            break;

        default:

            User::Leave(KErrArgument);

            break;

        }

    return *operation;

    } // CSmsMessageAdditionalAttributes::GetIEOperationL

/**

 *  Gets the operation being used but for a non Information Element Type. 

 *  

 *  @note In the present case it is the TPSRR operation as that's the only one which exists as for now.

 *  

 *  @param aId The Identifier for the operation.

 */

CSmsNonIEOperation& CSmsMessageAdditionalAttributes::GetNonIEOperationL(TSmsNonIEIdentifier aId) const

	{

    CSmsNonIEOperation* operation = NULL;

    if(aId == ESmsTPSRRParameter)

    	{

    	operation = iTPSRROperations;	

    	}