/**
doTestStepL()
Performs the comparison of POP messages
@return
Returns the teststep result.
*/
TVerdict CT_MsgComparePopEmailMsgs::doTestStepL()
{
INFO_PRINTF1(_L("Test Step: Compare Pop Email Msgs"));
if(LoadParametersL())
{
User::LeaveIfError(iFs.Connect());
CleanupClosePushL(iFs);
// Normally do not push an object that is a data member of another object.
// But in this case we want to close early if we get a leave.
// Otherwise the iFs would be open till the thread had begun to die.
if(TestStepResult() == EPass)
{
CMsvEntry* recvMsvEntry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(recvMsvEntry);
CMsvEntry* sentMsvEntry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(sentMsvEntry);
for(TInt i = 0;i < iInboxSelectionList->Count();i++)
{
recvMsvEntry->SetEntryL(iInboxSelectionList->At(i));
TMsvEntry recvEntry = recvMsvEntry->Entry();
for(TInt j = 0;j < iSentSelectionList->Count();j++)
{
sentMsvEntry->SetEntryL(iSentSelectionList->At(j));
TMsvEntry sentEntry = sentMsvEntry->Entry();
if(recvEntry.iDescription.Compare(sentEntry.iDescription) == 0)
{
CExpPop3MailInfo* pExpMailInfo = NULL;
for(int k = 0;k < iExpResults.Count();k++)
{
if(iExpResults[k]->GetDescription().Compare(recvEntry.iDescription) == 0)
{
pExpMailInfo = iExpResults[k];
break;
}
}
if(! pExpMailInfo)
{
ERR_PRINTF2(_L("Test %d failed could not retrieve expected mail info"), j+1);
SetTestStepResult(EFail);
break;
}
if(! DoCompareL(recvEntry, *pExpMailInfo, sentEntry))
{
INFO_PRINTF2(_L("Test %d failed"), j + 1);
SetTestStepResult(EFail);
}
}
}
}
CleanupStack::PopAndDestroy(2, recvMsvEntry); // recvMsvEntry, sentMsvEntry
}
CleanupStack::PopAndDestroy();
}
INFO_PRINTF1(_L("T_ComparePopEmailMsgs Completed"));
return TestStepResult();
}
/**
GetMessagePartIndexL()
Retrieves the part index id for the email identified by aEntry
@param aEntry
A valid email identifier
@param aUid
An identifier tfor the type of message part to be retrieved
@return
TMsvId - message part identifier
*/
TMsvId CT_MsgComparePopEmailMsgs::GetMessagePartIndexL(TMsvEntry& aEntry, TUid aUid)
{
static TBool msgPartFound = EFalse;
TMsvId msgPartId = 0;
CMsvEntry* baseEntry = iSharedDataPOP.iSession->GetEntryL(aEntry.Id());
CleanupStack::PushL(baseEntry);
CMsvEntrySelection* selection = baseEntry->ChildrenL();
CleanupStack::PushL(selection);
TInt count = selection->Count();
TInt ind1;
CMsvEntry* entry = iSharedDataPOP.iSession->GetEntryL(KMsvRootIndexEntryId);
CleanupStack::PushL(entry);
for (ind1=0, msgPartFound=EFalse; ind1 < count; ind1++)
{
if(msgPartFound)
{
break;
}
TMsvId childId = selection->At(ind1);
entry->SetEntryL(childId);
if (entry->Entry().iType == aUid)
{
msgPartId = childId;
break;
}
else if (entry->Entry().iType == KUidMsvFolderEntry)
{
TMsvEntry ent = entry->Entry();
msgPartId = GetMessagePartIndexL(ent, aUid);
}
}
CleanupStack::PopAndDestroy(3, baseEntry); // entry,selection,baseEntry
return msgPartId;
}
/*
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
*/
void CFakeSMSSender::AppendPDUDataL(TMsvId aEntryId, const TDesC& aRecipient,TBool aUnicodeMsg,const TDesC& aBody)
{
CMsvEntry* entry = iMsvSession->GetEntryL(aEntryId);
CleanupStack::PushL(entry);
CMsvStore* srore= entry->EditStoreL();
CleanupStack::PushL(srore);
if(srore)
{
CSmsBuffer* smsBuffer = CSmsBuffer::NewL();
CSmsMessage* smsMsg = CSmsMessage::NewL(iFsSession,CSmsPDU::ESmsDeliver, smsBuffer);
CleanupStack::PushL(smsMsg);
smsMsg->SetTime(entry->Entry().iDate);
if(aRecipient.Length() > 20)
smsMsg->SetToFromAddressL(aRecipient.Left(20));
else
smsMsg->SetToFromAddressL(aRecipient);
smsBuffer->InsertL(0,aBody);
CSmsDeliver& DSMSPDU = STATIC_CAST(CSmsDeliver&,smsMsg->SmsPDU());
DSMSPDU.SetMoreMessagesToSend(EFalse);
DSMSPDU.SetReplyPath(EFalse);
DSMSPDU.SetStatusReportIndication(EFalse);
TInt Hours(0x20);
DSMSPDU.SetServiceCenterTimeStamp(entry->Entry().iDate,Hours);
DSMSPDU.SetTextCompressed(EFalse);
DSMSPDU.SetPIDType(TSmsProtocolIdentifier::ESmsPIDShortMessageType);
//DSMSPDU.SetTextCompressed(TBool aCompressed);
//DSMSPDU.SetAlphabet(TSmsDataCodingScheme::TSmsAlphabet aAlphabet);
CSmsHeader* MyHeader = CSmsHeader::NewL(smsMsg);
CleanupStack::Pop(1);//smsMsg
CleanupStack::PushL(MyHeader);
CSmsSettings* MySetting = CSmsSettings::NewL();
CleanupStack::PushL(MySetting);
if(aUnicodeMsg)
MySetting->SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabetUCS2);
else
MySetting->SetCharacterSet(TSmsDataCodingScheme::ESmsAlphabet7Bit);
//MySetting->StoreL(*srore);//InternalizeL
MyHeader->SetSmsSettingsL(*MySetting);
MyHeader->StoreL(*srore);
srore->CommitL();
CleanupStack::PopAndDestroy(2);//MySetting,MyHeader,
}
CleanupStack::PopAndDestroy(2);//entry,srore
}
// ----------------------------------------------------------------------------
// CIpsPlgPop3ConnectOp::ConstructL()
// ----------------------------------------------------------------------------
//
void CIpsPlgPop3ConnectOp::ConstructL()
{
FUNC_LOG;
BaseConstructL( KUidMsgTypePOP3 );
// <qmail> iSelection construction has been removed
CMsvEntry* cEntry = iMsvSession.GetEntryL( iService );
User::LeaveIfNull( cEntry );
// NOTE: Not using cleanupStack as it is not needed in this situation:
const TMsvEntry tentry = cEntry->Entry();
delete cEntry;
cEntry = NULL;
if ( tentry.iType.iUid != KUidMsvServiceEntryValue )
{
// should we panic with own codes?
User::Leave( KErrNotSupported );
}
// <qmail> no need to have population limit as member variable
// <qmail> it is read from settings when needed
if ( tentry.Connected() )
{
iState = EConnected;
// <qmail> iAlreadyConnected removed
}
else
{
iState = EStartConnect;
}
// <qmail> SetActive(); moved inside CompleteThis();
CompleteThis();
}
// ----------------------------------------------------------------------------
// CIpsPlgNewChildPartFromFileOperation::PrepareMsvEntryL
// ----------------------------------------------------------------------------
//
void CIpsPlgNewChildPartFromFileOperation::PrepareMsvEntryL()
{
// Dig out the entry ID of the new attachment
iMessage->GetAttachmentsListL( iEntry->Entry().Id( ),
CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly );
TKeyArrayFix key( 0, ECmpTInt32 );
CMsvEntrySelection* attachmentIds = iMessage->Selection().CopyLC();
attachmentIds->Sort( key );
if ( !attachmentIds->Count() )
{
User::Leave( KErrGeneral );
}
iNewAttachmentId = (*attachmentIds)[ attachmentIds->Count()-1 ];
CleanupStack::PopAndDestroy( attachmentIds );
CMsvEntry* cAtta = iMsvSession.GetEntryL( iNewAttachmentId );
CleanupStack::PushL( cAtta );
// Set filename to iDetails
TMsvEntry tEntry = cAtta->Entry();
tEntry.iDetails.Set(iFilePath->Des());
// Do async
iOperation = cAtta->ChangeL( tEntry, iStatus );
CleanupStack::PopAndDestroy( cAtta );
iStep = EPrepareStore; // Next step
SetActive();
}
void CScheduleTestActive::HandleSessionEventL(TMsvSessionEvent eventType, TAny* p1, TAny*, TAny*)
{
if (iStopAtRunL) return;
if (eventType != EMsvEntriesCreated) return;
CMsvEntrySelection* entries = STATIC_CAST(CMsvEntrySelection*, p1);
CMsvEntry* cEntry = iSession.GetEntryL((*entries)[0]);
CleanupStack::PushL(cEntry);
TMsvEntry entry(cEntry->Entry());
if(entry.iDetails == KSchSendTestDetails)
{
iTest.Printf(_L("Scheduled message has been sent\n"));
//We found the right message!
CActiveScheduler::Stop();
//Delete the new message
CMsvOperationWait* wait = CMsvOperationWait::NewLC();
wait->Start();
cEntry->SetEntryL(entry.Parent());
CMsvOperation* op = cEntry->DeleteL(entry.Id(), wait->iStatus);
CActiveScheduler::Start();
delete op;
CleanupStack::PopAndDestroy(wait);
}
CleanupStack::PopAndDestroy(cEntry);
}
void CMtfTestActionDeleteEntry::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionDeleteEntry);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId paramEntryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramEntryId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramEntryId);
entry->SetEntryL(entry->Entry().Parent());
if (entry->OwningService() == KMsvLocalServiceIndexEntryId)
{
entry->DeleteL(paramEntryId);
DeleteParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TestCase().ActionCompletedL(*this);
}
else
{
iOperation = entry->DeleteL(paramEntryId,iStatus);
SetActive();
}
CleanupStack::PopAndDestroy(entry);
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionDeleteEntry);
}
void CMtfTestActionSetUserResponse::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSetUserResponse);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession> (TestCase(),ActionParameters().Parameter(0));
TInt paramUserResponse = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(1),EFalse);
CMsvEntry* cEntry = CMsvEntry::NewL(*paramSession, KMsvDraftEntryId,
TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue));
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = cEntry->ChildrenL();
CleanupStack::PushL(selection);
TestCase().INFO_PRINTF2(_L("Count of Draft Folder's selection is %d"),selection->Count());
if (selection->Count() == 0)
{
User::Leave(KErrNotFound);
}
cEntry->SetEntryL((*selection)[0]);
if (!paramUserResponse)
{
TMsvEntry entry = cEntry->Entry();
entry.iError = KErrCancel;
cEntry->ChangeL(entry);
}
CleanupStack::PopAndDestroy(2);
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSetUserResponse);
TestCase().ActionCompletedL(*this);
}
TInt CMtfTestActionCheckChildrenCountWithFlagBase::CountChildrenL(TMsvId aParent, CMsvSession& aSession)
{
TInt children = 0;
// Get children at this level
CMsvEntry* entryContext = CMsvEntry::NewL(aSession, aParent,
TMsvSelectionOrdering(KMsvNoGrouping, EMsvSortByNone, ETrue));
CleanupStack::PushL(entryContext);
entryContext->SetEntryL(aParent);
TMsvSelectionOrdering order;
order.SetShowInvisibleEntries(ETrue);
entryContext->SetSortTypeL(order);
CMsvEntrySelection* selection = entryContext->ChildrenL();
CleanupStack::PushL(selection);
// for each child
TInt count=selection->Count();
for(TInt child=0;child<count;child++)
{
entryContext->SetEntryL((*selection)[child]);
TMsvEntry entry=entryContext->Entry();
if (entry.iType==KUidMsvMessageEntry && FlagIsSet(entry) )
{
++children;
}
// if this is a folder then recurse
if (entry.iType==KUidMsvFolderEntry)
children +=CountChildrenL((*selection)[child], aSession);
}
CleanupStack::PopAndDestroy(2); // selection,entryContext
return children;
}
// -----------------------------------------------------------------------------
// CMmsAdapterMsvApi::UpdateUserFolderL
// Updates user folder (changes name)
// -----------------------------------------------------------------------------
TInt CMmsAdapterMsvApi::UpdateUserFolderL( TMsvId aFolder, const TDesC& aName )
{
TRACE_FUNC_ENTRY;
LOGGER_WRITE_1( "aName: %S", &aName );
CMsvEntry* entry = iSession.GetEntryL( aFolder );
CleanupStack::PushL( entry );
TMsvEntry tEntry = entry->Entry();
if ( tEntry.iType != KUidMsvFolderEntry )
{
CleanupStack::PopAndDestroy( entry );
LOGGER_WRITE( "No message folder" );
TRACE_FUNC_EXIT;
return KErrNotSupported;
}
tEntry.iDetails.Set( aName );
tEntry.iDescription.Set( aName );
entry->ChangeL( tEntry );
CleanupStack::PopAndDestroy( entry );
TRACE_FUNC_EXIT;
return KErrNone;
}
/**
Calls the MultipleRecipient() to check if it has been set to True
*/
TInt CMtfTestActionSendAsCheckMultipleRecipientFlag::CheckFlag(CMsvEntry& aMsgEntry)
{
TInt returnValue = KErrNotFound;
TBool check = aMsgEntry.Entry().MultipleRecipients();
if (check)
{
return KErrNone;
}
return returnValue ;
}
/*
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
*/
void CSMSSender::SetMtmEntryL(TMsvId aEntryId)
{
// Get the server entry from our session
CMsvEntry* entry = iSession->GetEntryL(aEntryId);
CleanupStack::PushL(entry);
// Check if our mtm is different from the mtm set to our entry
if ((iMtm == NULL) || (entry->Entry().iMtm != (iMtm->Entry()).Entry().iMtm))
{
// If so, we delete the old...
delete iMtm;
iMtm = NULL;
// ...and get a new one from the MtmRegistry
iMtm = iMtmRegistry->NewMtmL(entry->Entry().iMtm);
}
iMtm->SetCurrentEntryL(entry);
CleanupStack::Pop(entry);
}
void MsgStoreHandler::RunL()
{
TSsmState ssmState = iStateAwareSession.State();
if (ssmState.MainState() != ESsmNormal)
{
iStateAwareSession.RequestStateNotification(iStatus);
SetActive();
}
else
{
//Create the query/operation object
CMsvSearchSortOperation *operation = CMsvSearchSortOperation::NewL(*iMsvSession);
CleanupStack::PushL(operation);
CMsvSearchSortQuery *query = CMsvSearchSortQuery::NewL();
CleanupStack::PushL(query);
//set the query options
query->SetParentId(KMsvGlobalInBoxIndexEntryId);
query->SetResultType(EMsvResultAsTMsvId);
query->AddSearchOptionL(EMsvMtmTypeUID, KSenduiMtmSmsUidValue, EMsvEqual);
query->AddSearchOptionL(EMsvUnreadMessages, ETrue);
CleanupStack::Pop(query);
CMsvOperationActiveSchedulerWait* wait = CMsvOperationActiveSchedulerWait::NewLC();
//ownership of Query transferred to Operation
operation->RequestL(query, EFalse, wait->iStatus);
wait->Start();
//Get No of entries
RArray<TMsvId> messageArray;
operation->GetResultsL(messageArray);
CMsvEntry* entry = NULL;
for (TInt i = 0; i < messageArray.Count(); ++i)
{
entry = iMsvSession->GetEntryL(messageArray[i]);
TMsvSmsEntry smsEntry = entry->Entry();
TSmsDataCodingScheme::TSmsClass classType(TSmsDataCodingScheme::ESmsClass0);
if (smsEntry.Class(classType))
{
HandleClass0SmsL(entry, smsEntry.Id());
}
else
{
delete entry;
entry = NULL;
}
}
messageArray.Close();
CleanupStack::PopAndDestroy(2, operation);
}
}
LOCAL_C void TestSetSendingStateAttributeL()
{
CDummyObserver* ob = new(ELeave)CDummyObserver;
CleanupStack::PushL(ob);
CMsvSession* session = CMsvSession::OpenSyncL(*ob);
CleanupStack::PushL(session);
CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering());
CleanupStack::PushL(cEntry);
CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
CleanupStack::PushL(selection);
TMsvEntry entry1;
entry1.iType = KUidMsvMessageEntry;
entry1.iMtm = KUidMsvLocalServiceMtm;
entry1.iServiceId = KMsvLocalServiceIndexEntryId;
entry1.SetSendingState(12);
cEntry->CreateL(entry1);
selection->AppendL(entry1.Id());
TMsvEntry entry2;
entry2.iType = KUidMsvMessageEntry;
entry2.iMtm = KUidMsvLocalServiceMtm;
entry2.iServiceId = KMsvLocalServiceIndexEntryId;
entry2.SetSendingState(3);
cEntry->CreateL(entry2);
selection->AppendL(entry2.Id());
session->ChangeAttributesL(*selection, 6<<KMsvSendingStateShift, 0);
cEntry->SetEntryL(entry1.Id());
test(cEntry->Entry().SendingState() == 6);
cEntry->SetEntryL(entry2.Id());
test(cEntry->Entry().SendingState() == 6);
CleanupStack::PopAndDestroy(4); // selection, cEntry, session, ob
}
/**
Delete Existing Service
@param aSession Current Session reference
@internalTechnology
*/
void CentralRepoUtils::DeleteServiceL(CMsvSession* aSession)
{
TMsvId serviceId;
TRAPD(err,TSmsUtilities::ServiceIdL(*aSession,serviceId));
if(err !=KErrNotFound)
{
CMsvEntry* entry = CMsvEntry::NewL(*aSession,serviceId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(serviceId);
entry->SetEntryL(entry->Entry().Parent());
entry->DeleteL(serviceId);
CleanupStack::PopAndDestroy(entry);
}
}
void CMsvTestUtils::ShowChildrenL(const CMsvEntry& aEntry, TInt aStart, TInt& aMore, TInt aMaxCount)
{
iRTest.Printf(_L("Parent: "));
DisplayChildL(aEntry.Entry());
iRTest.Printf(KMsvTestUtilsNewLine);
iRTest.Printf(KMsvTestUtilsNewLine);
if (!aEntry.Entry().Owner())
return;
TInt count = aEntry.Count() - aStart;
if (aMaxCount > 0)
count = Min(count, aMaxCount);
for (TInt i = aStart; i < count + aStart; i++)
{
TBuf<16> prefix;
prefix.Zero();
prefix.AppendNum(i - aStart);
prefix.Append(_L(". ("));
prefix.AppendFormat(_L("%2d"), i + 1),
prefix.Append(_L("/"));
prefix.AppendFormat(_L("%2d"), aEntry.Count()),
prefix.Append(_L(")"));
iRTest.Printf(prefix);
DisplayChildL(aEntry[i]);
iRTest.Printf(KMsvTestUtilsNewLine);
}
aMore = aEntry.Count() - aStart - aMaxCount;
if (aMore > 0)
iRTest.Printf(_L("...%d more...\n"), aMore);
}
TVerdict CTestUTCSort::TestSortingL()
{
TVerdict result=EPass;
//create ordering objects
TMsvSelectionOrdering ordering;
ordering.SetSorting(EMsvSortByDate);
//sort the gloabl inbox by date
CMsvEntry* inboxEntry = CMsvEntry::NewL(*iSession, KMsvDraftEntryIdValue,ordering);
CleanupStack::PushL(inboxEntry);
//retrieve the children of the inbox
CMsvEntrySelection* msvEntrySelection;
msvEntrySelection=inboxEntry->ChildrenL();
CleanupStack::PushL(msvEntrySelection);
CMsvEntry* child;
TMsvEntry childDetails;
TBuf<45> dateTimeString;
//look at the id of each child and test its id, these should
//be in the order the entries were created.
for(TInt i=0;i<KNumEmailMessages;++i)
{
child=iSession->GetEntryL((*msvEntrySelection)[i]);
childDetails=child->Entry();
delete child;
//print the time of the entry to the log file
dateTimeString.Zero();
FormatDateTime(dateTimeString,childDetails.iDate);
INFO_PRINTF2(_L("%S"),&dateTimeString);
if(childDetails.Id()!=iTMsvIdList->At(i))
{
ERR_PRINTF1(_L("Entries in wrong order"));
result=EFail;
break;
}
}
CleanupStack::PopAndDestroy(msvEntrySelection);
CleanupStack::PopAndDestroy(inboxEntry);
return result;
}
void CSmsFile::handle_deleted(const TMsvId& entry_id, const TMsvId& parent_id)
{
CMsvEntry* realentry;
TRAPD(err, realentry = iReceiveSession->GetEntryL(entry_id));
if (err!=KErrNone)
{
return;
}
if (realentry->Entry().iMtm != KUidMsgTypeSMS) {
return;
}
//CSmsClientMtm* smsMtm = STATIC_CAST(CSmsClientMtm*, iReceiveMtm);
}
void CMsvSendExe::AddTaskL(const TMsvSchedulePackage& aPackage)
{
CMsvEntry* cEntry = NULL;
TRAPD(err, cEntry = iSession->GetEntryL(aPackage.iId));
if (err != KErrNotFound)
{
User::LeaveIfError(err);
CleanupStack::PushL(cEntry);
TMsvEntry entry = cEntry->Entry();
const TInt sendState = entry.SendingState();
//Only send the message if sending state is Scheduled or Resend.
if (entry.Scheduled() && (sendState == KMsvSendStateScheduled || sendState == KMsvSendStateResend))
{
entry.SetSendingState(KMsvSendStateWaiting);
// Fix for DEF000924: Need to be able to send/cancel an sms while another is being sent
if (entry.iServiceId == KMsvLocalServiceIndexEntryId && entry.iRelatedId != KMsvNullIndexEntryId)
{
SCHSENDLOG( FLog(iFileName, _L("Changing service from %x to %x"), entry.iServiceId, entry.iRelatedId));
entry.iServiceId = entry.iRelatedId;
}
else
{
SCHSENDLOG( FLog(iFileName, _L("Not changing service from %x (related=%x)"), entry.iServiceId, entry.iRelatedId));
}
// End of fix
cEntry->ChangeL(entry);
AddTaskL(aPackage, entry.iMtm);
SCHSENDLOG(FLog(iFileName, _L("\t\tMsg=%d [Mtm=%d SendState=%d]"), aPackage.iId, entry.iMtm.iUid, entry.SendingState()));
}
else
{
SCHSENDLOG(FLog(iFileName, _L("\t\tIGNORING Msg=%d (Mtm=%d SendState=%d Scheduled=%d)"), aPackage.iId, entry.iMtm.iUid, sendState, entry.Scheduled()));
}
CleanupStack::PopAndDestroy(cEntry);
}
else
{
SCHSENDLOG(FLog(iFileName, _L("\t\tIGNORING Msg=%d: NOT FOUND"), aPackage.iId));
}
}
void CMtfTestActionCopyEntry::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCopyEntry);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId paramEntryId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TMsvId paramTargetId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2));
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramEntryId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramEntryId);
entry->SetEntryL(entry->Entry().Parent());
iOperation = entry->CopyL(paramEntryId,paramTargetId,iStatus);
CleanupStack::PopAndDestroy(entry);
CActiveScheduler::Add(this);
SetActive();
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCopyEntry);
}
void CMtfTestActionDeletePop3Service::ExecuteActionL()
{
TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionDeletePop3Service);
CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0));
TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
CMsvEntry* entry = CMsvEntry::NewL(*paramSession,paramServiceId,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
entry->SetEntryL(paramServiceId);
entry->SetEntryL(entry->Entry().Parent());
entry->DeleteL(paramServiceId);
CleanupStack::PopAndDestroy(entry);
DeleteParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1));
TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionDeletePop3Service);
TestCase().ActionCompletedL(*this);
}
void CMsvSendExe::FailOnError(const CMsvEntrySelection& aSelection, TInt aError)
{
if (iSession == NULL)
return;
TInt selCount = aSelection.Count();
TInt err = KErrNone;
CMsvEntry* cEntry = NULL;
while (selCount--)
{
const TMsvId id = aSelection[selCount];
TRAP(err, cEntry = iSession->GetEntryL(id));
//no need for the cleanup stack
if (err == KErrNone)
{
TMsvEntry entry(cEntry->Entry());
switch (entry.SendingState())
{
case KMsvSendStateWaiting:
case KMsvSendStateScheduled:
case KMsvSendStateResend:
if (entry.iDate < iCreated)
{
//Message has not been rescheduled
entry.SetSendingState(KMsvSendStateFailed);
entry.SetScheduled(EFalse);
entry.SetFailed(ETrue);
entry.iError = aError;
TRAP(err, cEntry->ChangeL(entry)); //ignore error
}
break;
default:
break;
}
delete cEntry;
cEntry = NULL;
} //end if
} //end while
}
/*
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
*/
void CFakeSMSSender::FinalizeMessageL(TMsvId aEntryId,const TDesC& aBody,const TDesC& aRecipientName,TTime aMsgTime)
{
CMsvEntry* entry = iMsvSession->GetEntryL(aEntryId);
CleanupStack::PushL(entry);
TMsvEntry newEntry(entry->Entry()); // This represents an entry in the Message Server index
newEntry.SetInPreparation(EFalse); // a flag that this message is in preparation
newEntry.iDetails.Set(aRecipientName);
newEntry.SetUnread(ETrue);
newEntry.iDate = aMsgTime;
newEntry.SetReadOnly(ETrue);
CMsvStore* srore = entry->EditStoreL();
CleanupStack::PushL(srore);
if(srore)
{
CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL();
CleanupStack::PushL(paraFormatLayer);
CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL();
CleanupStack::PushL(charFormatLayer);
CRichText* messageBodyContent = CRichText::NewL(paraFormatLayer, charFormatLayer);
CleanupStack::PushL(messageBodyContent);
messageBodyContent->InsertL(0,aBody);
srore->StoreBodyTextL(*messageBodyContent);
srore->CommitL();
CleanupStack::PopAndDestroy(3); // messageBodyContent, charFormatLayer,paraFormatLayer
if(aBody.Length() > 50)
newEntry.iDescription.Set(aBody.Left(50));
else
newEntry.iDescription.Set(aBody);
}
CleanupStack::PopAndDestroy(srore);
entry->ChangeL(newEntry);
entry->MoveL(aEntryId,KMsvGlobalInBoxIndexEntryId);
CleanupStack::PopAndDestroy(entry);
}
void CScheduleTestActive::RunL()
{
iTest.Printf(_L("CScheduleTestActive::RunL() iStatus %d\n"), iStatus.Int());
User::LeaveIfError(iStatus.Int());
if(iStopAtRunL)
{
CActiveScheduler::Stop();
return;
}
switch (iCommand)
{
case EScheduleAllL:
case EReScheduleAllL:
{
TInt count = iSelection->Count();
TBool stopped = EFalse;
while (!stopped && count--)
{
CMsvEntry* entry = iSession.GetEntryL(iSelection->At(count));
CleanupStack::PushL(entry);
const TInt state = entry->Entry().SendingState();
switch(state)
{
case KMsvSendStateScheduled:
case KMsvSendStateResend:
break;
default: // The message sent or failed
stopped = ETrue;
CActiveScheduler::Stop();
break;
}
CleanupStack::PopAndDestroy(entry);
}
break;
}
default:
CActiveScheduler::Stop(); //Added by AA 9/6/2000. Is this correct?
break;
}
}
// Get the TMsvEntry of the message whose TMsvId is passed from the client..
void CDummyServerSession::GetTMsvEntryL(const RMessage2& aMessage)
{
CDummyObserver* ob = new(ELeave) CDummyObserver;
CleanupStack::PushL(ob);
TPckgBuf<TMsvId> idBuf;
idBuf = aMessage.Int0();
CMsvSession* session = CMsvSession::OpenSyncL(*ob);
CleanupStack::PushL(session);
TMsvId entryId = idBuf();
CMsvEntry* cEntry = session->GetEntryL(entryId);
CleanupStack::PushL(cEntry);
TPckgBuf<TMsvEntry> pckg = cEntry->Entry();
aMessage.WriteL(1,pckg);
CleanupStack::PopAndDestroy(3,ob);//cEntry,session,ob
}
void CTestUTCParse::TraverseL(const TMsvId aTMsvId)
{
//open the entry, dont sort
TMsvSelectionOrdering ordering;
ordering.SetSorting(EMsvSortByNone);
CMsvEntry* entry = CMsvEntry::NewL(*iSession, aTMsvId,ordering);
CleanupStack::PushL(entry);
//retrieve the entries children
CMsvEntrySelection* msvEntrySelection;
msvEntrySelection=entry->ChildrenL();
CleanupStack::PushL(msvEntrySelection);
TInt count = entry->Count();
CMsvEntry* child;
TMsvEntry childDetails;
//for each child test if its a message entry
for(TInt i=0;i<count;i++)
{
child=iSession->GetEntryL((*msvEntrySelection)[i]);
childDetails=child->Entry();
if(childDetails.iType==KUidMsvMessageEntry)
{
iMessageEntryCount++;
iTimeList->AppendL(childDetails.iDate);
PrintEntryTime(&childDetails.iDate);
}
//recursive call
TraverseL(childDetails.Id());
if(child)
{
delete child;
}
}
CleanupStack::PopAndDestroy(msvEntrySelection);
CleanupStack::PopAndDestroy(entry);
}
// -----------------------------------------------------------------------------
// CMmsAdapterMsvApi::DeleteUserFolderL
// -----------------------------------------------------------------------------
//
TInt CMmsAdapterMsvApi::DeleteUserFolderL( TMsvId aUid )
{
TRACE_FUNC_ENTRY;
CMsvEntry* entry = iSession.GetEntryL(aUid);
CleanupStack::PushL(entry);
TMsvEntry tEntry = entry->Entry();
TMsvId parent = tEntry.Parent();
if ( tEntry.iType != KUidMsvFolderEntry || parent != KMsvMyFoldersEntryIdValue )
{
LOGGER_WRITE( "Not correct folder" );
CleanupStack::PopAndDestroy(entry);
LOGGER_LEAVEFN( "MsvApi::DeleteUserFolderL" );
return KErrNotSupported;
}
CMsvEntrySelection* children = entry->ChildrenL();
TInt count = children->Count();
delete children;
if ( count > 0 )
{
LOGGER_WRITE( "Folder not empty" );
CleanupStack::PopAndDestroy( entry );
LOGGER_LEAVEFN( "MsvApi::DeleteUserFolderL" );
return KErrInUse;
}
tEntry.SetReadOnly( EFalse );
entry->ChangeL( tEntry );
entry->SetEntryL( parent );
entry->DeleteL( aUid );
CleanupStack::PopAndDestroy( entry );
TRACE_FUNC_EXIT;
return KErrNone;
}
void CMsvSendExe::DoResheduleOnErrorL(RScheduler& aScheduler, const CMsvEntrySelection& aSelection, const TMsvSchedulePackage& aPackage, TInt aError, TSchedulerItemRef& aRef, TInt& aCount, TTime& aStartTime)
{
SCHSENDLOG(FLog(iFileName, _L("\tDoRescheduleOnError [aError=%d]"), aError));
CMsvScheduleSettings* settings = CMsvScheduleSettings::NewL();
CleanupStack::PushL(settings);
TMsvSchedulePackage package(aPackage);
TInt selCount = aSelection.Count();
TTaskInfo info;
TInt err = KErrNone;
//Schedule each message
while (selCount--)
{
const TMsvId id = aSelection[selCount];
TBool scheduleMessage = ETrue;
CMsvEntry* cEntry = NULL;
TMsvEntry entry;
if (iSession != NULL)
TRAP(err, cEntry = iSession->GetEntryL(id));
SCHSENDLOG(FLog(iFileName, _L("\t\tScheduling Task [Id=%d Err=%d iSession=0x%X cEntry=0x%X]..."), id, err, iSession, cEntry));
if (cEntry != NULL)
{
CleanupStack::PushL(cEntry);
entry = cEntry->Entry();
switch (entry.SendingState())
{
case KMsvSendStateWaiting:
case KMsvSendStateScheduled:
case KMsvSendStateResend:
scheduleMessage = ETrue;
break;
case KMsvSendStateFailed:
case KMsvSendStateSent:
case KMsvSendStateSuspended:
default:
scheduleMessage = EFalse;
SCHSENDLOG(FLog(iFileName, _L("\t\tNot Scheduled Task [Id=%d State=%d Err=%d]"), id, entry.SendingState(), entry.iError));
break;
}
} //end if
if (scheduleMessage)
{
if (aRef.iHandle == KErrNotFound)
{
//Find or create the schedule
if (cEntry != NULL)
{
TRAP(err, RestoreScheduleSettingsL(entry.iServiceId, entry.iMtm, *settings)); //use default if err != KErrNone
SCHSENDLOG(FLog(iFileName, _L("\t\tRestoreScheduleSettings [Err=%d]"), err));
}
CMsvScheduleSend::ConnectAndRegisterL(aScheduler, *settings);
if (FindorCreateScheduleL(aScheduler, aStartTime, *settings, aRef))
aCount++;
User::LeaveIfError(aScheduler.DisableSchedule(aRef.iHandle));
}
//Schedule the message
package.iId = id;
CMsvScheduleSend::ScheduleEntryL(aScheduler, aRef, package, info);
SCHSENDLOG(FLog(iFileName, _L("\t\tScheduleEntryL [Id=%d Task=%d]"), id, info.iTaskId));
if (cEntry != NULL)
{
//Update the message
entry.iError = aError;
TRAP(err, UpdateEntryL(*cEntry, entry, aRef, info, aStartTime));
SCHSENDLOG(FLog(iFileName, _L("\t\tEntry updated [Err=%d]"), err));
}
aCount++;
SCHSENDLOG(FLog(iFileName, _L("\t\tScheduled Task Complete [Id=%d Task=%d]"), id, info.iTaskId));
}
if (cEntry)
CleanupStack::PopAndDestroy(cEntry);
} //end while
CleanupStack::PopAndDestroy(settings);
}
// ----------------------------------------------------------------------------
// CIpsPlgNewChildPartFromFileOperation::PrepareStoreL
// ----------------------------------------------------------------------------
//
void CIpsPlgNewChildPartFromFileOperation::PrepareStoreL()
{
CMsvEntry* cAtta = iMsvSession.GetEntryL( iNewAttachmentId );
CleanupStack::PushL( cAtta );
TBool parentToMultipartAlternative( EFalse );
if( cAtta->HasStoreL() )
{
CMsvStore* store = cAtta->EditStoreL();
CleanupStack::PushL( store );
CImMimeHeader* mimeHeader = CImMimeHeader::NewLC();
if( store->IsPresentL( KUidMsgFileMimeHeader ) )
{
mimeHeader->RestoreL( *store );
CDesC8Array& array = mimeHeader->ContentTypeParams();
array.AppendL( KMethod );
parentToMultipartAlternative = ETrue;
if( iContentType->Des().Find( KMimeTextCalRequest ) != KErrNotFound )
{
array.AppendL( KRequest );
}
else if( iContentType->Des().Find( KMimeTextCalResponse ) != KErrNotFound )
{
array.AppendL( KResponse );
}
else if( iContentType->Des().Find( KMimeTextCalCancel ) != KErrNotFound )
{
array.AppendL( KCancel );
}
else
{
parentToMultipartAlternative = EFalse;
}
mimeHeader->StoreWithoutCommitL( *store );
store->CommitL();
}
CleanupStack::PopAndDestroy( 2, store );
}
if( parentToMultipartAlternative &&
iFilePath->Find( KFileExtensionICS ) != KErrNotFound )
{
TMsvEntry tAttaEntry = cAtta->Entry();
TMsvId id = tAttaEntry.Parent();
CMsvEntry* cParent = iMsvSession.GetEntryL( id );
CleanupStack::PushL( cParent );
TMsvEmailEntry tEntry = cParent->Entry();
tEntry.SetMessageFolderType( EFolderTypeAlternative );
// Do async again if needed
iOperation = cParent->ChangeL( tEntry, iStatus );
CleanupStack::PopAndDestroy( cParent );
CleanupStack::PopAndDestroy( cAtta );
}
else
{
CleanupStack::PopAndDestroy( cAtta );
iStatus = KRequestPending;
TRequestStatus* status = &iStatus;
User::RequestComplete(status,KErrNone);
}
iStep = EStoreMessagePart; // Next step
SetActive();
}
/*
-----------------------------------------------------------------------------
----------------------------------------------------------------------------
*/
void CMailBoxContainer::ReadMailFolderL(TMsvId aSelected)
{
iCurrentMailBox = aSelected;
delete iIDArray;
iIDArray = NULL;
if(iSession && iSelectionBox)
{
TInt OrgCount = iSelectionBox->Model()->ItemTextArray()->MdcaCount();
STATIC_CAST(CDesCArray*,iSelectionBox->Model()->ItemTextArray())->Reset();
RPointerArray<CFFileTypeItem> ItemTypeArray = iUtils.GetFileUtils().GetItemTypeArray();
iIDArray = new(ELeave)CArrayFixFlat<TMyMailEntry>(10);
TMsvSelectionOrdering sort;
sort.SetShowInvisibleEntries(ETrue);
sort.SetSorting(EMsvSortByDate);
// Take a handle to the folder entry
CMsvEntry* parentEntry = CMsvEntry::NewL(*iSession,aSelected,sort);
CleanupStack::PushL(parentEntry);
// A selection of all BT entries
CMsvEntrySelection* entries = parentEntry->ChildrenL();//ChildrenWithMtmL(KUidMsgTypeBt);
CleanupStack::PushL(entries);
//Process all entries
for(TInt ii = 0; ii < entries->Count(); ii++)
{
//Get entry
CMsvEntry* btEntry = iSession->GetEntryL((*entries)[ii]);
CleanupStack::PushL(btEntry);
//Then get entrys child
CMsvEntrySelection* btChildren = btEntry->ChildrenL();
CleanupStack::PushL(btChildren);
TInt childc = btChildren->Count();
if (childc>0)
{
for(TInt i=0; i<childc; i++)
{
TMsvId btAtt = (*btChildren)[i];
btEntry->SetEntryL(btAtt);
if(btEntry->Entry().iMtm == KUidMsgTypePOP3)
{
CImEmailMessage* emailMessage = CImEmailMessage::NewL(*btEntry);
CleanupStack::PushL(emailMessage);
MMsvAttachmentManager& attMngr = emailMessage->AttachmentManager();
GetAttachmentsL(attMngr,*btEntry,(*entries)[ii],btAtt);
CleanupStack::PopAndDestroy(emailMessage);
}
else if (btEntry->HasStoreL())
{
CMsvStore* store = btEntry->ReadStoreL();
CleanupStack::PushL(store);
MMsvAttachmentManager& attMngr = store->AttachmentManagerL();
GetAttachmentsL(attMngr,*btEntry,(*entries)[ii],btAtt);
CleanupStack::PopAndDestroy(store);
}
}
}
CleanupStack::PopAndDestroy(2);
}
CleanupStack::PopAndDestroy(2);
CDesCArray* itemArray = STATIC_CAST( CDesCArray* ,iSelectionBox->Model()->ItemTextArray());
if(itemArray->Count() > OrgCount)
{
iSelectionBox->HandleItemAdditionL();
iSelectionBox->SetCurrentItemIndex(0);
}
else
{
iSelectionBox->HandleItemRemovalL();
if(itemArray->Count())
{
iSelectionBox->SetCurrentItemIndex(0);
}
}
UpdateScrollBar(iSelectionBox);
DrawNow();
}