void CMsgImOutboxSend::CleanUpOnDestructL()
{
if(!iSetDisconnected)
{
DisconnectUnsentMessagesL();
}
if (iStatus.Int() != KErrNone)
{
if ((iCurrentMessageNo != -1) && (iCurrentMessageNo<iTotalMessages))
{
TInt err=iServerEntry.SetEntry(iEntrySelection.At(iCurrentMessageNo));
if(err == KErrNotFound)
{
User::Leave(KErrNotFound);
}
__ASSERT_DEBUG(err == KErrNone, gPanic(EImsmServerError));
TMsvEntry entry = iServerEntry.Entry();
RestoreBccRecipientsToHeaderL();
// Set date info and completion data..update the iServerEntry with this data..
TInt errorCode = (TSmtpSessionError)iStatus.Int();
entry.iDate.UniversalTime();
if(errorCode!=KErrCancel)
{
entry.SetFailed(errorCode != KErrNone);
entry.SetSendingState(errorCode==KErrNone? KMsvSendStateSent: KMsvSendStateWaiting); //set it to send agian.
if (errorCode)
entry.iError=CalculateError(errorCode);
}
else
{
entry.SetFailed(EFalse);
entry.SetSendingState(KMsvSendStateSuspended);
entry.iError=KErrNone;
}
entry.SetConnected(EFalse);
#ifdef _DEBUG
err =
#endif
iServerEntry.ChangeEntry(entry);
__ASSERT_DEBUG(err == KErrNone, gPanic(EImsmServerError));
}
}
}
void CSmsReplyToStep::CreateMessageL()
{
INFO_PRINTF1(_L("Creating message..."));
TMsvEntry entry;
entry.SetVisible(ETrue);
entry.SetInPreparation(ETrue);
entry.iServiceId = iTestUtils->iSmsServiceId;
entry.iType = KUidMsvMessageEntry;
entry.iMtm = KUidMsgTypeSMS;
entry.iDate.HomeTime();
entry.iSize = 0;
entry.iDescription.Set(KNullDesC);
entry.iDetails.Set(KNullDesC);
entry.SetSendingState(KMsvSendStateScheduled);
// Create the SMS header object...
CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *iTestUtils->iRichText);
CleanupStack::PushL(header);
// Set the body text...
iTestUtils->iRichText->Reset();
iTestUtils->iRichText->InsertL(0, KMessageData);
// Copy the message settings...
header->SetSmsSettingsL(*iTestUtils->iServiceSettings);
// Set the service centre
TInt defaultIndex = iTestUtils->iServiceSettings->DefaultServiceCenter();
header->SetServiceCenterAddressL(iTestUtils->iServiceSettings->GetServiceCenter(defaultIndex).Address());
// Set recipient - ask derived class
SetRecipientsL(*header);
// Update entry description and details...
CArrayPtrFlat<CSmsNumber>& recipient = header->Recipients();
entry.iDetails.Set(recipient[0]->Address());
entry.iDescription.Set(iTestUtils->iRichText->Read(0, iTestUtils->iServiceSettings->DescriptionLength()));
entry.SetInPreparation(EFalse);
// Create the entry - set context to the global outbox.
iTestUtils->iMsvEntry->SetEntryL(KMsvGlobalOutBoxIndexEntryId);
iTestUtils->iMsvEntry->CreateL(entry);
// Create new store and save header information
iTestUtils->iMsvEntry->SetEntryL(entry.Id());
CMsvStore* store = iTestUtils->iMsvEntry->EditStoreL();
CleanupStack::PushL(store);
header->StoreL(*store);
store->StoreBodyTextL(*iTestUtils->iRichText);
store->CommitL();
CleanupStack::PopAndDestroy(2, header);
iMessageId = entry.Id();
}
/**
Utility function that updates message index entry fields to reflect
the message's scheduling.
@param aRef
Scheduler item.
@param aInfo
Scheduler task information.
@param aTime
Schedule start time.
@param aFinalState
Sending state flag.
@param aEntry
On return, updated index entry.
@param aData
On return, populated messaging scheduling data.
*/
EXPORT_C void CMsvScheduleSend::UpdateEntryAfterSchedule(const TSchedulerItemRef& aRef, const TTaskInfo& aInfo, const TTime& aTime, TInt aFinalState, TMsvEntry& aEntry, TMsvEntryScheduleData& aData)
{
aEntry.SetScheduled(ETrue);
aEntry.SetFailed(EFalse);
aEntry.SetSendingState(aFinalState);
aEntry.SetConnected(EFalse);
aEntry.iDate = aTime;
aData.iRef = aRef;
aData.iTaskId = aInfo.iTaskId;
}
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 CBulkCommitServerMtm::CreateBulkEntries(TUint aEntryCount, TMsvId aServiceId)
{
TMsvEntry newEntry;
for (TInt i = 0; i < aEntryCount; ++i)
{
newEntry.iType = KUidMsvMessageEntry;
newEntry.iMtm = KUidBulkCommitTestMtm;
newEntry.iServiceId = aServiceId;
newEntry.SetVisible(ETrue);
newEntry.SetReadOnly(EFalse);
newEntry.SetUnread(ETrue);
newEntry.iDescription.Set(_L("Bulk Entry"));
newEntry.SetSendingState(KMsvSendStateNotApplicable);
iServerEntry->CreateEntryBulk(newEntry);
}
}
/*
Creates two folders and then creates bulk entries under each folder.
After bulk commit, creates an entry to let the client know about
bulk commit is done.
@param aEntryCount - Bulk entries to be created under each root entry
*/
void CBulkCommitServerMtm::CreateBulkEntryWithMultipleParentsL(TUint aEntryCount)
{
iServerEntry->SetEntry(iServiceId);
TMsvEntry folderEntry1, folderEntry2;
//create the first folder
folderEntry1.iType=KUidMsvFolderEntry;
folderEntry1.iMtm = KUidBulkCommitTestMtm;
folderEntry1.iServiceId = iServiceId;
iServerEntry->CreateEntry(folderEntry1);
//create the second folder entry
folderEntry2.iType=KUidMsvFolderEntry;
folderEntry2.iMtm = KUidBulkCommitTestMtm;
folderEntry2.iServiceId = iServiceId;
iServerEntry->CreateEntry(folderEntry2);
iServerEntry->SetEntry(folderEntry1.Id());
//Create a series of entries using the bulk API under the first folder
CreateBulkEntries(aEntryCount, folderEntry1.Id());
iServerEntry->SetEntry(folderEntry2.Id());
//Create a series of entries using the bulk API under the second folder
CreateBulkEntries(aEntryCount, folderEntry2.Id());
//commit the bulk entries
iServerEntry->CompleteBulk();
iServerEntry->SetEntry(iServiceId);
//Let the client know that the bulk commit is done
TMsvEntry childEntry;
childEntry.iType = KUidMsvMessageEntry;
childEntry.iMtm = KUidBulkCommitTestMtm;
childEntry.iServiceId = iServiceId;
childEntry.SetVisible(ETrue);
childEntry.SetReadOnly(EFalse);
childEntry.SetUnread(ETrue);
childEntry.iDescription.Set(_L("Bulk Commit Done"));
childEntry.SetSendingState(KMsvSendStateNotApplicable);
iServerEntry->CreateEntry(childEntry);
//Set entry to NULL entry to avoid locking
iServerEntry->SetEntry(KMsvNullIndexEntryId);
}
/*
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
*/
void CSMSSender::PopulateMessageL(TMsvEntry& aMsvEntry,TDes& aDescription,TDes& aDetails)
{
ASSERT(iMtm);
// We get the message body from Mtm and insert a bodytext
CRichText& mtmBody = iMtm->Body();
mtmBody.Reset();
mtmBody.InsertL(0, iMessage); // insert our msg tag as the body text
if(iDescription)
{
if(iDescription->Des().Length() > 30)
aDescription.Copy(iDescription->Des().Left(30));
else
aDescription.Copy(iDescription->Des());
}
else
{
if(iMessage.Length() > 30)
aDescription.Copy(iMessage.Left(30));
else
aDescription.Copy(iMessage);
}
if(iDetails)
{
if(iDetails->Des().Length() > 30)
aDetails.Copy(iDetails->Des().Left(30));
else
aDetails.Copy(iDetails->Des());
}
else
{
if(iRecipients.Length() > 30)
aDetails.Copy(iRecipients.Left(30));
else
aDetails.Copy(iRecipients);
}
aMsvEntry.SetInPreparation(EFalse);
aMsvEntry.SetScheduled(EFalse);
aMsvEntry.iDate.UniversalTime();
aMsvEntry.SetSendingState(KMsvSendStateWaiting);
}
void CPigeonServerMtm::SendScheduledL(CMsvEntrySelection& aSelection, const TBool /*aMove*/, const TDesC8& /*aParameter*/, TRequestStatus& /*aStatus*/)
{
TBool leave = EFalse;
for ( TInt i = 0; i < aSelection.Count(); ++i )
{
// Move message to the sent folder, and update sending state to Sent.
TInt err = iServerEntry->SetEntry(aSelection[i]);
TMsvEntry entry = iServerEntry->Entry();
// Check each message to see if it should be sent...
if( entry.iError == KPigeonErrFailFirstSend )
{
leave = ETrue;
}
else
{
entry.SetSendingState(KMsvSendStateSent);
entry.iDetails.Set(KSchSendTestDetails);
err = iServerEntry->ChangeEntry(entry);
TMsvId id = entry.Id();
err = iServerEntry->SetEntry(KMsvSentEntryId);
if(KErrNone == err)
{
err = iServerEntry->SetEntry(KMsvGlobalOutBoxIndexEntryId);
if(KErrNone == err)
{
// Move it...
err = iServerEntry->MoveEntryWithinService(id, KMsvSentEntryId);
}
}
}
}
iServerEntry->SetEntry(KMsvNullIndexEntryId);
if( leave )
User::Leave(KErrDisconnected);
}
void CSmsCancelTest::CancelIfSendingL(const CMsvEntrySelection& aSelection)
{
const TInt count = aSelection.Count();
for (TInt i = 0; i < count; i++)
{
TRAPD(err, iSmsTest.SetEntryL(aSelection[i]));
if (!err)
{
TMsvEntry entry = iSmsTest.Entry();
if (entry.SendingState() == KMsvSendStateSending)
{
if (iOperation)
{
iOperation->Cancel();
return;
}
else
{
entry.SetSendingState(KMsvSendStateSuspended);
TRAP(err, iSmsTest.ChangeEntryL(entry)); //ignore error
if (err)
{
iSmsTest.Printf(_L("Error Cancelling Entry %d: On ChangeEntryL()\n"), aSelection[i]);
} //end if
} //end if
} //end if
}
else
{
iSmsTest.Printf(_L("Error Cancelling Entry %d: On SetEntryL()\n"), aSelection[i]);
}
}
}
TVerdict CCreateSmsMessageTestStep::doTestStepL()
{
CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
CActiveScheduler::Install(scheduler);
CleanupStack::PushL(scheduler);
CSessionObserver* sessionObserver = new (ELeave) CSessionObserver;
CleanupStack::PushL(sessionObserver);
CMsvSession* session = CMsvSession::OpenSyncL(*sessionObserver);
CleanupStack::PushL(session);
_LIT(KFileName,"FileName");
TPtrC tag;
if ( !GetStringFromConfig(ConfigSection(),KFileName,tag))
{
ERR_PRINTF1(_L("No Input for FileName in CreateSmsMessage"));
User::Leave(KErrNotReady);
}
HBufC* fileName = tag.AllocLC();
// Create a Rich Text object
CPlainText::TTextOrganisation ttOrg = {CPlainText::EOrganiseByLine};
CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL();
CleanupStack::PushL(paraFormatLayer);
CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL();
CleanupStack::PushL(charFormatLayer);
CRichText* bodyRichText = CRichText::NewL(paraFormatLayer, charFormatLayer);
CleanupStack::PushL(bodyRichText);
// Store the file contents into the CRichText object
bodyRichText->ImportTextFileL(0, fileName->Des(), ttOrg);
// Create the SMS header object...
CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsSubmit, *bodyRichText);
CleanupStack::PushL(header);
// Set the body text...
CSmsSettings* smsSettings = CSmsSettings::NewL();
CleanupStack::PushL(smsSettings);
CSmsAccount* account = CSmsAccount::NewLC();
account->LoadSettingsL(*smsSettings);
// Copy the message settings...
header->SetSmsSettingsL(*smsSettings);
// Set the service centre
TInt defaultIndex = smsSettings->DefaultServiceCenter();
header->SetServiceCenterAddressL(smsSettings->GetServiceCenter(defaultIndex).Address());
// Set recipient - ask derived class
SetRecipientsL(*header);
CArrayPtrFlat<CSmsNumber>& recipient = header->Recipients();
INFO_PRINTF1(_L("Creating message..."));
TMsvEntry entry;
entry.SetVisible(ETrue);
entry.SetInPreparation(ETrue);
TMsvId srvcId=0;
TSmsUtilities::ServiceIdL(*session, srvcId);
entry.iServiceId = srvcId;
entry.iType = KUidMsvMessageEntry;
entry.iMtm = KUidMsgTypeSMS;
entry.iDate.UniversalTime();
entry.iSize = 0;
entry.iDescription.Set(KNullDesC);
entry.iDetails.Set(KNullDesC);
entry.SetSendingState(KMsvSendStateWaiting);
// Update entry description and details...
entry.iDetails.Set(recipient[0]->Address());
entry.iDescription.Set(recipient[0]->Address());
entry.SetInPreparation(EFalse);
//TPtrC tag;
_LIT(KParent,"Parent");
TPtrC parentTag;
if ( !GetStringFromConfig(ConfigSection(),KParent,parentTag))
{
ERR_PRINTF1(_L("No Input for Outbox"));
User::Leave(KErrNotReady);
}
// Create the entry - set context to the global outbox.
TMsvId paramParentId = MsgingUtils::GetLocalFolderId(parentTag);//KMsvGlobalOutBoxIndexEntryId;
CMsvEntry* newEntry = CMsvEntry::NewL(*session,paramParentId,TMsvSelectionOrdering());
CleanupStack::PushL(newEntry);
newEntry->SetEntryL(paramParentId);
newEntry->CreateL(entry);
// Create new store and save header information
newEntry->SetEntryL(entry.Id());
CMsvStore* store = newEntry->EditStoreL();
CleanupStack::PushL(store);
header->StoreL(*store);
store->StoreBodyTextL(*bodyRichText);
store->CommitL();
//store,newEntry,account, smsSettings, header, bodyRichText,charFormatLayer, paraFormatLayer,fileName
CleanupStack::PopAndDestroy(9,fileName);
CleanupStack::PopAndDestroy(3, scheduler);
SetTestStepResult(EPass);
return TestStepResult();
}
void CMsgImOutboxSend::SetLastMessageStatusL(const TTime& aTimeNow, TInt aCompletionReason)
{
// If its the first message && there are messages to be sent change status..
if (iTotalMessages>0)
{
iProgress.SetStatus(EMsgOutboxProgressSending);
}
// Store the file progress for the last file sent. This will be used in
// the situation where we cancel the operation to do a bearer migration
// so that the progress information is for the last file completed as
// opposed to the one we have just cancelled.
if (iSession)
{
iProgress.iSendFileProgress = iSession->FileProgress();
}
// Fill in the iServerEntry details with data from the last message
// IMCV may had left this inconsistent... so reset the iServerEntry
// explicitly....
if (iCurrentMessageNo != -1)
{
TInt err;
err = iServerEntry.SetEntry(iEntrySelection.At(iCurrentMessageNo));
__ASSERT_DEBUG( err == KErrNone, gPanic(EImsmServerError));
TMsvEntry entry = iServerEntry.Entry();
// Set date info and completion data..update the iServerEntry with this data..
entry.iDate=aTimeNow;
if(aCompletionReason!=KErrCancel)
{
entry.SetFailed(aCompletionReason != KErrNone);
entry.SetSendingState(aCompletionReason==KErrNone? KMsvSendStateSent: KMsvSendStateWaiting); //set it to send agian.
if (aCompletionReason)
entry.iError=CalculateError(aCompletionReason);
}
else
{
entry.SetFailed(EFalse);
entry.SetSendingState(KMsvSendStateSuspended);
entry.iError=KErrNone;
}
// if (aCompletionReason<=KErrNone)
// {
// ignore any +ve errors which may leak from the SMTP code
// entry.iError=aCompletionReason;
// entry.SetSendingState(aCompletionReason==KErrNone? KMsvSendStateSent: KMsvSendStateWaiting); //set it to send agian.
// }
RestoreBccRecipientsToHeaderL();
entry.SetConnected(EFalse);
err = iServerEntry.ChangeEntry(entry);
__ASSERT_DEBUG( err == KErrNone, gPanic(EImsmServerError));
UpdateSummaryInfo(aCompletionReason);
// If it went move to the "Sent" folder..
if(!entry.Failed() && aCompletionReason!=KErrCancel)
{
TMsvId id = entry.Id();
err = iServerEntry.SetEntry(KMsvSentEntryIdValue);
if(err == KErrNone)
{
err = iServerEntry.SetEntry(KMsvGlobalOutBoxIndexEntryId);
if(err == KErrNone)
{
// Move it....
err = iServerEntry.MoveEntryWithinService(id, KMsvSentEntryIdValue);
}
}
}
}
}
/**
Verifies that the schedule information stored in specified messages is the
same as that on the task scheduler.
@param aSelection
Array of message IDs that need to be checked against the task scheduler.
@panic ScheduleSend-DLL 0
The array of message IDs is empty.
Debug build only.
*/
EXPORT_C void CMsvScheduleSend::CheckScheduleL(const CMsvEntrySelection& aSelection)
{
__ASSERT_DEBUG(aSelection.Count(), gPanic(EMessageSelectionEmpty));
GetMessagesL(aSelection); //Leaves with KErrNotFound if there are no messages returned in iSchEntries
TInt entryCount = iSchEntries->Count();
SCHSENDLOG(FLog(_L8("Asked to check schedule for %d msgs"), entryCount));
ConnectAndRegisterL();
while (entryCount--)
{
TBool found = EFalse;
TTsTime schTime;
CMsvScheduledEntry& sEntry = *iSchEntries->At(entryCount);
if (!sEntry.iData.IsReset())
{
TSchedulerItemRef ref;
TInt size = 0;
TTaskInfo info;
TInt err = iScheduler.GetTaskDataSize(sEntry.iData.iTaskId, size);
if (!err)
{
HBufC* buf = HBufC::NewLC(size);
TPtr ptr = buf->Des();
User::LeaveIfError(iScheduler.GetTaskInfoL(sEntry.iData.iTaskId, info, ptr, ref, schTime));
CleanupStack::PopAndDestroy(buf);
found = ETrue;
}
else if (err != KErrNotFound)
{
User::Leave(err);
}
}
if (iServerEntry.SetEntry(sEntry.Id()) == KErrNone)
{
TMsvEntry entry = iServerEntry.Entry();
TInt sendingState = entry.SendingState();
if (sendingState == KMsvSendStateScheduled || sendingState == KMsvSendStateResend || entry.Scheduled())
{
if (found)
{
entry.SetScheduled(ETrue);
entry.iDate = schTime.GetUtcTime();
User::LeaveIfError(iServerEntry.ChangeEntry(entry));
}
else
{
entry.SetScheduled(EFalse);
entry.SetSendingState(KMsvSendStateUnknown);
entry.iDate.UniversalTime();
User::LeaveIfError(iServerEntry.ChangeEntry(entry));
SendingCompleteL(sEntry, EFalse);
}
}
}
}
}
void CSmsFile::send_messageL(const TDesC& recipient, const TDesC& body)
{
if (iStatus==KRequestPending) {
User::Leave(KErrServerBusy);
}
state=_L("send_messageL");
TMsvEntry newEntry; // This represents an entry in the Message Server index
newEntry.iMtm = KUidMsgTypeSMS; // message type is CSmsFile
newEntry.iType = KUidMsvMessageEntry; // this defines the type of the entry: message
newEntry.iServiceId = KMsvLocalServiceIndexEntryId; // ID of local service (containing the standard folders)
newEntry.iDate.HomeTime(); // set the date of the entry to home time
newEntry.SetInPreparation(ETrue); // a flag that this message is in preparation
// get ref to outbox
state=_L("NewL");
CMsvEntry *entry =CMsvEntry::NewL(*iSession, KMsvGlobalOutBoxIndexEntryId ,TMsvSelectionOrdering());
CleanupStack::PushL(entry);
// create message in outbox
state=_L("CreateL");
entry->CreateL(newEntry);
state=_L("GetEntry");
entry = iSession->GetEntryL(newEntry.Id());
// SetCurrentEntryL takes ownership of the CMsvEntry
state=_L("SetCurrentEntry");
iMtm->SetCurrentEntryL(entry);
CleanupStack::Pop(); // entry
state=_L("Entry()");
TMsvEntry msvEntry = (iMtm->Entry()).Entry();
state=_L("Body()");
CRichText& mtmBody = iMtm->Body();
mtmBody.Reset();
state=_L("set message");
mtmBody.InsertL(0, body); // insert our msg tag as the body text
// set iRecipient into the Details of the entry
msvEntry.iDetails.Set(recipient); // set recipient info in details
msvEntry.SetInPreparation(EFalse); // set inPreparation to false
msvEntry.SetSendingState(KMsvSendStateWaiting); // set the sending state (immediately)
msvEntry.iDate.HomeTime(); // set time to Home Time
// To handle the CSmsFile specifics we start using SmsMtm
CSmsClientMtm* smsMtm = STATIC_CAST(CSmsClientMtm*, iMtm);
state=_L("RestoreServiceAndSettingsL");
smsMtm->RestoreServiceAndSettingsL();
state=_L("set header");
// CSmsHeader encapsulates data specific for CSmsFile messages,
// like service center number and options for sending.
CSmsHeader& header = smsMtm->SmsHeader();
state=_L("get options");
if (!sendOptions) {
sendOptions = CSmsSettings::NewL();
sendOptions->CopyL(smsMtm->ServiceSettings()); // restore existing settings
state=_L("SetDelivery");
sendOptions->SetDelivery(ESmsDeliveryImmediately); // set to be delivered immediately
}
// set send options
// ERROR HERE!
state=_L("SetSmsSettingsL");
header.SetSmsSettingsL(*sendOptions);
state=_L("check sc");
// let's check if there's sc address
if (header.Message().ServiceCenterAddress().Length() == 0)
{
// no, there isn't. We assume there is at least one sc number set and use
// the default SC number.
CSmsSettings* serviceSettings = &(smsMtm->ServiceSettings());
// if number of scaddresses in the list is null
if (!serviceSettings->NumSCAddresses())
{
// FIXME: what to do?
User::Leave(1);
} else {
// set sc address to default.
CSmsNumber* sc = 0;
sc = &(serviceSettings->SCAddress(serviceSettings->DefaultSC()));
header.Message().SetServiceCenterAddressL(sc->Address());
}
}
state=_L("add addresses");
// Add our recipient to the list, takes in two TDesCs, first is real address and second is an alias
// works also without the alias parameter.
smsMtm->AddAddresseeL(recipient, msvEntry.iDetails);
// if message is to be deleted after sending, mark with our UID
msvEntry.iMtmData3 = KUidRippleVaultApp.iUid;
state=_L("save");
// save message
iMtm->Entry().ChangeL(msvEntry); // make sure that we are handling the right entry
smsMtm->SaveMessageL(); // closes the message
state=_L("move");
// This moves the message entry to outbox, we'll schedule it for sending after this.
// TMsvId movedId = MoveMessageEntryL( KMsvGlobalOutBoxIndexEntryId ); // move message to outbox
TMsvId movedId = iMtm->Entry().Entry().Id();
// We must create an entry selection for message copies (although now we only have one message in selection)
CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
CleanupStack::PushL(selection);
selection->AppendL(movedId); // add our message to the selection
TBuf8<1> dummyParams;
// CCommandAbsorbingControl::NewLC();
state=_L("InvokeAsyncFunctionL");
// invoking async schedule copy command on our mtm
op=iMtm->InvokeAsyncFunctionL(
ESmsMtmCommandScheduleCopy,
*selection,
dummyParams,
iStatus);
CleanupStack::Pop(); // selection
#ifdef __LOGME__
iAppUi.LogText.Copy(_L("SENT\n"));
iAppUi.WriteLogFile(iAppUi.LogText);
#endif
SetActive();
//return KErrNone;
}
