diff -r 000000000000 -r 8e480a14352b messagingfw/msgtest/testutils/sms/src/SmsTestUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/msgtest/testutils/sms/src/SmsTestUtils.cpp Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,1323 @@ +// Copyright (c) 1999-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 "smstestutils.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace CommsDat; + +#include "EmsMsgTestUtils.h" +#include "emstestutils.h" +#include +#include + +#include "CAsyncWaiter.h" + +#include +#include + +#include + +// Constants +// +const TInt KUidNetworkBarsCmtValue=0x100052DB; +const TInt KUidCmtPowerValue=0x100052D9; + +/** + @enum TSANetworkBarsCmt + Enum defining the system agent network commands + @since 6.1 +*/ +enum TSANetworkBarsCmt + { + ENBars_0, //< + ENBars_1, //< + ENBars_2, //< + ENBars_3, //< + ENBars_4, //< + ECmtPowerOn, //< Specifies that the power is on + ECmtPowerOff //< Specifies that the power is off + }; + +/** + @enum TSACmtPower + Enum defining the system agent commands for power + @since 6.1 +*/ +enum TSACmtPower + { + ECmtOn, //< Specifies that the power is on + ECmtOff //< Specifies that the power is off + }; + + + +EXPORT_C CSmsTestUtils::~CSmsTestUtils() + { + Reset(); + delete iServiceSettings; + delete iRichText; + delete iCharFormat; + delete iParaFormat; + + iRTest.Printf(_L("Waiting 3 seconds for the msg server to close...\n")); + User::After(3000000); + } + +EXPORT_C void CSmsTestUtils::AddSystemAgentConditionsL() + { + CMsvSysAgentActions* actions = new (ELeave) CMsvSysAgentActions(); + CleanupStack::PushL(actions); + + CMsvScheduleSettings* schSettings = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(schSettings); + + CMsvOffPeakTimes* offPeakTimes = new (ELeave) CMsvOffPeakTimes(); + CleanupStack::PushL(offPeakTimes); + + CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(errorActions); + + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*schSettings, *offPeakTimes, *errorActions, *actions); + + actions->iDefault.iAction = ESendActionRetryImmediately; + actions->iDefault.iRetries = ESendRetriesFixed; + actions->iDefault.iRetrySpacing = ESendRetrySpacingStatic; + actions->iDefault.SetMaxRetries(1); + + TMsvSysAgentConditionAction condAction; + + condAction.iUseDefaultSysAgentAction = ETrue; + + condAction.iCondition.iVariable = KMsvTestUidPhonePwr; + condAction.iCondition.iState = EMsvTestPhoneOn; + condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals; + + actions->AppendL(condAction); + + condAction.iCondition.iVariable = KMsvTestUidSIMStatus; + condAction.iCondition.iState = EMsvTestSimOk; + condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals; + + actions->AppendL(condAction); + + condAction.iCondition.iVariable = KMsvTestUidNetworkStatus; + condAction.iCondition.iState = EMsvTestNetworkAvailable; + condAction.iCondition.iType = TMsvCondition::EMsvSchSendEquals; + + actions->AppendL(condAction); + +// TMsvSendErrorAction action; +// TBool condMet = actions->ConditionsMetL(action); + + account->SaveSettingsL(*schSettings, *offPeakTimes, *errorActions, *actions); + CleanupStack::PopAndDestroy(4, account); + } + +/** + @fn NotifySaPhoneOnL() + Intended Usage : To notify the system agent that the phone is on. + @since 6.1 + @pre None + @post System agent has been notified. + */ +EXPORT_C void CSmsTestUtils::NotifySaPhoneOnL() + { + User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOn)); + User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidCmtPowerValue, ECmtOn)); + User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidNetworkBarsCmtValue, ECmtPowerOn)); + User::LeaveIfError(RProperty::Set(KUidSystemCategory, 0x100052E7, 8)); + } + +/** + @fn NotifySaPhoneOffL() + Intended Usage : To notify the system agent that the phone is off. + @since 6.2 + @pre None + @post System agent has been notified. + */ +EXPORT_C void CSmsTestUtils::NotifySaPhoneOffL() + { + User::LeaveIfError(RProperty::Set(KUidSystemCategory, KMsvTestUidPhonePwrValue, EMsvTestPhoneOff)); + User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidCmtPowerValue, ECmtOff)); + User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidNetworkBarsCmtValue, ECmtPowerOff)); + User::LeaveIfError(RProperty::Set(KUidSystemCategory, 0x100052E7, 8)); + } + +EXPORT_C void CSmsTestUtils::WaitForInitializeL() +/** + Initialize the phone for the tsy. This will prevent message sends from completing with KErrNotReady +*/ + { + + TName tsy; + + CMDBSession* dbSession = CMDBSession::NewL(CMDBSession::LatestVersion()); + CleanupStack::PushL(dbSession); + + CMDBRecordSet globalSettingsRecord(KCDTIdGlobalSettingsRecord); + TRAPD(err, globalSettingsRecord.LoadL(*dbSession)); + if(err != KErrNone) + { + User::Leave(KErrNotFound); + } + + CCDModemBearerRecord *modemRecord = static_cast(CCDRecordBase::RecordFactoryL(KCDTIdModemBearerRecord)); + CleanupStack::PushL(modemRecord); + modemRecord->SetRecordId(((CCDGlobalSettingsRecord*)globalSettingsRecord.iRecords[0])->iModemForPhoneServicesAndSMS); + modemRecord->LoadL(*dbSession); + tsy = modemRecord->iTsyName; + CleanupStack::PopAndDestroy(2); //dbSession, modemRecord + + RTelServer server; + User::LeaveIfError(server.Connect()); + CleanupClosePushL(server); + User::LeaveIfError(server.LoadPhoneModule(tsy)); + + // Find the phone corresponding to this TSY and open a number of handles on it + TInt numPhones; + User::LeaveIfError(server.EnumeratePhones(numPhones)); + RPhone phone; + + while (numPhones--) + { + TName phoneTsy; + User::LeaveIfError(server.GetTsyName(numPhones,phoneTsy)); + if (phoneTsy.CompareF(tsy)==KErrNone) + { + RTelServer::TPhoneInfo info; + User::LeaveIfError(server.GetPhoneInfo(numPhones,info)); + User::LeaveIfError(phone.Open(server,info.iName)); + CleanupClosePushL(phone); + const TInt err = phone.Initialise(); + User::LeaveIfError(err); + CleanupStack::PopAndDestroy(&phone); + break; + } + } + + CleanupStack::PopAndDestroy(&server); + } + +EXPORT_C CSmsTestUtils* CSmsTestUtils::NewL(RTest& aRTest, TUint aCreationFlags) + { + CSmsTestUtils* self = NewLC(aRTest, aCreationFlags); + CleanupStack::Pop(); + return self; + } + +EXPORT_C CSmsTestUtils* CSmsTestUtils::NewLC(RTest& aRTest, TUint aCreationFlags) + { + CSmsTestUtils* self = new(ELeave) CSmsTestUtils(aRTest); + CleanupStack::PushL(self); + self->ConstructL(aCreationFlags); + return self; + } + +void CSmsTestUtils::Reset() + { + if (iSmsClientMtm) + { + delete iSmsClientMtm; + iSmsClientMtm=NULL; +// iMsvEntry=NULL; + } + + CMsvTestUtils::Reset(); + } + +// +// Register a Sms Mtm server DLL +// +EXPORT_C void CSmsTestUtils::CreateSmsServerMtmRegL() + { + CreateServerMtmRegL(KUidMsgTypeSMS, _L("SMS"), KSmsServerMtmFileName(), KSmsClientMtmFileName(), TMsvTestDllInfo(KSmsUiMtmFileFileName,2), TMsvTestDllInfo(KSmsUiMtmFileFileName,1), KUidMsgTypeSMS, KSmsDataComponentFileName); + } + +EXPORT_C TMsvId CSmsTestUtils::CreateSmsServiceL() + { + // create service in root + TInt err = KErrNone; + iSmsServiceId = 0; + TRAP(err, ServiceIdL(KUidMsgTypeSMS, iSmsServiceId)); + + if (err) + { + if (!iServiceSettings) + { + iServiceSettings = CSmsSettings::NewL(); + } + + CSmsAccount* account = CSmsAccount::NewLC(); + account->InitialiseDefaultSettingsL(*iServiceSettings); + ServiceIdL(KUidMsgTypeSMS, iSmsServiceId); + + iServiceSettings->SetValidityPeriod(ESmsVPWeek); // week + iServiceSettings->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFInteger); //relative + iServiceSettings->AddServiceCenterL(_L("Vodafone"), _L("+4477850016005")); + iServiceSettings->AddServiceCenterL(_L("Sonera"), _L("+358405202000")); + iServiceSettings->SetDefaultServiceCenter(1); + iServiceSettings->SetReplyQuoted(EFalse); + iServiceSettings->SetRejectDuplicate(ETrue); + iServiceSettings->SetDelivery(ESmsDeliveryImmediately); + iServiceSettings->SetDeliveryReport(ETrue); + iServiceSettings->SetReplyPath(EFalse); + iServiceSettings->SetMessageConversion(ESmsConvPIDNone); + iServiceSettings->SetCanConcatenate(ETrue); + + account->SaveSettingsL(*iServiceSettings); + + CMsvScheduleSettings* schSettings = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(schSettings); + + CMsvOffPeakTimes* offPeakTimes = new (ELeave) CMsvOffPeakTimes(); + CleanupStack::PushL(offPeakTimes); + + CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(errorActions); + + CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions(); + CleanupStack::PushL(sysAgentActions); + + account->LoadSettingsL(*schSettings, *offPeakTimes, *errorActions, *sysAgentActions); + + schSettings->SetLongInterval(30); + schSettings->SetShortInterval(10); + + account->SaveSettingsL(*schSettings, *offPeakTimes, *errorActions, *sysAgentActions); + + CleanupStack::PopAndDestroy(5, account); + } + else + { + User::Leave(KErrAlreadyExists); + } + + return iSmsServiceId; + } + + +EXPORT_C void CSmsTestUtils::InstallSmsMtmGroupL() + { + InstallMtmGroupL(KSmsDataComponentFileName); + } + +EXPORT_C void CSmsTestUtils::InstantiateSmsClientMtmL() + { + __ASSERT_ALWAYS(iSmsServiceId, Panic(KSmsTestUtilsPanicSmsServiceIdNotSet)); + delete iSmsClientMtm; + iSmsClientMtm = NULL; + iSmsClientMtm = (CSmsClientMtm*) InstantiateClientMtmL(KUidMsgTypeSMS, iSmsServiceId); + } + +EXPORT_C CSmsTestUtils::CSmsTestUtils(RTest& aRTest) +: CMsvTestUtils(aRTest), iSmsServiceId(KMsvNullIndexEntryId), iSmokeTest(EFalse) + { + } + +EXPORT_C void CSmsTestUtils::ConstructL(TUint aFlags) + { + CMsvTestUtils::ConstructL(aFlags); + + + iParaFormat = CParaFormatLayer::NewL(); + iCharFormat = CCharFormatLayer::NewL(); + iRichText = CRichText::NewL(iParaFormat, iCharFormat); + } + +EXPORT_C void CSmsTestUtils::SaveBodyToFileL(TMsvId aId) + { + SetEntryL(aId); + + CMsvStore* store = ReadStoreL(); + CleanupStack::PushL(store); + + iRichText->Reset(); + store->RestoreBodyTextL(*iRichText); + + CleanupStack::PopAndDestroy(store); + + const TInt length = iRichText->DocumentLength(); + + HBufC* buf = HBufC::NewLC(length); + HBufC8* buf8 = HBufC8::NewLC(length); + + TPtr bufPtr(buf->Des()); + + iRichText->Extract(bufPtr); + buf8->Des().Copy(*buf); + TFileName path; + + + TInt bioType = Entry().iBioType; + path.AppendNum((TUint)Entry().Id()); + path.Append(_L("-")); + path.AppendNum(bioType); + path.Append(_L(".body")); + + // Remove any attachments with the same name + if (iClientServer == EClientSide) + { + store = iMsvEntry->EditStoreL(); + } + else if (iClientServer == EServerSide) + { + store = iServerEntry->EditStoreL(); + } + else + { + User::Leave(KErrNotSupported); + } + CleanupStack::PushL(store); + + CAsyncWaiter* waiter = CAsyncWaiter::NewL(); + CleanupStack::PushL(waiter); + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + for(TInt ii=0; iiAttachmentName().CompareF(path) == 0 ) + { + CTestActive* testActive = new (ELeave) CTestActive(); + CleanupStack::PushL(testActive); + + // found a matching attachment, remove it + manager.RemoveAttachmentL(ii, waiter->iStatus); + waiter->StartAndWait(); + User::LeaveIfError(waiter->Result()); + } + CleanupStack::PopAndDestroy(attachment); + + } + + // create a new attachment file + CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); + CleanupStack::PushL(attachment); + attachment->SetSize(buf->Length()); + attachment->SetAttachmentNameL(path); + RFile file; + manager.CreateAttachmentL(path, file, attachment, waiter->iStatus); + CleanupStack::Pop(attachment); // ownership passed + waiter->StartAndWait(); + User::LeaveIfError(waiter->Result()); + + CleanupClosePushL(file); + + file.Write(*buf8); + file.Flush(); + + CleanupStack::PopAndDestroy(5, buf); // file, waiter, store, buf8, buf + } + + + +void CSmsTestUtils::DisplayChildDetailsL(const TMsvEntry& aEntry) + { + iRTest.Printf(KMsvTestUtilsNewLine); + DisplayChildL(aEntry); + iRTest.Printf(KMsvTestUtilsNewLine); + + if ((aEntry.iMtm != KUidMsgTypeSMS && aEntry.iMtm != KUidBIOMessageTypeMtm) || aEntry.iType != KUidMsvMessageEntry) + return; + + CMsvEntry* cEntry = iMsvSession->GetEntryL(aEntry.Id()); + CleanupStack::PushL(cEntry); + + CSmsHeader* header = DoGetHeaderLC(*cEntry); + + TBuf<256> temp; + temp.Append(_L("\tType: SMS ")); + + switch (header->Type()) + { + case CSmsPDU::ESmsDeliver: + temp.Append(_L("Deliver\n")); + break; + case CSmsPDU::ESmsSubmit: + temp.Append(_L("Submit\n")); + break; + case CSmsPDU::ESmsDeliverReport: + temp.Append(_L("Deliver Report\n")); + break; + case CSmsPDU::ESmsSubmitReport: + temp.Append(_L("Submit Report\n")); + break; + default: + temp.Append(_L("Other\n")); + break; + } + + iRTest.Printf(temp); + temp.Zero(); + + iRTest.Printf(_L("\tBio Type UID: %d\n"), aEntry.iBioType); + iRTest.Printf(_L("\tSending State: %d\n"), aEntry.SendingState()); + + if (header->Type() == CSmsPDU::ESmsDeliver) + { + CSmsDeliver& pdu = header->Deliver(); + + TBool found = EFalse; + TInt destination, originator, is16Bit; + destination = originator = is16Bit = 0; + if (pdu.UserDataPresent()) + { + const CSmsUserData& userData = pdu.UserData(); + TInt count = userData.NumInformationElements(); + iRTest.Printf(_L("\tPdu contains %d information elements\n"), count); + while (!found && count--) + { + CSmsInformationElement& nextIE=userData.InformationElement(count); + switch(nextIE.Identifier()) + { + case CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit: + case CSmsInformationElement::ESmsIEIApplicationPortAddressing16Bit: + { + pdu.ApplicationPortAddressing(destination, originator, &is16Bit); + found = ETrue; + break; + } + default: + break; + } + } + } + if (found) + iRTest.Printf(_L("\tApplication Port Addressing: Dest %d, Origin %d, is16Bit %d\n"), destination, originator, is16Bit); + else + iRTest.Printf(_L("\tApplication Port Addressing: Not Found\n")); + } + + CleanupStack::PopAndDestroy(header); + CleanupStack::PopAndDestroy(cEntry); + + iRTest.Printf(_L("\n'S'ave or any other key...\n")); + TChar key = iRTest.Getch(); + + if (key == 's' || key == 'S') + { + TRAPD(err, SaveBodyToFileL(aEntry.Id())); + + if (!err) + iRTest.Printf(_L("\nMessage body saved OK\n")); + else + iRTest.Printf(_L("\nSave ERROR %d\n"), err); + + iRTest.Getch(); + } + } + +EXPORT_C void CSmsTestUtils::DisplayMessagesL(const CMsvEntrySelection& aSelection) + { + TInt count = aSelection.Count(); + + for (TInt i = 0; i < count; i++) + { + DisplayMessageL(aSelection[i]); + } + } + +EXPORT_C void CSmsTestUtils::DisplayMessageL(TMsvId aId) + { + SetEntryL(aId); + CSmsHeader* header = GetHeaderLC(aId); + + HBufC* buf = HBufC::NewLC(100 + Entry().iDetails.Length() + Entry().iDescription.Length()); + TPtr temp(buf->Des()); + + temp.AppendNum((TInt) aId); + temp.Append(_L(" Type: ")); + + switch (header->Type()) + { + case CSmsPDU::ESmsDeliver: + temp.Append(_L("Deliver")); + break; + case CSmsPDU::ESmsSubmit: + temp.Append(_L("Submit ")); + break; + case CSmsPDU::ESmsSubmitReport: + temp.Append(_L("SubRprt")); + break; + case CSmsPDU::ESmsDeliverReport: + temp.Append(_L("DelRprt")); + break; + default: + temp.Append(_L("Other ")); + break; + } + + temp.Append(_L(" Rcpts: ")); + temp.AppendNum(header->Recipients().Count()); + temp.Append(_L(" Det: \"")); + temp.Append(Entry().iDetails); + temp.Append(_L("\" Desc: \"")); + temp.Append(Entry().iDescription); + temp.Append(_L("\"\n")); + Printf(*buf); + + CleanupStack::PopAndDestroy(buf); + CleanupStack::PopAndDestroy(header); + } + +EXPORT_C TBool CSmsTestUtils::ReadScriptL(const TDesC& aFile, TMsvId aDestFolder, CMsvEntrySelection& aSelection, const TTime& aDate) + { + TParse fileOut; + + User::LeaveIfError(ResolveFile(KSmsComponent, aFile, fileOut)); + + return DoReadScriptL(fileOut.FullName(), aDestFolder, aSelection, aDate); + } + +TBool CSmsTestUtils::DoReadScriptL(const TDesC& aFile, TMsvId aDestFolder, CMsvEntrySelection& aSelection, const TTime& aDate) + { + CScriptFile* scriptFile = CScriptFile::NewLC(*this, KSmsComponent, aFile); + TBool retVal = CreateMessagesL(aDestFolder, *scriptFile, aSelection, aDate); + CleanupStack::PopAndDestroy(scriptFile); + return retVal; + } + +TBool CSmsTestUtils::CreateMessagesL(TMsvId aDestFolder, CScriptFile& rFile, CMsvEntrySelection& rSelection, const TTime& aDate) + { + CArrayPtrFlat& sections = rFile.Sections(); + + TBool retVal = EFalse; + + if (!sections.Count()) + return EFalse; + + const TInt secCount = sections.Count(); + TInt count = secCount; + TInt all = KErrNotFound; + CScriptSection* section = NULL; + + while (count--) + { + section = sections[count]; + if (section->SectionName().CompareF(_L("All")) == 0) + { + all = count; + break; + } + } + + count = secCount; + + for(TInt item = 0; item < count; item++) + { + section = sections[item]; + + if (item == all) + { + continue; + } + + TPtrC typePtr(section->ItemValue(KScriptItemMessageType, KScriptItemSubmit)); // CJCW + TPtrC classPtr(section->ItemValue(KScriptItemMessageClass, KScriptItemClassDefault)); // CJCW + TPtrC scPtr(section->ItemValue(KScriptItemSC, KScriptItemSCDef)); + TPtrC rcptsPtr(section->ItemValue(KScriptItemRecipients, KScriptItemRecipientsDef)); + TInt bioId(section->ItemValue(KScriptItemBioUid, KScriptItemBioUidDef)); + TInt encoding(section->ItemValue(KScriptItemEncoding, KScriptItemEncodingDef)); + TPtrC drPtr(section->ItemValue(KScriptItemDeliveryReport, KScriptItemDeliveryReportDef)); + TPtrC bearerPtr(section->ItemValue(KScriptItemBearer, KScriptItemBearerDef)); + TPtrC msgPtr(section->ItemValue(KScriptItemMessage, KNullDesC)); + TPtrC filePtr(section->ItemValue(KScriptItemFile, KNullDesC)); + + TBioMsgIdType bearer = EBioMsgIdNbs; + + if (bearerPtr.CompareF(_L("wap")) == 0) + { + bearer = EBioMsgIdWap; + } + else if (bearerPtr.CompareF(_L("wapsecure")) == 0) + { + bearer = EBioMsgIdWapSecure; + } + + TSmsDataCodingScheme::TSmsAlphabet alpha = TSmsDataCodingScheme::ESmsAlphabet7Bit; + + switch (encoding) + { + case 7: + alpha = TSmsDataCodingScheme::ESmsAlphabet7Bit; + break; + case 8: + alpha = TSmsDataCodingScheme::ESmsAlphabet8Bit; + break; + case 16: + alpha = TSmsDataCodingScheme::ESmsAlphabetUCS2; + break; + default: + alpha = TSmsDataCodingScheme::ESmsAlphabet7Bit; + break; + } + + TBool changeDR = ETrue; + TBool deliveryReport = EFalse; + + if (drPtr.CompareF(_L("NO")) == 0) + { + deliveryReport = EFalse; + } + else if (drPtr.CompareF(_L("YES")) == 0) + { + deliveryReport = ETrue; + } + else + { + changeDR = EFalse; + } + + if (filePtr.Length()) + { + HBufC8* tempMsg = NULL; + TRAPD(resErr, tempMsg = ReadFileLC(filePtr)); + + if (resErr) + { + TParse fileOut; + resErr = ResolveFile(KSmsComponent, filePtr, fileOut); + + if (resErr) + { + Printf(_L("Cannot resolve file %S\n"), &filePtr); + User::Leave(resErr); + } + + tempMsg = ReadFileLC(fileOut.FullName()); + } + + HBufC* msgVal = HBufC::NewLC(tempMsg->Length()); + msgVal->Des().Copy(*tempMsg); + section->ReplaceItemL(KScriptItemMessage, *msgVal); + CleanupStack::PopAndDestroy(2); //tempMsg, msgVal + msgPtr.Set(section->ItemValue(KScriptItemMessage, KNullDesC)); + } + + if (msgPtr.Length()) + { + //Replace LF with CRLF for vCards and vCals only + if (bioId == KVCardBioUid.iUid || bioId == KVCalBioUid.iUid || msgPtr.Left(5) == _L("//SCK")) + { + CScriptSectionItem* sectionItem = section->Item(KScriptItemMessage); + + __ASSERT_ALWAYS(sectionItem, Panic(KErrNotFound)); + + CScriptFile::ReplaceL(KScriptCRLF, KScriptLF, sectionItem->iValue); + CScriptFile::ReplaceL(KScriptLF, KScriptCRLF, sectionItem->iValue); + TInt valLen = sectionItem->Value().Length(); + sectionItem->iValue = sectionItem->iValue->ReAllocL(valLen + 2); + sectionItem->iValue->Des().Append(KScriptCRLF); + } + + TLex input(rcptsPtr); + TPtrC rcpt; + TInt curRcpt = 0; + TMsvEntry entry; + + while (CScriptFile::GetNextWord(input, '|', rcpt) == KErrNone) + { + if (rcpt.CompareF(KDefault1) == 0 || rcpt.CompareF(KDefault2) == 0) + { + CScriptSection* defaults = section->Defaults(); + if (defaults != NULL) + { + rcpt.Set(defaults->ItemValue(KScriptItemRecipients, KScriptItemRecipientsDef)); + } + } + + retVal = ETrue; + + if (!curRcpt) + { + entry = TMsvEntry(); + entry.iBioType = bioId; + entry.SetSendingState(KMsvSendStateUponRequest); + + CSmsPDU::TSmsPDUType type=CSmsPDU::ESmsSubmit; + if (typePtr.CompareF(KScriptItemSubmit) == 0) // CJCW + type=CSmsPDU::ESmsSubmit; + else if (typePtr.CompareF(KScriptItemDeliver) == 0) + type=CSmsPDU::ESmsDeliver; + else if (typePtr.CompareF(KScriptItemStatusReport) == 0) + type=CSmsPDU::ESmsStatusReport; + else if (typePtr.CompareF(KScriptItemSubmit) == 0) + type=CSmsPDU::ESmsCommand; + else + User::Leave(KErrNotSupported); + + CSmsHeader* header = CSmsHeader::NewL(type, *iRichText); // CJCW + CleanupStack::PushL(header); + + iRichText->Reset(); + if (msgPtr.Length()) + { + if (type==CSmsPDU::ESmsStatusReport) + { + CSmsStatusReport& statusreport=header->StatusReport(); + statusreport.SetParameterIndicatorPresent(ETrue); + statusreport.SetDataCodingSchemePresent(ETrue); + statusreport.SetUserDataPresent(ETrue); + } + iRichText->InsertL(0, msgPtr); + } + + __ASSERT_ALWAYS(iServiceSettings, Panic(KSmsTestUtilsPanicSettingsNotConstructed)); + + header->SetSmsSettingsL(*iServiceSettings); + + if (type==CSmsPDU::ESmsSubmit || type==CSmsPDU::ESmsDeliver) + { + CSmsPDU& pdu=header->Message().SmsPDU(); + if (classPtr.CompareF(KScriptItemClassDefault)==0) + pdu.SetClass(EFalse,TSmsDataCodingScheme::ESmsClass0); + else if (classPtr.CompareF(KScriptItemClass0)==0) + pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass0); + else if (classPtr.CompareF(KScriptItemClass1)==0) + pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass1); + else if (classPtr.CompareF(KScriptItemClass2)==0) + pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass2); + else if (classPtr.CompareF(KScriptItemClass3)==0) + pdu.SetClass(ETrue,TSmsDataCodingScheme::ESmsClass3); + } + + if (changeDR) + { + switch (header->Type()) + { + case CSmsPDU::ESmsSubmit: + { + header->Submit().SetStatusReportRequest(deliveryReport); + break; + } + case CSmsPDU::ESmsCommand: + { + header->Command().SetStatusReportRequest(deliveryReport); + break; + } + default: + User::Leave(KErrNotSupported); + }; + } + + header->SetBioMsgIdType(bearer); + + if (scPtr.CompareF(KScriptItemSCUseDefault) == 0) + { + header->Message().SetServiceCenterAddressL(TPtrC()); + } + else + { + header->Message().SetServiceCenterAddressL(scPtr); + } + + // Extract the EMS objects + CEmsExtractor* ems = CEmsExtractor::NewLC(*section); + ems->AddToMessageL(header->Message()); + CleanupStack::PopAndDestroy(ems); + + CSmsPDU& pdu=header->Message().SmsPDU(); + if (pdu.DataCodingSchemePresent()) + pdu.SetAlphabet(alpha); + + TMsvId destfolder=aDestFolder; + if (destfolder==KMsvNullIndexEntryId) + destfolder=(type==CSmsPDU::ESmsSubmit) || (type==CSmsPDU::ESmsCommand)? KMsvGlobalOutBoxIndexEntryId: KMsvGlobalInBoxIndexEntryId; + + CreateMessageL(destfolder, entry, *header, *iRichText, aDate); + CleanupStack::PopAndDestroy(); //header + + AddRecipientL(entry.Id(), rcpt); + + rSelection.AppendL(entry.Id()); + } + else + { + AddRecipientL(entry.Id(), rcpt); + } + + curRcpt++; + } + } + } + + return retVal; + } + +EXPORT_C TMsvId CSmsTestUtils::CreateDummyMessageToSendL() + { + TMsvEntry entry; + entry.SetSendingState(KMsvSendStateUponRequest); + entry.iDate.HomeTime(); + + iRichText->Reset(); + iRichText->InsertL(0,_L("This is a send test.\näöå\n Cheers, Mico\n")); + + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit,*iRichText); + CleanupStack::PushL(header); + + header->SetSmsSettingsL(*iServiceSettings); + + CSmsNumber* recipient=CSmsNumber::NewL(); + CleanupStack::PushL(recipient); + recipient->SetAddressL(KScriptItemRecipientsDef); + recipient->SetNameL(_L("Anthony")); + header->Recipients().AppendL(recipient); + CleanupStack::Pop(); //recipients + + CSmsNumber* recipient2=CSmsNumber::NewL(); + CleanupStack::PushL(recipient2); + recipient2->SetAddressL(KScriptItemRecipients2Def); + recipient2->SetNameL(_L("Julia")); + header->Recipients().AppendL(recipient2); + CleanupStack::Pop(); //recipients + + TTime now; + now.HomeTime(); + + CreateMessageL(KMsvGlobalOutBoxIndexEntryId, entry, *header, *iRichText, now); +// Printf(_L("Test Create Message (%d) To Send\n"), entry.Id()); + + CleanupStack::PopAndDestroy(1); //header + + return entry.Id(); + } + +EXPORT_C TMsvId CSmsTestUtils::CreateDummyMessageToReceiveL() + { + TMsvEntry entry; + entry.iType=KUidMsvMessageEntry; + entry.SetSendingState(KMsvSendStateNotApplicable); + + iRichText->Reset(); + iRichText->InsertL(0,_L("Hiphei")); + + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iRichText); + CleanupStack::PushL(header); + + header->SetFromAddressL(KScriptItemRecipientsDef); + header->Message().SetServiceCenterAddressL(KScriptItemSCDef); + + TTime now; + now.HomeTime(); + + CreateMessageL(KMsvGlobalInBoxIndexEntryId, entry, *header, *iRichText, now); + entry.SetReadOnly(ETrue); + ChangeEntryL(entry); + +// Printf(_L("Create Message (%d) To Receive\n"), entry.Id()); + + CleanupStack::PopAndDestroy(1); //header + return entry.Id(); + } + +EXPORT_C void CSmsTestUtils::CreateMessageL(TMsvId aDestFolder, TMsvEntry& aEntry, CSmsHeader& aHeader, CRichText& aBody, const TTime& aDate) + { + TSmsUtilities::PopulateMsgEntry(aEntry, aHeader.Message(), iSmsServiceId); + TBuf desc; + + TSmsUtilities::GetDescription(aHeader.Message(), desc); + aEntry.iDescription.Set(desc); + + aEntry.iDate = aDate; + + SetEntryL(aDestFolder); + + CreateEntryL(aEntry); + + if (iClientServer == EClientSide) + iMsvSession->CleanupEntryPushL(aEntry.Id()); + + SetEntryL(aEntry.Id()); + + CMsvStore* store = EditStoreL(); + CleanupStack::PushL(store); + + aHeader.StoreL(*store); + + store->StoreBodyTextL(aBody); + + store->CommitL(); + + aEntry.iSize = store->SizeL(); + ChangeEntryL(aEntry); + + CleanupStack::PopAndDestroy(store); + + if (iClientServer == EClientSide) + iMsvSession->CleanupEntryPop(); + } + +EXPORT_C void CSmsTestUtils::AddRecipientL(TMsvId aId, const TDesC& aNumber) + { + CSmsHeader* header = GetHeaderLC(aId); + + SetEntryL(aId); + CMsvStore* store = EditStoreL(); + CleanupStack::PushL(store); + + CSmsNumber* rcpt = CSmsNumber::NewL(); + CleanupStack::PushL(rcpt); + rcpt->SetAddressL(aNumber); + + TBuf details; + + if (TSmsUtilities::GetDetails(iFs, aNumber, details) == KErrNone) + { + rcpt->SetNameL(details); + TMsvEntry entry(Entry()); + entry.iDetails.Set(details); + ChangeEntryL(entry); + } + + header->Recipients().AppendL(rcpt); + CleanupStack::Pop(); //rcpt; + + header->StoreL(*store); + + store->CommitL(); + + CleanupStack::PopAndDestroy(store); + CleanupStack::PopAndDestroy(header); + } + +EXPORT_C void CSmsTestUtils::Panic(TSmsTestUtilsPanic aPanic) + { + Panic((TInt) aPanic); + } + +EXPORT_C void CSmsTestUtils::Panic(TInt aPanic) + { + User::Panic(SMSTEST_PANIC, aPanic); + } + +EXPORT_C void CSmsTestUtils::InstantiateSmsServerMtmL() + { + InstantiateServerMtmL(KUidMsgTypeSMS, iSmsServiceId); + } + +EXPORT_C void CSmsTestUtils::DeleteSmsServiceL() + { + DeleteServiceL(KUidMsgTypeSMS); + } + +EXPORT_C TMsvId CSmsTestUtils::FindExistingSmsServiceL() + { + TMsvId firstId = 0; + ServiceIdL(KUidMsgTypeSMS, firstId); + return firstId; + } + +EXPORT_C void CSmsTestUtils::FindExistingServicesL() + { + iSmsServiceId = 0; + TRAPD(err, iSmsServiceId = FindExistingSmsServiceL()); + + if (err) + Printf(_L("No existing SMS services found!\n")); + } + +EXPORT_C void CSmsTestUtils::DeleteSmsMessagesL(TMsvId aFolder) + { + SetEntryL(aFolder); + CMsvEntrySelection* sel = ChildrenWithMtmLC(KUidMsgTypeSMS); + + TInt count = sel->Count(); + + while (count--) + { + DeleteEntryL(sel->At(count)); + } + + CleanupStack::PopAndDestroy(); //sel + } + +EXPORT_C TBool CSmsTestUtils::AreMessagesSameTextL(TMsvId aSentId, TMsvId aRecvId, TBool aPrintIfMismatch) + { + __ASSERT_ALWAYS(aSentId != aRecvId, Panic(KSmsTestUtilsPanicCannotCompareSameIds)); + + CSmsHeader* sentHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iRichText); + CleanupStack::PushL(sentHeader); + CSmsHeader* rcvdHeader = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *iRichText); + CleanupStack::PushL(rcvdHeader); + + // extract the sent message + SetEntryL(aSentId); + CMsvStore* store = ReadStoreL(); + CleanupStack::PushL(store); + sentHeader->RestoreL(*store); + CleanupStack::PopAndDestroy(); //store + + // do the same for the rx message + SetEntryL(aRecvId); + store = ReadStoreL(); + CleanupStack::PushL(store); + rcvdHeader->RestoreL(*store); + CleanupStack::PopAndDestroy(); //store + + // compare the text and the EMS objects + TBool retVal = EmsTestUtils::CompareEmsMsgL(sentHeader->Message(), rcvdHeader->Message()); + if (!retVal && aPrintIfMismatch) + { + Printf(_L("Message mismatch...\n")); + } + + CleanupStack::PopAndDestroy(rcvdHeader); + CleanupStack::PopAndDestroy(sentHeader); + + return retVal; + } + +void CSmsTestUtils::DisplayLogEventData(const CLogEvent& aEvent) + { + if (aEvent.EventType() == KLogShortMessageEventTypeUid) + { + TLogSmsPduData data; + TPckg packeddata(data); + packeddata.Copy(aEvent.Data()); + + TBuf<256> output; + output.Append(_L("\t")); + + switch (data.iType) + { + case CSmsPDU::ESmsSubmit: + output.Append(_L("Submit")); + break; + case CSmsPDU::ESmsDeliver: + output.Append(_L("Deliver")); + break; + case CSmsPDU::ESmsStatusReport: + output.Append(_L("Status Report")); + break; + case CSmsPDU::ESmsSubmitReport: + output.Append(_L("Submit Report")); + break; + case CSmsPDU::ESmsDeliverReport: + output.Append(_L("Deliver Report")); + break; + default: + output.Append(_L("Command")); + break; + } + + output.Append(_L(" Tot %d Sent %d Deliver %d Fail %d Recvd %d\n")); + Printf(output, data.iTotal, data.iSent, data.iDelivered, data.iFailed, data.iReceived); + } + } + +EXPORT_C void CSmsTestUtils::SetCommDbServiceCenterFromScriptL(const TDesC& aScriptFile) + { + //Update the service settings with the Service Centre address read from the script + Printf(_L("Setting Comm DB Service Center from Script\n")); + + TTime now; + now.HomeTime(); + + CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection(); + CleanupStack::PushL(sel); + + ReadScriptL(aScriptFile, KMsvGlobalOutBoxIndexEntryId, *sel, now); + + Printf(_L("\t%d msgs read from %S\n"), sel->Count(), &aScriptFile); + + if (!sel->Count()) + User::Leave(KErrNotFound); + + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iRichText); + CleanupStack::PushL(header); + + SetEntryL(sel->At(0)); + CMsvStore* store = ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(store); + + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iServiceSettings); + + iServiceSettings->SetCommDbAction(CSmsSettings::EStoreToCommDb); + + TInt count = iServiceSettings->ServiceCenterCount(); + while (count--) + { + iServiceSettings->RemoveServiceCenter(count); + } + + TPtrC sc(header->Message().ServiceCenterAddress()); + Printf(_L("\tUsing service center %S\n"), &sc); + iServiceSettings->AddServiceCenterL(_L("Unknown"), sc); + + account->SaveSettingsL(*iServiceSettings); + CleanupStack::PopAndDestroy(account); + + count = sel->Count(); + while (count--) + { + TMsvId id = sel->At(count); + SetEntryL(id); + SetEntryL(Entry().Parent()); + DeleteEntryL(id); + } + + CleanupStack::PopAndDestroy(header); + CleanupStack::PopAndDestroy(sel); + Printf(_L("\tComplete: Setting Comm DB Service Center from Script\n")); + } + +EXPORT_C TBool CSmsTestUtils::SendingCompleteL(const CMsvEntrySelection& aSelection, TInt& rError) + { + TBool sent = ETrue; + const TInt msgCount = aSelection.Count(); + TInt err = KErrNone; + + for (TInt msg = 0; msg < msgCount; msg++) + { + TRAP(err, SetEntryL(aSelection[msg])); + + if (err == KErrNone) + { + TMsvEntry entry = Entry(); + + TRAP(err, SetEntryL(KMsvGlobalOutBoxIndexEntryId)); //ignore error + + switch (entry.SendingState()) + { + case KMsvSendStateSending: + case KMsvSendStateResend: + case KMsvSendStateScheduled: + case KMsvSendStateWaiting: + sent = EFalse; + break; + case KMsvSendStateFailed: + if (entry.iError) + rError = entry.iError; + else + rError = KErrGeneral; + break; + default: + break; + //nothing + } + } + } + + return sent; + } + +EXPORT_C void CSmsTestUtils::DisplaySendingStatesL(const CMsvEntrySelection& aSelection) + { + TInt err = KErrNone; + TInt msgCount = aSelection.Count(); + + for (TInt msg = 0; msg < msgCount; msg++) + { + TRAP(err, SetEntryL(aSelection[msg])); + + if (!err) + { + TMsvEntry entry = Entry(); + TRAP(err, SetEntryL(KMsvGlobalOutBoxIndexEntryId)); //ignore error + + TBuf<0x100> output; + TBuf<0x50> nowBuf; + + switch (entry.SendingState()) + { + case KMsvSendStateSending: + output.AppendFormat(_L("Message %d Sending with error %d\n"), entry.Id(), entry.iError); + break; + case KMsvSendStateResend: + output.AppendFormat(_L("Message %d Resend with error %d at:\n"), entry.Id(), entry.iError); + err = AppendScheduleTimeL(entry.Id(), output); + if (err) + { + entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B")); + output.Append(nowBuf); + output.Append(_L("\n")); + } + break; + case KMsvSendStateScheduled: + output.AppendFormat(_L("Message %d Scheduled with error %d at:\n"), entry.Id(), entry.iError); + err = AppendScheduleTimeL(entry.Id(), output); + break; + case KMsvSendStateFailed: + output.AppendFormat(_L("Message %d Failed with error %d\n"), entry.Id(), entry.iError); + break; + case KMsvSendStateWaiting: + output.AppendFormat(_L("Message %d Waiting with error %d\n"), entry.Id(), entry.iError); + break; + case KMsvSendStateSent: + output.AppendFormat(_L("Message %d Sent\n"), entry.Id()); + break; + case KMsvSendStateSuspended: + output.AppendFormat(_L("Message %d Suspended\n"), entry.Id()); + break; + default: + output.AppendFormat(_L("Message %d Other Sending State with error %d and failed %d\n"), entry.Id(), entry.iError, entry.Failed()); + break; + //nothing + } //end switch + Printf(output); + } //end if + } //end for + } + +CSmsHeader* CSmsTestUtils::DoGetHeaderLC(CMsvEntry& aEntry) + { + CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iRichText); + CleanupStack::PushL(header); + + CMsvStore* store = aEntry.ReadStoreL(); + CleanupStack::PushL(store); + + header->RestoreL(*store); + iRichText->Reset(); + store->RestoreBodyTextL(*iRichText); + + CleanupStack::PopAndDestroy(store); + + return header; + } + +EXPORT_C CSmsHeader* CSmsTestUtils::GetHeaderLC(TMsvId aId) + { + iMsvEntry->SetEntryL(aId); + return DoGetHeaderLC(*iMsvEntry); + }