void CMtfTestActionCompareAttachment::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionCompareAttachment); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); HBufC* dataFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(3)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->ReadStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& manager = store->AttachmentManagerL(); RFile fileAttachment = manager.GetAttachmentFileL(attachId); CleanupClosePushL(fileAttachment); CompareFileL(fileAttachment, *dataFilePath); CleanupStack::PopAndDestroy(&fileAttachment); CleanupStack::PopAndDestroy(2, entry); // store, entry TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionCompareAttachment); TestCase().ActionCompletedL(*this); }
void CMtfTestActionSmtpGetAttachmentFileFromId::RunTestActionL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); HBufC* dataFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(3), NULL); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CImEmailMessage* emailMsg = CImEmailMessage::NewL(*entry); CleanupStack::PushL(emailMsg); MMsvAttachmentManager& manager = emailMsg->AttachmentManager(); RFile fileAttachment = manager.GetAttachmentFileL(attachId); CleanupClosePushL(fileAttachment); if( dataFilePath != NULL ) { // check of contents of attachment file is requested CompareFileL(fileAttachment, *dataFilePath); } CleanupStack::PopAndDestroy(3, entry); // fileAttachment, emailMsg, entry }
void CMtfTestActionAddFileAttachmentByHandle::RunTestL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); HBufC* paramFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(2)); HBufC8* paramMimeType = ObtainParameterReferenceL<HBufC8>(TestCase(),ActionParameters().Parameter(3)); iEntry = paramSession->GetEntryL(messageEntry); iStore = iEntry->EditStoreL(); iAttachment = CMsvAttachment::NewL(CMsvAttachment::EMsvFile); iAttachment->SetMimeTypeL(*paramMimeType); RFile fileHandle = OpenFileL(paramSession->FileSession(), *paramFilePath); CleanupClosePushL(fileHandle); TFileName fileName; User::LeaveIfError(fileHandle.Name(fileName)); iAttachment->SetAttachmentNameL(fileName); TInt fileSize = 0; User::LeaveIfError(fileHandle.Size(fileSize)); iAttachment->SetSize(fileSize); MMsvAttachmentManager& manager = iStore->AttachmentManagerL(); CActiveScheduler::Add(this); SetActive(); manager.AddAttachmentL(fileHandle, iAttachment, iStatus); iAttachmentId = iAttachment->Id(); iAttachment = NULL; // ownership passed to manager CleanupStack::Pop(&fileHandle); }
void CMtfTestActionGetAttachmentFileFromIndex::RunTestActionL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TInt attachIndex = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(2)); HBufC* dataFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(3), NULL); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->ReadStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& manager = store->AttachmentManagerL(); RFile fileAttachment = manager.GetAttachmentFileL(attachIndex); CleanupClosePushL(fileAttachment); if( dataFilePath != NULL ) { // check of contents of attachment file is requested CompareFileL(fileAttachment, *dataFilePath); } CleanupStack::PopAndDestroy(3, entry); // fileAttachment, store, entry }
// methods from CSendAsEditUtils void CSendAsTestEditUtils::LaunchEditorL(TMsvId /*aId*/, TRequestStatus& aStatus) { CDummyObserver* ob1 = new(ELeave) CDummyObserver; CleanupStack::PushL(ob1); CMsvSession* session = CMsvSession::OpenSyncL(*ob1); CleanupStack::PushL(session); CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone,ETrue)); CleanupStack::PushL(cEntry); CMsvEntrySelection* selection = cEntry->ChildrenL(); CleanupStack::PushL(selection); CMsvEntry* cEntry2 = session->GetEntryL(selection->At(0)); CleanupStack::PushL(cEntry2); TMsvEntry entry = cEntry2->Entry(); entry.SetMtmData3(234567890); // Show we've been called by touching the TMsvEntry. cEntry2->ChangeL(entry); CleanupStack::PopAndDestroy(5, ob1); // cEntry2, selection, cEntry, session, ob1 iUserStatus = &aStatus; aStatus = KRequestPending; // wait a few seconds before completing iEditTimer->After(KSendAsTestEditWaitTime); }
void CMtfTestActionSmtpRemoveEntryAttachmentById::RunTestL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CImEmailMessage* emailMsg = CImEmailMessage::NewL(*entry); CleanupStack::PushL(emailMsg); MMsvAttachmentManager& manager = emailMsg->AttachmentManager(); CMsvAttachment* attachInfo = manager.GetAttachmentInfoL(attachId); CleanupStack::PushL(attachInfo); // First ensure that the attachment is a file attachment if( attachInfo->Type() != CMsvAttachment::EMsvMessageEntry ) { User::Leave(KErrGeneral); } // Get the linked file TMsvId msgId = attachInfo->EntryAttachmentId(); CleanupStack::PopAndDestroy(attachInfo); // Remove the attachment CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); manager.RemoveAttachmentL(attachId, waiter->iStatus); waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); CleanupStack::PopAndDestroy(2, entry); // email msg, entry // Ensure that the message entry still exists CMsvEntry* checkEntry = paramSession->GetEntryL(msgId); delete checkEntry; checkEntry = NULL; }
void CMtfTestActionSmtpModifyAttachmentInfo::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionSmtpModifyAttachmentInfo); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachmentId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CImEmailMessage* emailMsg = CImEmailMessage::NewL(*entry); CleanupStack::PushL(emailMsg); MMsvAttachmentManager& manager = emailMsg->AttachmentManager(); CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL(); CleanupStack::PushL(mimeHeaders); mimeHeaders->SetContentDescriptionL(KTxtContentDescription()); mimeHeaders->SetContentBaseL(KTxtContentBase()); mimeHeaders->SetContentLocationL(KTxtContentLocation()); mimeHeaders->SetContentIdL(KTxtContentId()); mimeHeaders->SetContentTypeL(KTxtContentType()); mimeHeaders->SetContentSubTypeL(KTxtContentSubType()); mimeHeaders->SetContentDispositionL(KTxtContentDisposition()); mimeHeaders->ContentTypeParams().AppendL(KTxtParam1()); mimeHeaders->ContentTypeParams().AppendL(KTxtParam2()); mimeHeaders->ContentTypeParams().AppendL(KTxtParam3()); mimeHeaders->ContentDispositionParams().AppendL(KTxtParam4()); mimeHeaders->ContentDispositionParams().AppendL(KTxtParam5()); mimeHeaders->ContentDispositionParams().AppendL(KTxtParam6()); mimeHeaders->XTypeParams().AppendL(KTxtParam7()); mimeHeaders->XTypeParams().AppendL(KTxtParam8()); mimeHeaders->XTypeParams().AppendL(KTxtParam9()); CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); CMsvAttachment* attachment = manager.GetAttachmentInfoL(attachmentId); CleanupStack::PushL(attachment); mimeHeaders->StoreL(*attachment); manager.ModifyAttachmentInfoL(attachment, waiter->iStatus); CleanupStack::Pop(attachment); waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(2, mimeHeaders); // waiter, mimeHeaders CompareMimeHeadersL(*emailMsg, attachmentId); CleanupStack::PopAndDestroy(2, entry);//emailMsg, entry TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionSmtpModifyAttachmentInfo); TestCase().ActionCompletedL(*this); }
void CMtfTestActionSmtpAddLinkedAttachment::RunTestL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); HBufC* paramFilePath = ObtainParameterReferenceL<HBufC>(TestCase(),ActionParameters().Parameter(2)); HBufC8* paramMimeType = ObtainParameterReferenceL<HBufC8>(TestCase(),ActionParameters().Parameter(3)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CImEmailMessage* emailMsg = CImEmailMessage::NewL(*entry); CleanupStack::PushL(emailMsg); CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvLinkedFile); CleanupStack::PushL(attachment); attachment->SetMimeTypeL(*paramMimeType); TParse fileNameParser; User::LeaveIfError(fileNameParser.Set(*paramFilePath, NULL, NULL)); attachment->SetAttachmentNameL(fileNameParser.NameAndExt()); TEntry fileEntry; User::LeaveIfError(paramSession->FileSession().Entry( fileNameParser.FullName(), fileEntry)); attachment->SetSize(fileEntry.iSize); MMsvAttachmentManager& manager = emailMsg->AttachmentManager(); manager.AddLinkedAttachmentL(*paramFilePath, attachment, waiter->iStatus); CleanupStack::Pop(attachment); // ownership passed to manager waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); attachment = NULL; TInt attachmentCount = manager.AttachmentCount(); attachment = manager.GetAttachmentInfoL(attachmentCount - 1); CleanupStack::PushL(attachment); TMsvAttachmentId attachmentId = attachment->Id(); CleanupStack::PopAndDestroy(attachment); CleanupStack::PopAndDestroy(2, entry); // emailMsg, entry StoreParameterL<TMsvAttachmentId>(TestCase(),attachmentId,ActionParameters().Parameter(4)); }
/** ConstructL() Used to ensure that MMsvAttachmentManager is not destroyed until we want it to be. To do this we need to preserve certain objects of CImEmailMessage, which if disappeared would invalidate MMsvAttachmentManager. But this should be deleted in a controlled manner. @param aSession An object of type CMsvSession object. @param aEntry An object of type TMsvEntry used to get the entry ID. */ void CAttachmentItem::ConstructL(CMsvSession& aSession, TMsvEntry aEntry) { iMsvEntry = aSession.GetEntryL(aEntry.Id()); iMsvEntry->SetEntryL(aEntry.Id()); iEmailMsg = CImEmailMessage::NewL(*iMsvEntry); CMsvOperationActiveSchedulerWait* waiter = CMsvOperationActiveSchedulerWait::NewLC(); iEmailMsg->GetAttachmentsListL(waiter->iStatus, aEntry.Id(), CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly); waiter->Start(); CleanupStack::PopAndDestroy(1, waiter); //waiter }
// --------------------------------------------------------------------------- // Second level constructor. Creates the data members to the heap. // Creates also the folder CMsvEntry. // --------------------------------------------------------------------------- // void CIpsPlgMsgIterator::ConstructL( CMsvSession& aMsvSession, const TFSMailMsgId aFolderId, const RArray<TFSMailSortCriteria>& aSorting ) { FUNC_LOG; iFolderEntry = aMsvSession.GetEntryL( aFolderId.Id() ); StoreSortCriteriaL(aSorting); iMsgSortKey = new (ELeave) TIpsPlgMsgKey( *iFolderEntry, iSortingCriteria ); iMsgSwapper = new (ELeave) TIpsPlgMsgSwap( *iFolderEntry ); iSortingOn = ( aSorting.Count() > 0 ) && ( aSorting[0].iField != EFSMailDontCare); iMsgMapper = CIpsPlgMsgMapper::NewL( aMsvSession, iPlugin ); iMsvSession = &aMsvSession; }
void CMtfTestActionRemoveAllAttachments::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionRemoveAllAttachments); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TInt attachIdFlag = ObtainValueParameterL<TInt>(TestCase(),ActionParameters().Parameter(2), 0); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->EditStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& manager = store->AttachmentManagerL(); TInt attachmentCount = manager.AttachmentCount(); for ( ; attachmentCount > 0 ; attachmentCount-- ) { CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); if( attachIdFlag == 1 ) { CMsvAttachment* attachInfo = manager.GetAttachmentInfoL(0); CleanupStack::PushL(attachInfo); manager.RemoveAttachmentL(attachInfo->Id(), waiter->iStatus); CleanupStack::PopAndDestroy(attachInfo); } else { manager.RemoveAttachmentL(0, waiter->iStatus); } waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); } store->CommitL(); CleanupStack::PopAndDestroy(2, entry); // store, entry TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionRemoveAllAttachments); TestCase().ActionCompletedL(*this); }
// 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 }
/** Stores the Unknown Push message in the message store. Saves the message data in a new attachment file. This makes it more efficient for the UI to read the data. @param aSession Message server session @param aParent ID of the parent for the new entry. It is the caller's responsibility to ensure that the parent ID is correct. @return ID of the new message server entry. @see CPushMsgEntryBase::SaveL() */ EXPORT_C TMsvId CUnknownPushMsgEntry::SaveL(CMsvSession& aSession, TMsvId aParent) { CMsvEntry* entryPtr = aSession.GetEntryL(KMsvRootIndexEntryId); CleanupStack::PushL(entryPtr); // This tidies itself up TMsvId newEntry = CPushMsgEntryBase::SaveL(aSession, aParent); #ifdef __MESSAGING_API_V2__ TRAPD( saveError, TFileName fileName = ContentFileNameL(); entryPtr->SetEntryL(newEntry); CMsvStore* store = entryPtr->EditStoreL(); CleanupStack::PushL(store); SaveMessageBodyL(store->AttachmentManagerL(), fileName); store->CommitL(); CleanupStack::PopAndDestroy(store); )
void CMtfTestActionGetEntry::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionAddGetEntry); if(TestCase().TestStepResult() == EPass) { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); entry->SetEntryL(messageEntry); StoreParameterL<CMsvEntry>(TestCase(),*entry,ActionParameters().Parameter(2)); CleanupStack::Pop(entry); TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionAddGetEntry); } TestCase().ActionCompletedL(*this); }
void CMtfTestActionRemoveFileAttachmentWithDestroy::ExecuteActionL() { TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionRemoveFileAttachmentWithDestroy); CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvAttachmentId attachId = ObtainValueParameterL<TMsvAttachmentId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->EditStoreL(); CleanupStack::PushL(store); MMsvAttachmentManager& manager = store->AttachmentManagerL(); CMsvAttachment* attachInfo = manager.GetAttachmentInfoL(attachId); CleanupStack::PushL(attachInfo); // First ensure that the attachment is a file attachment if( attachInfo->Type() != CMsvAttachment::EMsvFile ) { User::Leave(KErrGeneral); } CleanupStack::PopAndDestroy(attachInfo); CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); manager.RemoveAttachmentL(attachId, waiter->iStatus); waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); // destroy the store without commit CleanupStack::PopAndDestroy(2, entry); // store, entry TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionRemoveFileAttachmentWithDestroy); TestCase().ActionCompletedL(*this); }
void CMtfTestActionAddEntryAttachment::RunTestL() { CMsvSession* paramSession = ObtainParameterReferenceL<CMsvSession>(TestCase(),ActionParameters().Parameter(0)); TMsvId messageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(1)); TMsvId attachmentMessageEntry = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(2)); CMsvEntry* entry = paramSession->GetEntryL(messageEntry); CleanupStack::PushL(entry); CMsvStore* store = entry->EditStoreL(); CleanupStack::PushL(store); CMtfAsyncWaiter* waiter = CMtfAsyncWaiter::NewL(); CleanupStack::PushL(waiter); CMsvAttachment* attachment = CMsvAttachment::NewL(CMsvAttachment::EMsvMessageEntry); CleanupStack::PushL(attachment); TMsvEntry attachmentEntry; TMsvId attachmentServiceEntry; User::LeaveIfError(paramSession->GetEntry(attachmentMessageEntry, attachmentServiceEntry, attachmentEntry)); attachment->SetSize(attachmentEntry.iSize); MMsvAttachmentManager& manager = store->AttachmentManagerL(); manager.AddEntryAsAttachmentL(attachmentMessageEntry, attachment, waiter->iStatus); CleanupStack::Pop(attachment); // ownership passed to manager waiter->StartAndWait(); User::LeaveIfError(waiter->Result()); CleanupStack::PopAndDestroy(waiter); TMsvAttachmentId attachmentId = attachment->Id(); store->CommitL(); CleanupStack::PopAndDestroy(2, entry); // store, entry StoreParameterL<TMsvAttachmentId>(TestCase(),attachmentId,ActionParameters().Parameter(3)); }
EXPORT_C void CBaseSmsActiveSocketWatcher::StoreMsgL(CSmsMessage* aSmsMessage, TBool aCheckForSID) { BIOWATCHERLOG(iWatcherLog.Printf(_L("Bio: StoreMsgL: %S"), &iBioMsgText)); CleanupStack::PushL(aSmsMessage); CMsvSession* session = CMsvSession::OpenSyncL(*this); CleanupStack::PushL(session); BIOWATCHERLOG(LogMessageL(*aSmsMessage)); // The trap error code is ignored here. We already have loaded the settings // in the SetupL method. Any catastrophic failure would be reported later // when the message store is attempted. TRAP_IGNORE(RestoreSettingsL(*session)); PreStoreActionL(*session, *aSmsMessage); CMsvEntry* msvEntry = session->GetEntryL(KMsvGlobalInBoxIndexEntryId); CleanupStack::PushL(msvEntry); TInt systemDrive = RFs::GetSystemDrive(); TInt driveUnit = session->CurrentDriveL(); TVolumeInfo volumeInfo; User::LeaveIfError(iFs.Volume(volumeInfo, driveUnit)); BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: driveUnit: %d "),driveUnit)); BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: volumeInfo : %d"), volumeInfo.iFree)); BIOWATCHERLOG(iWatcherLog.Printf(_L("BioNbs: threshold level= : %d"), KSmsThresholdDiskSpaceValue)); //Check if non-system drive has enough space to store the message if (driveUnit != systemDrive ) { BIOWATCHERLOG(iWatcherLog.Printf(_L8("Low Memory"))); TInt value; TInt err = RProperty::Get(KUidSystemCategory,KUidPSDiskSpaceMonitorKeyType, value); BIOWATCHERLOG(iWatcherLog.Printf(_L("RProperty Get Value: %d "),err)); if (volumeInfo.iFree < KSmsThresholdDiskSpaceValue) { if(value == ESmsDiskSpaceAvailable) { User::LeaveIfError(RProperty::Set(KUidSystemCategory,KUidPSDiskSpaceMonitorKeyType, ESmsDiskSpaceFull)); } User::Leave(KErrDiskFull); } else { if(value == ESmsDiskSpaceFull) { User::LeaveIfError(RProperty::Set(KUidSystemCategory,KUidPSDiskSpaceMonitorKeyType, ESmsDiskSpaceAvailable)); } } } if( CanStoreMessage() ) { TBool retainReplaceMessage = ETrue; ReplaceTypeMessageL(*msvEntry, *aSmsMessage, retainReplaceMessage); CleanupStack::Pop(3, aSmsMessage); CleanupStack::PushL(session); //guaranteed not leave because of the 3 previous POPs CleanupStack::PushL(msvEntry); if( retainReplaceMessage ) CreateMessageL(*msvEntry, aSmsMessage, aCheckForSID); //destroys the CSmsMessage else delete aSmsMessage; //destroy the CSmsMessage as CreateMessageL() would have done CleanupStack::PopAndDestroy(2, session); } else { CleanupStack::PopAndDestroy(3, aSmsMessage); BIOWATCHERLOG(iWatcherLog.Printf(_L8("Not Creating Message"))); } }
/* Test to check the new API ** CopyStoreL(TInt aDrive, TMsvOp aOperationId, TRequestStatus& aStatus) */ LOCAL_C void TestCopyStoreOperationL() { CMsgsTestUtils::SetDriveL(EDriveC); CSessionObserver* ob = new(ELeave)CSessionObserver; CleanupStack::PushL(ob); // Set session in observer CMsvSession* session = CMsvSession::OpenAsyncL(*ob); ob->iSession = session; CleanupStack::PushL(session); CActiveScheduler::Start(); test(ob->iType==MMsvSessionObserver::EMsvServerReady); //Create an entry in the mail CMsvEntry* entry=session->GetEntryL(KMsvDraftEntryId); CleanupStack::PushL(entry); // create entry to work under TMsvEntry folder; folder.iType = KUidMsvFolderEntry; folder.iMtm = KUidMsvLocalServiceMtm; folder.iServiceId = KMsvLocalServiceIndexEntryId; _LIT(KTestDescription,"A Description"); _LIT(KTestDetails,"A Details"); folder.iDescription.Set(KTestDescription); folder.iDetails.Set(KTestDetails); entry->CreateL(folder); entry->SetEntryL(folder.Id()); CMsvStore* store=entry->EditStoreL(); CleanupStack::PushL(store); RMsvWriteStream stream; stream.AssignLC(*store,TUid::Uid(0x1000)); stream.WriteL(KTestDescription); stream.CommitL(); store->CommitL(); CleanupStack::PopAndDestroy(3); CTestActive* active = new(ELeave)CTestActive; CleanupStack::PushL(active); // Test Copy MailStore active->StartL(); CMsvOperation* operation = NULL; TDriveUnit unit =(EDriveD); operation = session->CopyStoreL(unit, active->iStatus); test(operation->Mtm() == KUidMsvServerMtm); CleanupStack::PushL(operation); CActiveScheduler::Start(); //Retrieve progress TPckgBuf<TMsvCopyProgress> package; package.Copy(operation->ProgressL()); test(package().iError == KErrNone); //delete session; CleanupStack::PopAndDestroy(4); //Check that both the source and destination //MailStore directory structure is same CMsgsTestUtils::WaitForServerClose(); CDir *srcDir; CDir *destDir; _LIT(intro, "Testing the directory structure"); _LIT(KEntryname,"%S"); theUtils->Printf(intro); TFileName dest = unit.Name(); dest.Append(KMsvDefaultFolder2); User::LeaveIfError(theUtils->FileSession().GetDir(dest, KEntryAttDir|KEntryAttNormal, ESortByName, destDir)); unit =EDriveC; TFileName src = unit.Name(); src.Append(KMsvDefaultFolder2); User::LeaveIfError(theUtils->FileSession().GetDir(src, KEntryAttDir|KEntryAttNormal, ESortByName, srcDir)); TInt counter=0; TEntry srcEntry; TEntry destEntry; while (counter<srcDir->Count()) { srcEntry = (*srcDir)[counter]; destEntry = (*destDir)[counter]; //Check the sizes test(srcEntry.iSize == destEntry.iSize); //Check the names test(srcEntry.iName == destEntry.iName); //Print out the names on the log theUtils->Printf(KEntryname,&(srcEntry.iName)); counter++; } delete srcDir; delete destDir; }
void CSMSSender::CreateSMSMessageL(const TDesC& aText, const TDesC& aAddress) /** Prepare SMS specific objects ready to send via ESOCK @param aText buffer containing ascii contents of message to send @param aAddress buffer with telephone number of SMS receiver */ { #ifndef __WINS__ TSmsAddr smsAddr; smsAddr.SetSmsAddrFamily(ESmsAddrSendOnly); smsAddr.SetPort(smsAddr.Port() + 1);//ycf __LOGSTR_TOFILE("sockent bind"); iSocket.Bind(smsAddr); CSmsBuffer* smsBuffer = CSmsBuffer::NewL(); //CleanupStack::PushL(smsBuffer) is NOT used because CSmsMessage takes ownership of our buffer :-) CSmsMessage* smsMsg = CSmsMessage::NewL(iFs, CSmsPDU::ESmsSubmit, smsBuffer); CleanupStack::PushL(smsMsg); TSmsUserDataSettings smsSettings; smsSettings.SetAlphabet(TSmsDataCodingScheme::ESmsAlphabetUCS2); smsSettings.SetTextCompressed(EFalse); smsMsg->SetUserDataSettingsL(smsSettings); TBuf<KMaxAddressSize> toAddress; toAddress.Copy(aAddress); smsMsg->SetToFromAddressL(toAddress); //Get service centre address. // The method used here assumes the SMS settings are provisioned, which is true in known cases. // There are alternative partner-only APIs, however this allow this source to be kept public #ifdef EKA2 CSmsSettings* smsSCSettings = CSmsSettings::NewL(); CleanupStack::PushL(smsSCSettings); CSmsAccount* smsAccount=CSmsAccount::NewLC(); smsAccount->LoadSettingsL(*smsSCSettings); // index of the default service centre address for this service TInt defIndex; User::LeaveIfError(defIndex = smsSCSettings->DefaultServiceCenter()); // Get the service center address CSmsServiceCenter& scAddr = smsSCSettings->GetServiceCenter(defIndex); TPtrC theAddress=scAddr.Address(); HBufC* serviceCentreAddress=HBufC::NewLC(theAddress.Length()); *serviceCentreAddress=theAddress; smsMsg->SmsPDU().SetServiceCenterAddressL(*serviceCentreAddress); CleanupStack::PopAndDestroy(serviceCentreAddress);// CleanupStack::PopAndDestroy(smsAccount); CleanupStack::PopAndDestroy(smsSCSettings); #else TMsvId serviceId; CObserver* pObserver = new (ELeave) CObserver(); CleanupStack::PushL(pObserver); CMsvSession* pSession = CMsvSession::OpenSyncL(*pObserver); CleanupStack::PushL(pSession); TSmsUtilities::ServiceIdL(*pSession, serviceId, KUidMsgTypeSMS); CMsvEntry* service = pSession->GetEntryL(serviceId); CleanupStack::PushL(service); CMsvStore* msvstore = service->ReadStoreL(); CleanupStack::PushL(msvstore); CSmsSettings* smsSCSettings = CSmsSettings::NewL(); CleanupStack::PushL(smsSCSettings); smsSCSettings->RestoreL(*msvstore); TInt defIndex; User::LeaveIfError(defIndex = smsSCSettings->DefaultSC()); defIndex = smsSCSettings->DefaultSC(); // Get the default service center address CSmsNumber& scAddr = smsSCSettings->SCAddress(defIndex); TPtrC theAddress=scAddr.Address(); HBufC* serviceCentreAddress=HBufC::NewLC(theAddress.Length()); *serviceCentreAddress=theAddress; smsMsg->SmsPDU().SetServiceCenterAddressL(*serviceCentreAddress); CleanupStack::PopAndDestroy(serviceCentreAddress);// CleanupStack::PopAndDestroy(smsSCSettings); //smsSettings CleanupStack::PopAndDestroy(msvstore); CleanupStack::PopAndDestroy(service); CleanupStack::PopAndDestroy(pSession); CleanupStack::PopAndDestroy(pObserver); #endif //convert to wide HBufC* payload = HBufC::NewL(aText.Length()); CleanupStack::PushL(payload); TPtr pPayload=payload->Des(); pPayload.Copy(aText); //copy from narrow to wide and convert smsBuffer->InsertL(0, pPayload); //copies payload RSmsSocketWriteStream writeStream(iSocket); CleanupClosePushL(writeStream); writeStream << *smsMsg; // remember << operator _CAN_ leave __LOGSTR_TOFILE("write stream commit"); writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); CleanupStack::PopAndDestroy(2);//smsMsg, payload #endif }
LOCAL_C void DoExecuteL() { CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler(); CleanupStack::PushL(activeScheduler); CActiveScheduler::Install(activeScheduler); // Create Session CSessionObserver* sessionObserver; sessionObserver = new (ELeave) CSessionObserver; CleanupStack::PushL(sessionObserver); CMsvSession* session = CMsvSession::OpenSyncL(*sessionObserver); CleanupStack::PushL(session); // Set the message entry to global Outbox folder CMsvEntry* msvEntry = session->GetEntryL(KMsvGlobalOutBoxIndexEntryId); CleanupStack::PushL(msvEntry); // Get the selection of Pigeon messages present in Outbox CMsvEntrySelection* selection = msvEntry->ChildrenWithMtmL(KUidMsgTypePigeon); CleanupStack::PushL(selection); // Schedule it to send immediately - use default settings. CMsvScheduleSettings* settings = CMsvScheduleSettings::NewL(); CleanupStack::PushL(settings); RScheduler scheduler; TSchedulerItemRef ref; CMsvScheduleSend::ConnectAndRegisterL(scheduler, *settings); CleanupClosePushL(scheduler); TInt selCount = selection->Count(); for( TInt index = 0; index < selCount; ++index ) { msvEntry->SetEntryL(selection->At(index)); if(msvEntry != NULL) { TMsvEntry entry = msvEntry->Entry(); ref.iHandle = KErrNotFound; FindOrCreateScheduleL(scheduler, entry.iDate, *settings, ref); User::LeaveIfError(scheduler.DisableSchedule(ref.iHandle)); TMsvSchedulePackage package; package.iPollProgress = 3000000; package.iCommandId = ESendScheduledL; package.iId = selection->At(index); TTaskInfo info; CMsvScheduleSend::ScheduleEntryL(scheduler, ref, package, info); User::LeaveIfError(scheduler.EnableSchedule(ref.iHandle)); } } CleanupStack::PopAndDestroy(7, activeScheduler); }