diff -r 518b245aa84c -r 4e4b6adb1024 messagingapp/msgutils/convergedmessageutils/tsrc/mmstestbed/src/mmsreadfile.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingapp/msgutils/convergedmessageutils/tsrc/mmstestbed/src/mmsreadfile.cpp Tue Jun 29 23:42:47 2010 +0530 @@ -0,0 +1,1799 @@ +/* + * Copyright (c) 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: + */ + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include + +#include +#include "mmsconst.h" +#include "mmsclient.h" +#include "mmsheaders.h" +#include "mmsreadfile.h" +#include "mmsmmboxviewheaders.h" +#include "mmsmmboxmessageheaders.h" +#include "mmsmmboxflags.h" +#include "mmssettings.h" + + +// EXTERNAL DATA STRUCTURES + +// EXTERNAL FUNCTION PROTOTYPES + +// CONSTANTS +const TInt KMmsGranularity = 8; +_LIT( K1970, "19700000:000000.000000" ); // 1-Jan 1970 0:00:00 + + +// MACROS + +// LOCAL CONSTANTS AND MACROS + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES + +// ==================== LOCAL FUNCTIONS ==================== + + +// ================= MEMBER FUNCTIONS ======================= + + +// C++ default constructor can NOT contain any code, that +// might leave. +// +CMmsReadFile::CMmsReadFile() + { + // all member variables in a class derived from CBase + // are automatically set to 0. + } + + +// +void CMmsReadFile::ConstructL(RFs& aFs, RFileReadStream& aReadStream ) + { + // iRowBuffer = HBufC8::NewMaxL( 500 ); // Max row length!!!! + iFs = aFs; + iReader = &aReadStream; + iByteBuffer = HBufC8::NewL( DefaultBufLen ); + iAliasArray = new ( ELeave ) CDesCArrayFlat( KMmsGranularity ); + iAttaStructures = new ( ELeave ) CArrayPtrFlat( KMmsGranularity ); + Reset(); + } + +// Two-phased constructor. +CMmsReadFile* CMmsReadFile::NewL(RFs& aFs, RFileReadStream& aReadStream ) + { + CMmsReadFile* self = new ( ELeave ) CMmsReadFile(); + CleanupStack::PushL( self ); + self->ConstructL( aFs, aReadStream ); + CleanupStack::Pop(); + return self; + } + + +// Destructor +CMmsReadFile::~CMmsReadFile() + { + Reset(); // resets and destroys all array data + if (iAliasArray != NULL) iAliasArray->Reset(); + delete iByteBuffer; + delete iAliasArray; + delete iAttaStructures; + } + +void CMmsReadFile::Reset() + { + // reset all arrays + if (iAttaStructures != NULL) iAttaStructures->ResetAndDestroy(); + iAttaCount = 0; + iAttaRoot = 0; + } + +// --------------------------------------------------------- +// CMmsReadFile()::CompleteTest +// --------------------------------------------------------- +// +TInt CMmsReadFile::CompleteTestL( TInt aMessageCounter, CMmsHeaders& aMmsHeaders ) +{ + Reset(); // new message + + TUint32 val; + TUint limit = 1000000; + TUint sizeLimit = 1000 * 1024; //max message size 1000 kB! + TUint allLimit = 999999; + TInt error; + TRadix radix = EDecimal; + TLex16 lex; + TTestReadStatus readStatus = ETestUnknown; + CMmsAttaStructure* oneAtta = NULL; + TInt index; + TTime y1970( K1970 ); + TTimeIntervalMicroSeconds interval; + TTime date; + TInt order = 0; + TInt16 shortInteger = 0; + + //iso luuppi, joka kiertää ja lukee kunnes EOF tule vastaan + //Big Loop, which passes around and read until the EOF + + iMessageType = iNextMessageType; + while(readStatus != ETestEof) + { + readStatus = ReadRowL(); + if ( readStatus == ETestEof ) + { + return(-1); + } + if ( readStatus == ETestUnknown ) + { + // A line containing only comments, or an unknown tag + // As using the scripts to test settings is no longer supported, + // any old keywords used to test CMmsSettings class are ignored + continue; + } + if( readStatus == ETestNewMessage ) + { + iNextMessageType = readStatus; + if(aMessageCounter++) + { + return(NULL); + } + else + { + iMessageType = iNextMessageType; + continue; + } + } + if ( iMessageType == ETestNewMessage) + { + switch(readStatus) + { + case ETestFrom: + aMmsHeaders.SetSenderL( iValueBuffer ); + break; + case ETestFromAlias: + index = FindAlias(iValueBuffer); + if(index >= 0) + { + aMmsHeaders.SetSenderL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ) ); + } + break; + case ETestTo: + aMmsHeaders.AddTypedAddresseeL( iValueBuffer, EMsvRecipientTo ); + break; + case ETestToAlias: + index = FindAlias(iValueBuffer); + if(index >= 0) + { + aMmsHeaders.AddTypedAddresseeL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ), EMmsTo ); + } + break; + case ETestCc: + aMmsHeaders.AddTypedAddresseeL( iValueBuffer, EMsvRecipientCc ); + break; + case ETestCcAlias: + index = FindAlias(iValueBuffer); + if(index >= 0) + { + aMmsHeaders.AddTypedAddresseeL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ), EMmsCc ); + } + break; + case ETestBcc: + aMmsHeaders.AddTypedAddresseeL( iValueBuffer, EMsvRecipientBcc ); + break; + case ETestBccAlias: + index = FindAlias(iValueBuffer); + if(index >= 0) + { + aMmsHeaders.AddTypedAddresseeL( iAliasArray->MdcaPoint(index).Mid(iAliasArray->MdcaPoint(index).Locate('=') + 1 ), EMmsBcc ); + } + break; + case ETestSubject: + aMmsHeaders.SetSubjectL( iValueBuffer ); + break; + case ETestExpiryRel: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if (error == KErrNone) + { + aMmsHeaders.SetExpiryInterval( val ); + } + break; + case ETestExpiryAbs: + error = iDate.Set(iValueBuffer); + interval = iDate.MicroSecondsFrom( y1970 ); + // expiry date in seconds from 1.1.1970. + aMmsHeaders.SetExpiryDate( (interval.Int64())/1000000 ); + break; + case ETestDeliveryTimeRel: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if (error == KErrNone) + { + aMmsHeaders.SetDeliveryTimeInterval( val ); + } + break; + case ETestDeliveryTimeAbs: + error = iDate.Set(iValueBuffer); + interval = iDate.MicroSecondsFrom( y1970 ); + aMmsHeaders.SetDeliveryDate( (interval.Int64())/1000000 ); + break; + case ETestDate: + error = iDate.Set(iValueBuffer); + interval = iDate.MicroSecondsFrom( y1970 ); + aMmsHeaders.SetDate( (interval.Int64())/1000000 ); + case ETestPriority: + val = 0; + if ((iValueBuffer.CompareF(KLow)) == 0) + { + val = EMmsPriorityLow; + } + else if ((iValueBuffer.CompareF(KNormal)) == 0) + { + val = EMmsPriorityNormal; + } + else if ((iValueBuffer.CompareF(KHigh)) == 0) + { + val = EMmsPriorityHigh; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetMessagePriority( val ); + break; + case ETestSenderVisibility: + val = 0; + if ((iValueBuffer.CompareF(KHide)) == 0) + { + val = EMmsSenderVisibilityHide; + } + else if ((iValueBuffer.CompareF(KShow)) == 0) + { + val = EMmsSenderVisibilityShow; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetSenderVisibility( val ); + break; + case ETestDeliveryReport: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = EMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = EMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetDeliveryReport( val ); + break; + case ETestDelivReportSendAllow: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = EMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = EMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetReportAllowed( val ); + break; + + case ETestReadReply: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = EMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = EMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetReadReply( val ); + break; + case ETestNewAttachment: + oneAtta = CMmsAttaStructure::NewL(); + iAttaStructures->AppendL(oneAtta); + oneAtta->iAtta->Des().Copy( iValueBuffer ); + iAttaCount++; + break; + case ETestAttachmentType: + if (oneAtta != NULL) + { + oneAtta->iAttaType->Des().Copy( iValueBuffer ); + } + break; + case ETestAttachmentContLoc: + if (oneAtta != NULL) + { + oneAtta->iAttaName->Des().Copy( iValueBuffer ); + } + break; + case ETestAttaRecommendedName: + if (oneAtta != NULL) + { + oneAtta->iAttaRecommendedName->Des().Copy( iValueBuffer ); + } + break; + case ETestAttachmentCharset: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if (error == KErrNone) + { + if (oneAtta != NULL) + { + oneAtta->iAttaCharset = val; + } + } + break; + case ETestAttachmentCid: + if (oneAtta != NULL) + { + oneAtta->iAttaCid->Des().Copy(iValueBuffer); + } + break; + case ETestAttContTypeParamName: + iByteBuffer->Des().Copy( iValueBuffer ); + if (oneAtta != NULL) + { + oneAtta->iContentTypeParams->AppendL(iByteBuffer->Des()); + } + break; + case ETestAttContTypeParamValue: + iByteBuffer->Des().Copy( iValueBuffer ); + if (oneAtta != NULL) + { + oneAtta->iContentTypeParams->AppendL(iByteBuffer->Des()); + } + break; + case ETestAttXTypeParamName: + iByteBuffer->Des().Copy( iValueBuffer ); + if (oneAtta != NULL) + { + oneAtta->iXTypeParams->AppendL(iByteBuffer->Des()); + } + break; + case ETestAttXTypeParamValue: + iByteBuffer->Des().Copy( iValueBuffer ); + if (oneAtta != NULL) + { + oneAtta->iXTypeParams->AppendL(iByteBuffer->Des()); + } + break; + case ETestAttachmentRoot: + iAttaRoot = iAttaCount; + break; + case ETestAlias: + // all aliases are global even if they appear + // in the middle of a message + iAliasArray->AppendL( iValueBuffer ); + iAliasCount++; + break; + case ETestMessageClass: // should be handled! + val = EMmsClassPersonal; + if ((iValueBuffer.CompareF(KPersonal)) == 0) + { + val = EMmsClassPersonal; + } + else if ((iValueBuffer.CompareF(KAdvertisement)) == 0) + { + val = EMmsClassAdvertisement; + } + else if ((iValueBuffer.CompareF(KInformational)) == 0) + { + val = EMmsClassInformational; + } + else if ((iValueBuffer.CompareF(KAuto)) == 0) + { + val = EMmsClassAuto; + } + else + { + val = (TMmsMessageClass)KMmsTestIllegalValue; + } + aMmsHeaders.SetMessageClass( val ); + break; + case ETestReplyCharging: + val = 0; + if ((iValueBuffer.CompareF(KRequested)) == 0) + { + val = KMmsReplyChargingRequested; + } + else if ((iValueBuffer.CompareF(KReqTextOnly)) == 0) + { + val = KMmsReplyChargingRequestedTextOnly; + } + else if ((iValueBuffer.CompareF(KAccepted)) == 0) + { + val = KMmsReplyChargingAccepted; + } + else if ((iValueBuffer.CompareF(KAccTextOnly)) == 0) + { + val = KMmsReplyChargingAcceptedTextOnly; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetReplyCharging( val ); + break; + case ETestReplyChargAbs: + error = date.Set(iValueBuffer); + if ( error == KErrNone ) + { + interval = date.MicroSecondsFrom( y1970 ); + aMmsHeaders.SetReplyChargingDate( (interval.Int64())/1000000 ); + } + break; + case ETestReplyChargRel: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if (error == KErrNone) + { + aMmsHeaders.SetReplyChargingInterval( val ); + } + break; + case ETestReplyChargSize: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,sizeLimit); + if (error == KErrNone) + { + aMmsHeaders.SetReplyChargingSize( val ); + } + break; + case ETestReplyChargID: + iByteBuffer->Des().Copy( iValueBuffer ); + aMmsHeaders.SetReplyChargingIdL( iByteBuffer->Des() ); + break; + case ETestTID: + iByteBuffer->Des().Copy( iValueBuffer ); + aMmsHeaders.SetTidL( iByteBuffer->Des() ); + break; + case ETestContentLocation: + iByteBuffer->Des().Copy( iValueBuffer ); + if ( aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewReq || + aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewConf || + aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteReq ) + { + aMmsHeaders.MMBoxMessageHeadersL().ContentLocationList().AppendL( iByteBuffer->Des() ); + } + else if ( aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteConf ) + { + aMmsHeaders.InsertDeleteContentLocationL( order, iByteBuffer->Des() ); + } + else + { + aMmsHeaders.SetContentLocationL( iByteBuffer->Des() ); + } + break; + case ETestPreviouslySentIndex: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + order = val; + break; + case ETestPreviouslySentBy: + aMmsHeaders.InsertPreviouslySentByL( order, iValueBuffer ); + break; + case ETestPreviouslySentDate: + error = date.Set(iValueBuffer); + if ( error == KErrNone ) + { + interval = date.MicroSecondsFrom( y1970 ); + aMmsHeaders.InsertPreviouslySentDateL( order, (interval.Int64())/1000000 ); + } + break; + case ETestMessageId: + iByteBuffer->Des().Copy( iValueBuffer ); + aMmsHeaders.SetMessageIdL( iByteBuffer->Des() ); + break; + case ETestMessageSize: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,sizeLimit); + if (error == KErrNone) + { + aMmsHeaders.SetMessageSize( val ); + } + break; + case ETestVersion: + lex.Assign(iValueBuffer); + error = lex.Val(val,EHex,limit); + shortInteger = TInt16( val ); + if (error == KErrNone) + { + aMmsHeaders.SetMmsVersion( shortInteger ); + } + break; + case ETestReadStatus: + val = 0; + if ((iValueBuffer.CompareF(KRead)) == 0) + { + val = KMmsReadStatusRead; + } + else if ((iValueBuffer.CompareF(KDelNotRead)) == 0) + { + val = KMmsReadStatusDeletedWithoutBeingRead; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetReadStatus( val ); + break; + case ETestResponseStatus: + val = 0; + if ((iValueBuffer.CompareF(KOk)) == 0) + { + val = KMmsStatusOk; + } + else if ((iValueBuffer.CompareF(KErrUnspecified)) == 0) + { + val = KMmsErrorUnspecified; + } + else if ((iValueBuffer.CompareF(KErrServiceDenied)) == 0) + { + val = KMmsErrorServiceDenied; + } + else if ((iValueBuffer.CompareF(KErrMessageFormatCorrupt)) == 0) + { + val = KMmsErrorMessageFormatCorrupt; + } + else if ((iValueBuffer.CompareF(KErrAddressUnresolved)) == 0) + { + val = KMmsErrorSendingAddressUnresolved; + } + else if ((iValueBuffer.CompareF(KErrMessageNotFound)) == 0) + { + val = KMmsErrorMessageNotFound; + } + else if ((iValueBuffer.CompareF(KErrNetworkProblem)) == 0) + { + val = KMmsErrorNetworkProblem; + } + else if ((iValueBuffer.CompareF(KErrContentNotAccepted)) == 0) + { + val = KMmsErrorNoContentAccepted; + } + else if ((iValueBuffer.CompareF(KErrUnsupportedMessage)) == 0) + { + val = KMmsErrorUnsupportedMessage; + } + else if ((iValueBuffer.CompareF(KErrTransient)) == 0) + { + val = KMmsErrorTransientFailure; + } + else if ((iValueBuffer.CompareF(KErrTransientAddressUnresolved)) == 0) + { + val = KMmsErrorTransientSendingAddressUnresolved; + } + else if ((iValueBuffer.CompareF(KErrTransientNotFound)) == 0) + { + val = KMmsErrorTransientMessageNotFound; + } + else if ((iValueBuffer.CompareF(KErrTransientNetworkproblem)) == 0) + { + val = KMmsErrorTransientNetworkProblem; + } + else if ((iValueBuffer.CompareF(KErrPermanent)) == 0) + { + val = KMmsErrorPermanentFailure; + } + else if ((iValueBuffer.CompareF(KErrPermanentServiceDenied)) == 0) + { + val = KMmsErrorPermanentServiceDenied; + } + else if ((iValueBuffer.CompareF(KErrPermanentMessageFormatCorrupt)) == 0) + { + val = KMmsErrorPermanentMessageFormatCorrupt; + } + else if ((iValueBuffer.CompareF(KErrPermanentAddressUnresolved)) == 0) + { + val = KMmsErrorPermanentSendingAddressUnresolved; + } + else if ((iValueBuffer.CompareF(KErrPermanentNotFound)) == 0) + { + val = KMmsErrorPermanentMessageNotFound; + } + else if ((iValueBuffer.CompareF(KErrPermanentContentNotAccepted)) == 0) + { + val = KMmsErrorPermanentContentNotAccepted; + } + else if ((iValueBuffer.CompareF(KErrReplyChargingLimitNotMet)) == 0) + { + val = KMmsErrorPermanentReplyChargingLimitationsNotMet; + } + else if ((iValueBuffer.CompareF(KErrReplyChargingRequestNotAccepted)) == 0) + { + val = KMmsErrorPermanentReplyChargingRequestNotAccepted; + } + else if ((iValueBuffer.CompareF(KErrReplyChargingForwardingDenied)) == 0) + { + val = KMmsErrorPermanentReplyChargingForwardingDenied; + } + else if ((iValueBuffer.CompareF(KErrReplyChargingNotSupported)) == 0) + { + val = KMmsErrorPermanentReplyChargingNotSupported; + } + else if ((iValueBuffer.CompareF(KErrTransientPartialSuccess)) == 0) + { + val = KMmsErrorTransientPartialSuccess; + } + else if ((iValueBuffer.CompareF(KErrAddressHidingNotSupported)) == 0) + { + val = KMmsErrorPermanentAddressHidingNotSupported; + } + else + { + val = KMmsTestIllegalValue; + } + if ( aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteConf ) + { + aMmsHeaders.InsertDeleteStatusL( order, val ); + } + else + { + aMmsHeaders.SetResponseStatus( val ); + } + break; + case ETestResponseText: + if ( aMmsHeaders.MessageType() == KMmsMessageTypeMBoxDeleteConf ) + { + aMmsHeaders.InsertDeleteResponseTextL( order, iValueBuffer ); + } + else + { + aMmsHeaders.SetResponseTextL( iValueBuffer ); + } + break; + case ETestRetrieveStatus: + val = 0; + if ((iValueBuffer.CompareF(KOk)) == 0) + { + val = KMmsStatusOk; + } + else if ((iValueBuffer.CompareF(KErrTransient)) == 0) + { + val = KMmsErrorTransientFailure; + } + else if ((iValueBuffer.CompareF(KErrTransientNotFound)) == 0) + { + val = KMmsErrorReceiveTransientMessageNotFound; + } + else if ((iValueBuffer.CompareF(KErrTransientNetworkproblem)) == 0) + { + val = KMmsErrorReceiveTransientNetworkProblem; + } + else if ((iValueBuffer.CompareF(KErrPermanent)) == 0) + { + val = KMmsErrorPermanentFailure; + } + else if ((iValueBuffer.CompareF(KErrPermanentServiceDenied)) == 0) + { + val = KMmsErrorPermanentServiceDenied; + } + else if ((iValueBuffer.CompareF(KErrPermanentNotFound)) == 0) + { + val = KMmsErrorReceivePermanentMessageNotFound; + } + else if ((iValueBuffer.CompareF(KErrRetrieveContentUnsupported)) == 0) + { + val = KMmsErrorReceivePermanentContentUnsupported; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetResponseStatus( val ); + break; + case ETestRetrieveText: + aMmsHeaders.SetResponseTextL( iValueBuffer ); + break; + case ETestStatus: + val = 0; + if ((iValueBuffer.CompareF(KDeferred)) == 0) + { + val = KMmsMessageStatusDeferred; + } + else if ((iValueBuffer.CompareF(KExpired)) == 0) + { + val = KMmsMessageStatusExpired; + } + else if ((iValueBuffer.CompareF(KRetrieved)) == 0) + { + val = KMmsMessageStatusRetrieved; + } + else if ((iValueBuffer.CompareF(KRejected)) == 0) + { + val = KMmsMessageStatusRejected; + } + else if ((iValueBuffer.CompareF(KUnrecognized)) == 0) + { + val = KMmsMessageStatusUnrecognized; + } + else if ((iValueBuffer.CompareF(KIndeterminate)) == 0) + { + val = KMmsMessageStatusIndeterminate; + } + else if ((iValueBuffer.CompareF(KForwarded)) == 0) + { + val = KMmsMessageStatusForwarded; + } + else if ((iValueBuffer.CompareF(KUnreachable)) == 0) + { + val = KMmsMessageStatusUnreachable; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetStatus( val ); + break; + case ETestMessageType: + val = 0; + if ((iValueBuffer.CompareF(KSendReq)) == 0) + { + val = KMmsMessageTypeMSendReq; + } + else if ((iValueBuffer.CompareF(KSendConf)) == 0) + { + val = KMmsMessageTypeMSendConf; + } + else if ((iValueBuffer.CompareF(KNotifInd)) == 0) + { + val = KMmsMessageTypeMNotificationInd; + } + else if ((iValueBuffer.CompareF(KNotifResp)) == 0) + { + val = KMmsMessageTypeMNotifyRespInd; + } + else if ((iValueBuffer.CompareF(KRetrConf)) == 0) + { + val = KMmsMessageTypeMRetrieveConf; + } + else if ((iValueBuffer.CompareF(KAckInd)) == 0) + { + val = KMmsMessageTypeAcknowledgeInd; + } + else if ((iValueBuffer.CompareF(KDelInd)) == 0) + { + val = KMmsMessageTypeDeliveryInd; + } + else if ((iValueBuffer.CompareF(KReadReqInd)) == 0) + { + val = KMmsMessageTypeReadRecInd; + } + else if ((iValueBuffer.CompareF(KReadOrigInd)) == 0) + { + val = KMmsMessageTypeReadOrigInd; + } + else if ((iValueBuffer.CompareF(KForwardRec)) == 0) + { + val = KMmsMessageTypeForwardReq; + } + else if ((iValueBuffer.CompareF(KForwardConf)) == 0) + { + val = KMmsMessageTypeForwardConf; + } + else if ((iValueBuffer.CompareF(KMBoxStoreReq)) == 0) + { + val = KMmsMessageTypeMboxStoreReq; + } + else if ((iValueBuffer.CompareF(KMBoxStoreConf)) == 0) + { + val = KMmsMessageTypeMboxStoreConf; + } + else if ((iValueBuffer.CompareF(KMBoxViewReq)) == 0) + { + val = KMmsMessageTypeMboxViewReq; + } + else if ((iValueBuffer.CompareF(KMBoxViewConf)) == 0) + { + val = KMmsMessageTypeMboxViewConf; + } + else if ((iValueBuffer.CompareF(KMBoxUploadReq)) == 0) + { + val = KMmsMessageTypeMBoxUploadReq; + } + else if ((iValueBuffer.CompareF(KMBoxUploadConf)) == 0) + { + val = KMmsMessageTypeMBoxUploadConf; + } + else if ((iValueBuffer.CompareF(KMBoxDeleteReq)) == 0) + { + val = KMmsMessageTypeMBoxDeleteReq; + } + else if ((iValueBuffer.CompareF(KMBoxDeleteConf)) == 0) + { + val = KMmsMessageTypeMBoxDeleteConf; + } + else if ((iValueBuffer.CompareF(KMBoxDescr)) == 0) + { + val = KMmsMessageTypeMBoxDescr; + } + else if ((iValueBuffer.CompareF(KDeleteReq)) == 0) + { + val = KMmsMessageTypeDeleteReq; + } + else if ((iValueBuffer.CompareF(KDeleteConf)) == 0) + { + val = KMmsMessageTypeDeleteConf; + } + else if ((iValueBuffer.CompareF(KCancelReq)) == 0) + { + val = KMmsMessageTypeCancelReq; + } + else if ((iValueBuffer.CompareF(KCancelResp)) == 0) + { + val = KMmsMessageTypeCancelConf; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetMessageType( val ); + break; + case ETestAttribute: + val = 0; + iByteBuffer->Des().Copy( iValueBuffer ); + if ((iByteBuffer->Des().CompareF(KTestBcc)) == 0) + { + val = KMmsAssignedBcc; + } + else if ((iByteBuffer->Des().CompareF(KTestCc)) == 0) + { + val = KMmsAssignedCc; + } + else if ((iByteBuffer->Des().CompareF(KTestContent)) == 0) + { + val = KMmsAssignedContent; + } + else if ((iByteBuffer->Des().CompareF(KTestContentType)) == 0) + { + val = KMmsAssignedContentType; + } + else if ((iByteBuffer->Des().CompareF(KTestDate)) == 0) + { + val = KMmsAssignedDate; + } + else if ((iByteBuffer->Des().CompareF(KTestDeliveryReport)) == 0) + { + val = KMmsAssignedDeliveryReport; + } + else if ((iByteBuffer->Des().CompareF(KTestDeliveryTime)) == 0) + { + val = KMmsAssignedDeliveryTime; + } + else if ((iByteBuffer->Des().CompareF(KTestExpiry)) == 0) + { + val = KMmsAssignedExpiry; + } + else if ((iByteBuffer->Des().CompareF(KTestFrom)) == 0) + { + val = KMmsAssignedFrom; + } + else if ((iByteBuffer->Des().CompareF(KTestMessageClass)) == 0) + { + val = KMmsAssignedMessageClass; + } + else if ((iByteBuffer->Des().CompareF(KTestMessageId)) == 0) + { + val = KMmsAssignedMessageId; + } + else if ((iByteBuffer->Des().CompareF(KTestMessageSize)) == 0) + { + val = KMmsAssignedMessageSize; + } + else if ((iByteBuffer->Des().CompareF(KTestPriority)) == 0) + { + val = KMmsAssignedPriority; + } + else if ((iByteBuffer->Des().CompareF(KTestReadReply)) == 0) + { + val = KMmsAssignedReadReply; + } + else if ((iByteBuffer->Des().CompareF(KTestSubject)) == 0) + { + val = KMmsAssignedSubject; + } + else if ((iByteBuffer->Des().CompareF(KTestTo)) == 0) + { + val = KMmsAssignedTo; + } + else if ((iByteBuffer->Des().CompareF(KTestReplyCharging)) == 0) + { + val = KMmsAssignedReplyCharging; + } + else if ((iByteBuffer->Des().CompareF(KTestReplyChargID)) == 0) + { + val = KMmsAssignedReplyChargingID; + } + else if ((iByteBuffer->Des().CompareF(KTestReplyCharg)) == 0) + { + val = KMmsAssignedReplyChargingDeadline; + } + else if ((iByteBuffer->Des().CompareF(KTestReplyChargSize)) == 0) + { + val = KMmsAssignedReplyChargingSize; + } + else if ((iByteBuffer->Des().CompareF(KTestPreviouslySentBy)) == 0) + { + val = KMmsAssignedPreviouslySentBy; + } + else if ((iByteBuffer->Des().CompareF(KTestPreviouslySentDate)) == 0) + { + val = KMmsAssignedPreviouslySentDate; + } + else if ((iByteBuffer->Des().CompareF(KTestAdditionalHeaders)) == 0) + { + val = KMmsAssignedAdditionalHeaders; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.MMBoxViewHeadersL().AttributeArray().InsertInOrder(val); + break; + case ETestDistributionIndicator: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetDistributionIndicator( val ); + break; + case ETestLimit: + aMmsHeaders.MMBoxViewHeadersL().SetMmsLimit(KMaxTUint32); + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if ( val > allLimit ) + { + val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" + } + if( error == KErrNone ) + { + aMmsHeaders.MMBoxViewHeadersL().SetMmsLimit(val); + } + break; + case ETestMessageQuota: + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaNumber(KMaxTUint32); + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if ( val > allLimit ) + { + val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" + } + if (error == KErrNone) + { + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaNumber(val); + } + break; + case ETestSizeQuota: + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaSize(KMaxTUint32); + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if ( val > allLimit ) + { + val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" + } + if (error == KErrNone) + { + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxQuotaSize(val); + } + break; + case ETestMessageTotal: + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalNumber(KMaxTUint32); + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if ( val > allLimit ) + { + val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" + } + if (error == KErrNone) + { + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalNumber(val); + } + break; + case ETestSizeTotal: + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalSize(KMaxTUint32); + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if ( val > allLimit ) + { + val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" + } + if (error == KErrNone) + { + aMmsHeaders.MMBoxViewHeadersL().SetMMBoxTotalSize(val); + } + break; + case ETestMessageCount: + aMmsHeaders.MMBoxViewHeadersL().SetMmsMessageCount(KMaxTUint32); + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if ( val > allLimit ) + { + val = KMaxTUint32; // this is too hard to type, more than 999999 means "all" + } + if (error == KErrNone) + { + aMmsHeaders.MMBoxViewHeadersL().SetMmsMessageCount(val); + } + break; + case ETestAddKeyword: + aMmsHeaders.MMBoxMessageHeadersL().AppendKeywordItemL(KMmsAddToken, iValueBuffer); + break; + case ETestRemoveKeyword: + aMmsHeaders.MMBoxMessageHeadersL().AppendKeywordItemL(KMmsRemoveToken, iValueBuffer); + break; + case ETestFilterKeyword: + aMmsHeaders.MMBoxMessageHeadersL().AppendKeywordItemL(KMmsFilterToken, iValueBuffer); + break; + case ETestMMState: + val = 0; + if ((iValueBuffer.CompareF(KDraft)) == 0) + { + val = KMmsDraft; + } + else if ((iValueBuffer.CompareF(KSent)) == 0) + { + val = KMmsSent; + } + else if ((iValueBuffer.CompareF(KNew)) == 0) + { + val = KMmsNew; + } + else if ((iValueBuffer.CompareF(KRetrieved)) == 0) + { + val = KMmsRetrieved; + } + else if ((iValueBuffer.CompareF(KForwarded)) == 0) + { + val = KMmsForwarded; + } + else + { + val = KMmsTestIllegalValue; + } + if ( aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewReq || + aMmsHeaders.MessageType() == KMmsMessageTypeMboxViewConf ) + { + aMmsHeaders.MMBoxViewHeadersL().MMStateArray().InsertInOrder( val ); + } + else + { + aMmsHeaders.MMBoxMessageHeadersL().SetMMState( val ); + } + break; + case ETestQuota: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.MMBoxViewHeadersL().SetMmsQuotas( val ); + break; + case ETestStart: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + if (error == KErrNone) + { + aMmsHeaders.MMBoxViewHeadersL().SetMmsStart(val); + } + break; + case ETestStore: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.MMBoxMessageHeadersL().SetMmsStore( val ); + break; + case ETestStored: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.MMBoxMessageHeadersL().SetMmsStored( val ); + break; + case ETestStoreStatus: + val = 0; + if ((iValueBuffer.CompareF(KOk)) == 0) + { + val = KMmsStatusOk; + } + else if ((iValueBuffer.CompareF(KErrTransient)) == 0) + { + val = KMmsErrorTransientFailure; + } + else if ((iValueBuffer.CompareF(KErrTransientNetworkproblem)) == 0) + { + val = KMmsErrorStoreStatusTransientNetworkProblem; + } + else if ((iValueBuffer.CompareF(KErrPermanent)) == 0) + { + val = KMmsErrorPermanentFailure; + } + else if ((iValueBuffer.CompareF(KErrPermanentServiceDenied)) == 0) + { + val = KMmsErrorPermanentServiceDenied; + } + else if ((iValueBuffer.CompareF(KErrPermanentMessageFormatCorrupt)) == 0) + { + val = KMmsErrorPermanentMessageFormatCorrupt; + } + else if ((iValueBuffer.CompareF(KErrPermanentNotFound)) == 0) + { + val = KMmsErrorStoreStatusPermanentMessageNotFound; + } + else if ((iValueBuffer.CompareF(KErrMMBoxFull)) == 0) + { + val = KMmsErrorStoreStatusPermanentMmboxFull; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.MMBoxMessageHeadersL().SetMmsStoreStatus( val ); + break; + case ETestStoreStatusText: + aMmsHeaders.MMBoxMessageHeadersL().SetMmsStoreStatusTextL( iValueBuffer ); + break; + case ETestTotals: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.MMBoxViewHeadersL().SetMmsTotals( val ); + break; + + case ETestDeleteInfoIndex: + lex.Assign(iValueBuffer); + error = lex.Val(val,radix,limit); + order = val; + break; + + case ETestApplicId: + aMmsHeaders.SetApplicIdL( iValueBuffer ); + break; + case ETestReplyApplicId: + aMmsHeaders.SetReplyApplicIdL( iValueBuffer ); + break; + case ETestApplicInfo: + iByteBuffer->Des().Copy( iValueBuffer ); + aMmsHeaders.SetAuxApplicInfoL( iByteBuffer->Des() ); + break; + case ETestContentClass: + val = 0; + if ((iValueBuffer.CompareF(KText)) == 0) + { + val = KMmsContentClassText; + } + else if ((iValueBuffer.CompareF(KImageBasic)) == 0) + { + val = KMmsContentClassImageBasic; + } + else if ((iValueBuffer.CompareF(KImageRich)) == 0) + { + val = KMmsContentClassImageRich; + } + else if ((iValueBuffer.CompareF(KVideoBasic)) == 0) + { + val = KMmsContentClassVideoBasic; + } + else if ((iValueBuffer.CompareF(KVideoRich)) == 0) + { + val = KMmsContentClassVideoRich; + } + else if ((iValueBuffer.CompareF(KMegaPixel)) == 0) + { + val = KMmsContentClassMegaPixel; + } + else if ((iValueBuffer.CompareF(KContentBasic)) == 0) + { + val = KMmsContentClassContentBasic; + } + else if ((iValueBuffer.CompareF(KContentRich)) == 0) + { + val = KMmsContentClassContentRich; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetContentClass( val ); + break; + case ETestDrmContent: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetDrmContent( val ); + break; + case ETestAdaptationAllowed: + val = 0; + if ((iValueBuffer.CompareF(KYes)) == 0) + { + val = KMmsYes; + } + else if ((iValueBuffer.CompareF(KNo)) == 0) + { + val = KMmsNo; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetAdaptationAllowed( val ); + break; + case ETestRecommendedRetrievalMode: + val = 0; + if ((iValueBuffer.CompareF(KManual)) == 0) + { + val = KMmsRecommendedRetrievalModeManual; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetRecommendedRetrievalMode( val ); + break; + case ETestRecRetrievalModeText: + aMmsHeaders.SetRecommendedRetrievalModeTextL( iValueBuffer ); + break; + case ETestReplaceId: + iByteBuffer->Des().Copy( iValueBuffer ); + aMmsHeaders.SetReplaceCancelIdL( iByteBuffer->Des() ); + break; + case ETestStatusText: + aMmsHeaders.SetResponseTextL( iValueBuffer ); + break; + case ETestCancelId: + iByteBuffer->Des().Copy( iValueBuffer ); + aMmsHeaders.SetReplaceCancelIdL( iByteBuffer->Des() ); + break; + case ETestCancelStatus: + val = 0; + if ((iValueBuffer.CompareF(KCancelSuccessful)) == 0) + { + val = KMmsCancelRequestSuccessfullyReceived; + } + else if ((iValueBuffer.CompareF(KCancelCorrupted)) == 0) + { + val = KMmsCancelRequestCorrupted; + } + else + { + val = KMmsTestIllegalValue; + } + aMmsHeaders.SetCancelStatus( val ); + break; + default: + break; + } + } + else + { + switch(readStatus) + { + case ETestAlias: + iAliasArray->AppendL( iValueBuffer ); + iAliasCount++; + break; + + default: + break; + } + + } + } + return(-1); +} + +// --------------------------------------------------------- +// CMmsReadFile()::ReadRowL +// --------------------------------------------------------- +// +TTestReadStatus CMmsReadFile::ReadRowL() + { + + TBuf8 RowBuffer; + TBuf8<32> KeyBuffer; + + // READ ONE ROW AND DROP CR+LF FROM THE END OF LINE + TChar delim( 10 ); + iReader->ReadL( RowBuffer, delim); + TInt length = RowBuffer.Length(); + if ( RowBuffer.Length() < 2 ) + { + return ETestEof; + } + RowBuffer.Delete(length - 2,2); + + // DROP POSSIBLE COMMENT OUT + TInt pos = RowBuffer.Locate( ';' ); + if ( pos >= 0 ) RowBuffer.Delete( pos, length-pos-2 ); + + if ( RowBuffer.Length() == 0 ) + { + // the line contained only comment + return ETestUnknown; + } + + // First split the row (:) + pos = RowBuffer.Locate( ':' ); + if (pos > 0) + { + TPtrC8 p = RowBuffer.Mid( pos+1 ); + length = p.Length(); + iValueBuffer.Zero(); + for (TInt i=0; i < length; ++i) + { + iValueBuffer.Append(p[i]); + } + iValueBuffer.Trim(); + TPtrC8 pp = RowBuffer.Left(pos); + KeyBuffer.CopyUC(pp); + KeyBuffer.Trim(); + } + // TRY TO FIND CORRECT TAG + if ((KeyBuffer.CompareF(KTestNewMessage)) == 0) return(ETestNewMessage); + if ((KeyBuffer.CompareF(KTestMessageType)) == 0) return ETestMessageType; + if ((KeyBuffer.CompareF(KTestDate)) == 0) return ETestDate; + if ((KeyBuffer.CompareF(KTestFrom)) == 0) return ETestFrom; + if ((KeyBuffer.CompareF(KTestTo)) == 0) return ETestTo; + if ((KeyBuffer.CompareF(KTestCc)) == 0) return ETestCc; + if ((KeyBuffer.CompareF(KTestBcc)) == 0) return ETestBcc; + if ((KeyBuffer.CompareF(KTestSubject)) == 0) return ETestSubject; + if ((KeyBuffer.CompareF(KTestExpiryRel)) == 0) return ETestExpiryRel; + if ((KeyBuffer.CompareF(KTestExpiryAbs)) == 0) return ETestExpiryAbs; + if ((KeyBuffer.CompareF(KTestDeliveryTimeRel)) == 0) return ETestDeliveryTimeRel; + if ((KeyBuffer.CompareF(KTestDeliveryTimeAbs)) == 0) return ETestDeliveryTimeAbs; + if ((KeyBuffer.CompareF(KTestPriority)) == 0) return ETestPriority; + if ((KeyBuffer.CompareF(KTestSenderVisibility)) == 0) return ETestSenderVisibility; + if ((KeyBuffer.CompareF(KTestDeliveryReport)) == 0) return ETestDeliveryReport; + if ((KeyBuffer.CompareF(KTestReadReply)) == 0) return ETestReadReply; + if ((KeyBuffer.CompareF(KTestNewAttachment)) == 0) return ETestNewAttachment; + if ((KeyBuffer.CompareF(KTestAttachmentName)) == 0) return ETestAttaRecommendedName; + if ((KeyBuffer.CompareF(KTestAttachmentContLoc)) == 0) return ETestAttachmentContLoc; + if ((KeyBuffer.CompareF(KTestAttachmentType)) == 0) return ETestAttachmentType; + if ((KeyBuffer.CompareF(KTestAttachmentCharset)) == 0) return ETestAttachmentCharset; + if ((KeyBuffer.CompareF(KTestAttachmentCid)) == 0) return ETestAttachmentCid; + if ((KeyBuffer.CompareF(KTestAttachmentRoot)) == 0) return ETestAttachmentRoot; + if ((KeyBuffer.CompareF(KTestEndOfFile)) == 0) return ETestEof; + if ((KeyBuffer.CompareF(KTestMessageClass)) == 0) return ETestMessageClass; + if ((KeyBuffer.CompareF(KTestDelivRepSendAllow)) == 0) return ETestDelivReportSendAllow; + if ((KeyBuffer.CompareF(KTestAlias)) == 0 ) return ETestAlias; + if ((KeyBuffer.CompareF(KTestFromAlias)) == 0 ) return ETestFromAlias; + if ((KeyBuffer.CompareF(KTestToAlias)) == 0 ) return ETestToAlias; + if ((KeyBuffer.CompareF(KTestCcAlias)) == 0 ) return ETestCcAlias; + if ((KeyBuffer.CompareF(KTestBccAlias)) == 0 ) return ETestBccAlias; + if ((KeyBuffer.CompareF(KTestReplyCharging)) == 0 ) return ETestReplyCharging; + if ((KeyBuffer.CompareF(KTestReplyChargAbs)) == 0 ) return ETestReplyChargAbs; + if ((KeyBuffer.CompareF(KTestReplyChargRel)) == 0 ) return ETestReplyChargRel; + if ((KeyBuffer.CompareF(KTestReplyChargSize)) == 0 ) return ETestReplyChargSize; + if ((KeyBuffer.CompareF(KTestReplyChargID)) == 0 ) return ETestReplyChargID; + if ((KeyBuffer.CompareF(KTestTID)) == 0 ) return ETestTID; + if ((KeyBuffer.CompareF(KTestContentLocation)) == 0 ) return ETestContentLocation; + if ((KeyBuffer.CompareF(KTestPreviouslySentIndex)) == 0 ) return ETestPreviouslySentIndex; + if ((KeyBuffer.CompareF(KTestPreviouslySentBy)) == 0 ) return ETestPreviouslySentBy; + if ((KeyBuffer.CompareF(KTestPreviouslySentDate)) == 0 ) return ETestPreviouslySentDate; + if ((KeyBuffer.CompareF(KTestMessageId)) == 0 ) return ETestMessageId; + if ((KeyBuffer.CompareF(KTestMessageSize)) == 0 ) return ETestMessageSize; + if ((KeyBuffer.CompareF(KTestVersion)) == 0 ) return ETestVersion; + if ((KeyBuffer.CompareF(KTestReadStatus)) == 0 ) return ETestReadStatus; + if ((KeyBuffer.CompareF(KTestResponseStatus)) == 0 ) return ETestResponseStatus; + if ((KeyBuffer.CompareF(KTestResponseText)) == 0 ) return ETestResponseText; + if ((KeyBuffer.CompareF(KTestRetrieveStatus)) == 0 ) return ETestRetrieveStatus; + if ((KeyBuffer.CompareF(KTestRetrieveText)) == 0 ) return ETestRetrieveText; + if ((KeyBuffer.CompareF(KTestStatus)) == 0 ) return ETestStatus; + if ((KeyBuffer.CompareF(KTestAttribute)) == 0 ) return ETestAttribute; + if ((KeyBuffer.CompareF(KTestDistributionIndicator)) == 0 ) return ETestDistributionIndicator; + if ((KeyBuffer.CompareF(KTestLimit)) == 0 ) return ETestLimit; + if ((KeyBuffer.CompareF(KTestMessageQuota)) == 0 ) return ETestMessageQuota; + if ((KeyBuffer.CompareF(KTestSizeQuota)) == 0 ) return ETestSizeQuota; + if ((KeyBuffer.CompareF(KTestMessageTotal)) == 0 ) return ETestMessageTotal; + if ((KeyBuffer.CompareF(KTestSizeTotal)) == 0 ) return ETestSizeTotal; + if ((KeyBuffer.CompareF(KTestMessageCount)) == 0 ) return ETestMessageCount; + if ((KeyBuffer.CompareF(KTestAddKeyword)) == 0 ) return ETestAddKeyword; + if ((KeyBuffer.CompareF(KTestRemoveKeyword)) == 0 ) return ETestRemoveKeyword; + if ((KeyBuffer.CompareF(KTestFilterKeyword)) == 0 ) return ETestFilterKeyword; + if ((KeyBuffer.CompareF(KTestMMState)) == 0 ) return ETestMMState; + if ((KeyBuffer.CompareF(KTestQuota)) == 0 ) return ETestQuota; + if ((KeyBuffer.CompareF(KTestStart)) == 0 ) return ETestStart; + if ((KeyBuffer.CompareF(KTestStore)) == 0 ) return ETestStore; + if ((KeyBuffer.CompareF(KTestStored)) == 0 ) return ETestStored; + if ((KeyBuffer.CompareF(KTestStoreStatus)) == 0 ) return ETestStoreStatus; + if ((KeyBuffer.CompareF(KTestStoreStatusText)) == 0 ) return ETestStoreStatusText; + if ((KeyBuffer.CompareF(KTestTotals)) == 0 ) return ETestTotals; + if ((KeyBuffer.CompareF(KTestDeleteInfoIndex)) == 0 ) return ETestDeleteInfoIndex; + if ((KeyBuffer.CompareF(KTestApplicId)) == 0 ) return ETestApplicId; + if ((KeyBuffer.CompareF(KTestReplyApplicId)) == 0 ) return ETestReplyApplicId; + if ((KeyBuffer.CompareF(KTestApplicInfo)) == 0 ) return ETestApplicInfo; + if ((KeyBuffer.CompareF(KTestContentClass)) == 0 ) return ETestContentClass; + if ((KeyBuffer.CompareF(KTestDrmContent)) == 0 ) return ETestDrmContent; + if ((KeyBuffer.CompareF(KTestAdaptationAllowed)) == 0 ) return ETestAdaptationAllowed; + if ((KeyBuffer.CompareF(KTestRecommendedRetrievalMode)) == 0 ) return ETestRecommendedRetrievalMode; + if ((KeyBuffer.CompareF(KTestRecRetrievalModeText)) == 0 ) return ETestRecRetrievalModeText; + if ((KeyBuffer.CompareF(KTestReplaceId)) == 0 ) return ETestReplaceId; + if ((KeyBuffer.CompareF(KTestStatusText)) == 0 ) return ETestStatusText; + if ((KeyBuffer.CompareF(KTestCancelId)) == 0 ) return ETestCancelId; + if ((KeyBuffer.CompareF(KTestCancelStatus)) == 0 ) return ETestCancelStatus; + if ((KeyBuffer.CompareF(KTestAttContTypeParamName)) == 0 ) return ETestAttContTypeParamName; + if ((KeyBuffer.CompareF(KTestAttContTypeParamValue)) == 0 ) return ETestAttContTypeParamValue; + if ((KeyBuffer.CompareF(KTestAttXTypeParamName)) == 0 ) return ETestAttXTypeParamName; + if ((KeyBuffer.CompareF(KTestAttXTypeParamValue)) == 0 ) return ETestAttXTypeParamValue; + return ETestUnknown; + } + +// --------------------------------------------------------- +// CMmsReadFile()::CreateMessageL +// program build a message from given parts +// --------------------------------------------------------- +// +void CMmsReadFile::CreateMessageL( CMmsClientMtm* aMmsClient, CMmsHeaders* aMmsHeaders ) + { + + // Reset inactivity timer to keem viewServer from crashing + User::ResetInactivityTime(); + + TInt i; + TInt error = KErrNone; + RFile attaFile; + _LIT8(KLeftAngle, "<"); + _LIT8(KRightAngle, ">"); + // we can't use "seconds from" as it only returns a + // 32 bit signed integer. If fails in 2038. + // "microseconds from" returns a 64 bit signed integer + + CMsvStore* store = aMmsClient->Entry().EditStoreL(); + CleanupStack::PushL(store); + aMmsHeaders->StoreL(*store); + store->CommitL(); + CleanupStack::PopAndDestroy( store ); + store = NULL; + + aMmsClient->LoadMessageL(); // read store is needed to do this + + store = aMmsClient->Entry().EditStoreL(); + CleanupStack::PushL(store); + CMsvAttachment* attaInfo = NULL; + TMsvAttachmentId attaId = 0; + + for ( i=0; i < iAttaStructures->Count(); ++i) + { + attaId = KMsvNullIndexEntryId; + iFilename.Copy(iAttaStructures->At(i)->iAtta->Des()); + + error = attaFile.Open( iFs, iFilename, EFileShareReadersOnly | EFileRead ); + User::LeaveIfError( error ); + + CleanupClosePushL(attaFile); + + CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL(); + CleanupStack::PushL( mimeHeaders ); + TPtrC8 contentType = iAttaStructures->At(i)->iAttaType->Des(); + + TDataRecognitionResult result; + result.Reset(); // make sure that it is cleared + + if(iAttaStructures->At(i)->iAttaCid->Length()) + { + TPtr8 attaCID = iAttaStructures->At(i)->iAttaCid->Des(); + if (attaCID.Find(KLeftAngle) == 0 && + attaCID.Find(KRightAngle) == attaCID.Length()-1 ) + { + // remove angle brackets from cid + attaCID = attaCID.Mid(1,attaCID.Length()-2); + } + mimeHeaders->SetContentIdL(attaCID); + } + + if (iAttaStructures->At(i)->iAttaCharset) + { + mimeHeaders->SetMimeCharset(iAttaStructures->At(i)->iAttaCharset); + } + + if (iAttaStructures->At(i)->iAttaName->Length()) + { + iFilename.Copy(iAttaStructures->At(i)->iAttaName->Des()); + } + iParse.Set( iFilename, NULL, NULL ); + iFilename.Copy( iParse.NameAndExt() ); + + mimeHeaders->SetContentLocationL( iFilename ); + + // if Mime type has not been set, use RapaRecognizer + if ( iAttaStructures->At(i)->iAttaType->Length() == 0 && iFilename.Length() > 0) + { + // TO BE IMPLEMENTED + + RApaLsSession lsSession; + + if ( lsSession.Connect() == KErrNone ) + { + CleanupClosePushL( lsSession ); + + iFilename.Copy(iAttaStructures->At(i)->iAtta->Des()); + if ( lsSession.RecognizeData( iFilename, TPtrC8(), result ) == KErrNone ) + { + // Check confidence level. Recognization must be at least + // "EProbable". We don't accept the result if it is "EPossible" + // or "EUnlikely" or "ENotRecognized"! + + if ( result.iConfidence < CApaDataRecognizerType::EProbable ) + { + result.Reset(); // clear buffer and try again with longer buffer + } + + TPtrC8 mimeBuf8 = result.iDataType.Des8(); + + if ( mimeBuf8.Length() == 0 ) + { + // Open file buffer and try again.. + + TInt bufSize = 0; + (void)lsSession.GetMaxDataBufSize( bufSize ); // ignore errors + if ( bufSize <= 0 ) + { + bufSize = 30; + } + HBufC8* buf = HBufC8::NewLC( bufSize ); + TPtr8 des = buf->Des(); + + RFile file; + TInt err=file.Open( iFs, iFilename, EFileShareReadersOnly ); + if ( err == KErrNone ) + { + err = file.Read( des ); + file.Close(); + if ( err == KErrNone ) + { + if ( ( lsSession.RecognizeData( iFilename, des, result ) ) == KErrNone ) + { + mimeBuf8.Set( result.iDataType.Des8() ); + } + } + + } + CleanupStack::PopAndDestroy(); // buf + } + if ( mimeBuf8.Length() > 0 && + result.iConfidence >= CApaDataRecognizerType::EProbable ) + { + contentType.Set( result.iDataType.Des8() ); + } + } + CleanupStack::PopAndDestroy(1); // lssession + } + } + + if ( contentType.Length() > 0 ) + { + TInt position = contentType.Find( KMmsSlash8 ); + if ( position >= 0 ) + { + mimeHeaders->SetContentTypeL( contentType.Left( position ) ); + } + if ( position < contentType.Length() - 1 ) + { + mimeHeaders->SetContentSubTypeL( contentType.Mid( position + 1 ) ); + } +// CreateAttachment2L sets the content type to attaInfo +// attaInfo->SetMimeTypeL( contentType ); + } + + if (iAttaStructures->At(i)->iAttaRecommendedName->Length()) + { + iFilename.Copy(iAttaStructures->At(i)->iAttaRecommendedName->Des()); + iParse.Set( iFilename, NULL, NULL ); + iFilename.Copy( iParse.NameAndExt() ); + mimeHeaders->SetSuggestedFilenameL( iFilename ); + } + + TInt j = 0; + for ( j = 0; j < iAttaStructures->At(i)->iContentTypeParams->MdcaCount(); ++j ) + { + mimeHeaders->ContentTypeParams().AppendL( iAttaStructures->At(i)->iContentTypeParams->MdcaPoint( j ) ); + } + for ( j = 0; j < iAttaStructures->At(i)->iXTypeParams->MdcaCount(); ++j ) + { + mimeHeaders->XTypeParams().AppendL( iAttaStructures->At(i)->iXTypeParams->MdcaPoint( j ) ); + } + + attaInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); + // attaInfo does not go onto cleaunpstack because ownership will + // be transferred to attachment manager. + + aMmsClient->CreateAttachment2L( + *store, + attaFile, + contentType, + *mimeHeaders, + attaInfo, + attaId); + attaInfo = NULL; // ownership transferred + + CleanupStack::PopAndDestroy(); // mimeHeaders + CleanupStack::PopAndDestroy(); // attaFile.Close() + + if ( iAttaRoot > 0 && iAttaRoot == ( i + 1 ) ) + { + aMmsClient->SetMessageRootL( attaId ); + } + } + + store->CommitL(); + CleanupStack::PopAndDestroy(); // store + + // This frees all memory and resets all values + Reset(); + // Reset inactivity timer to keem viewServer from crashing + User::ResetInactivityTime(); + } + + +// --------------------------------------------------------- +// CMmsReadFile()::FindAlias +// program build a message from given parts +// --------------------------------------------------------- +// +TInt CMmsReadFile::FindAlias( TPtrC aAlias ) + { + TBuf abuf; + for( TInt i=0; i < iAliasCount; ++i ) + { + abuf.Copy( iAliasArray->MdcaPoint(i) ); + abuf.SetLength( abuf.Locate('=') ); + if( ( abuf.CompareF( aAlias ) ) == 0 ) return( i ); + } + return( -1 ); + } + + +// C++ default constructor can NOT contain any code, that +// might leave. +// +CMmsAttaStructure::CMmsAttaStructure() + { + iAtta = NULL; + iAttaType = NULL; + iAttaName = NULL; + iAttaCid = NULL; + iAttaRecommendedName = NULL; + } + + +// +void CMmsAttaStructure::ConstructL() + { + iAtta = HBufC8::NewL(DefaultBufLen); + iAttaType = HBufC8::NewL(DefaultBufLen); + iAttaName = HBufC8::NewL(DefaultBufLen); + iAttaCid = HBufC8::NewL(DefaultBufLen); + iAttaRecommendedName = HBufC::NewL(DefaultBufLen); + iAttaCharset = 0; + iXTypeParams = new(ELeave) CDesC8ArrayFlat(4); + iContentTypeParams = new(ELeave) CDesC8ArrayFlat(4); + + } + +// Two-phased constructor. +CMmsAttaStructure* CMmsAttaStructure::NewL() + { + CMmsAttaStructure* self = new ( ELeave ) CMmsAttaStructure; + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +// Destructor +CMmsAttaStructure::~CMmsAttaStructure() + { + delete iAtta; + delete iAttaName; + delete iAttaType; + delete iAttaCid; + delete iAttaRecommendedName; + if ( iContentTypeParams ) + { + iContentTypeParams->Reset(); + } + delete iContentTypeParams; + if ( iXTypeParams ) + { + iXTypeParams->Reset(); + } + delete iXTypeParams; + } + + +// End of File