diff -r 000000000000 -r 72b543305e3a messagingappbase/obexmtms/TObexMTM/SRC/SendMessageState.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/obexmtms/TObexMTM/SRC/SendMessageState.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,334 @@ +// Copyright (c) 2002-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: +// $Workfile: SendMessageState.cpp $ +// $Author: Stevep $ +// $Revision: 8 $ +// $Date: 27/03/02 10:49 $ +// +// + +#include "sendmessagestate.h" + +//TODO:- check that all these headers are required + +// System includes +#include // KUidMsgTypeBt +#include // TBtMtmAsyncCmds +#include // KUidMsgTypeIr +#include // TIrMtmAsyncCmds +#include // KUidMsvMessageEntry +#include +#include +#include + +#include +#include + +#include "cobextestfilenameandheaders.h" +#include "casyncwaiter.h" + +// User includes +#include "obexharness.h" +#include "obextestutils.h" +#include "obextestheaderlist.h" + +// Stub support. +_LIT(KStubConfigFolderName, "c:\\msgtest\\obexsmoke\\stub\\"); +_LIT(KStubConfigFileName, "c:\\msgtest\\obexsmoke\\stub\\conf.txt"); + +// To test with the old "CObexClientMtm::STimeouts" structure, updated with +// new "CIrClientMtm::STimeouts" structure by DEF36727, remove comment below. +//#define VERIFY_DEF36727_USING_OLD_STURCT + +// +// CSendMessageState +// + +CSendMessageState::CSendMessageState(const TDesC& aStubDesiredResult, CObexClientTest& aClientTest) + : CActiveTestState(EPriorityNormal), + iClientTest(aClientTest), + iStubDesiredResult(aStubDesiredResult) + { + iTimer = CPeriodic::NewL(EPriorityNormal); + CActiveScheduler::Add(this); + } + +void CSendMessageState::StartL(TRequestStatus& aStatus) + { + // If the "stub" folder is present, externalize desired result and + // verify headers. + + RFs rfs; + CleanupClosePushL(rfs); // PUSH + User::LeaveIfError(rfs.Connect()); + + RDir dir; + CleanupClosePushL(dir); + + TInt fileErr = dir.Open(rfs, KStubConfigFolderName, KEntryAttDir); + if (fileErr == KErrNone) + { + CObexTestHeaderList* verifyHeaderList = iClientTest.VerifyHeaders(); + + verifyHeaderList->AutoExternaliseL(KStubConfigFileName, iStubDesiredResult); + + // Clear the verify headers, ready for the next send. + iClientTest.ClearVerifyHeadersL(); + } + + CleanupStack::PopAndDestroy(2); + + + + // Add any attachments. + iReportStatus = &aStatus; + CObexTestUtils& testUtils = iClientTest.ObexTestUtils(); + CObexClientMtm& obexMtm = (CObexClientMtm&)testUtils.GetCurrentObexClientMtm(); + + // Create a "selection" object from the currently selected entry. + iSelection = new (ELeave) CMsvEntrySelection; + iSelection->AppendL(testUtils.Entry().Id()); + + // Add each attachment to the message, if any. + RPointerArray& attachments = iClientTest.Attachments(); + + if (attachments.Count() > 0) + { + CMsvEntry& entry = obexMtm.Entry(); + CMsvStore* store = entry.EditStoreL(); + CleanupStack::PushL(store); + MMsvAttachmentManager& manager = store->AttachmentManagerL(); + TInt count = manager.AttachmentCount(); + for( TInt ii=0; iiiHeaderList; + if( headerList != NULL ) + { + headerList->ExportToAttachmentL(*attachment); + } + + TParse fileNameParser; + User::LeaveIfError(fileNameParser.Set(attachments[ii]->iFileName, NULL, NULL)); + attachment->SetAttachmentNameL(fileNameParser.NameAndExt()); + manager.AddLinkedAttachmentL(attachments[ii]->iFileName, attachment, waiter->iStatus); + CleanupStack::Pop(attachment); + waiter->StartAndWait(); + User::LeaveIfError(waiter->Result()); + CleanupStack::PopAndDestroy(waiter); + } + store->CommitL(); + CleanupStack::PopAndDestroy(store); + } + iClientTest.ClearAttachmentsL(); + + + // Now carry out the send. + if(testUtils.CurrentObexMtm() == KUidMsgTypeBt) + { + CBtClientMtm::SBtcCmdSendParams sendParams; + // if not, we set the password length to zero + iConnectPassword.SetLength(0); + + // initialise T-Class to something sensible. + sendParams.iTimeouts.iPutTimeout = 300000000; + sendParams.iTimeouts.iConnectTimeout = 300000000; + sendParams.iRemoteObexPort = 0; + sendParams.iConnectPassword = &iConnectPassword; + + TPckgBuf sendParamsBuf(sendParams); + + // Invoke the "send" command on the Obex Client MTM, + // asking it to notify us when it completes (which will be when the + // message has actually been sent). + + // Note that the current obex mtm needs to have been set + testUtils.InstantiateBTClientMtmL(); + testUtils.GetCurrentObexClientMtm().SwitchCurrentEntryL(testUtils.Entry().Id()); + testUtils.GetCurrentObexClientMtm().LoadMessageL(); + iClientTest.SetCurrentOperation(testUtils.GetCurrentObexClientMtm().InvokeAsyncFunctionL(EBtMtmCmdSend, *iSelection, sendParamsBuf, iStatus)); + } + else + { +#ifdef VERIFY_DEF36727_USING_OLD_STURCT + CObexClientMtm::STimeouts sendParams; +#else + CIrClientMtm::STimeouts sendParams; +#endif + + // initialise T-Class to something sensible. + sendParams.iPutTimeout = 300000000; + sendParams.iConnectTimeout = 300000000; + +#ifdef VERIFY_DEF36727_USING_OLD_STURCT + TPckgBuf sendParamsBuf(sendParams); +#else + TPckgBuf sendParamsBuf(sendParams); +#endif + + // Invoke the "send" command on the Obex Client MTM, + // asking it to notify us when it completes (which will be when the + // message has actually been sent). + + // Note that the current obex mtm needs to have been set + + testUtils.InstantiateIRClientMtmL(); + testUtils.GetCurrentObexClientMtm().SwitchCurrentEntryL(testUtils.Entry().Id()); + testUtils.GetCurrentObexClientMtm().LoadMessageL(); + iClientTest.SetCurrentOperation(testUtils.GetCurrentObexClientMtm().InvokeAsyncFunctionL(CIrClientMtm::EIrcCmdSend, *iSelection, sendParamsBuf, iStatus)); + } + + // If we want to cancel this request after a certain time, set up + // the timer which will notify us when the time is up. + if (iClientTest.CancelGranularity() > 0) + { + iCancel = ETrue; + // NB: the timer interval is specified in microseconds + iTimer->Start(iClientTest.CancelGranularity() * 1000, + iClientTest.CancelGranularity() * 1000, + TCallBack(TimerCallback, this)); + } + // If we're checking the progress every n milliseconds, set up the + // timer to check this. + else if (iClientTest.ProgressGranularity() > 0) + { + iCheckProgress = ETrue; + // NB: the timer interval is specified in microseconds + iTimer->Start(1, iClientTest.ProgressGranularity() * 1000, + TCallBack(TimerCallback, this)); + } + + // tell the caller that we're waiting for the request to complete + aStatus = KRequestPending; + SetActive(); + } + +TInt CSendMessageState::TimerCallback(TAny* aPtr) + { + CSendMessageState* self = static_cast(aPtr); + + // if we want to cancel the timer, then do so + if (self->iCancel) + { + // stop the timer + self->iTimer->Cancel(); + delete self->iTimer; + self->iTimer = NULL; + + // cancel and delete the operation + self->iClientTest.CurrentOperation().Cancel(); + self->iClientTest.SetCurrentOperation(NULL); + + self->iCancelled = ETrue; + + // tell the caller that we're complete - if the send isn't + // already complete + if (!self->iSendComplete) + User::RequestComplete(self->iReportStatus, KErrNone); + } + else if (self->iCheckProgress) + { + TPckgBuf package; +// Assume that a callback function shouldn't leave + TRAPD(err, package.Copy(self->iClientTest.CurrentOperation().ProgressL())); + + if(err == KErrNone) + { + TBuf<256> progressBuf; + _LIT(KFormatString, "Sent %d/%d messages (%d/%d bytes): error code = %d"); + progressBuf.Format(KFormatString, + package().iEntriesDone, + package().iTotalEntryCount, + package().iCurrentBytesTrans, + package().iCurrentEntrySize, + package().iError); + TRAP(err, self->iClientTest.LogCommentL(progressBuf)); + } + + if (self->iSendComplete) + { + self->iTimer->Cancel(); + delete self->iTimer; + self->iTimer = NULL; + self->iClientTest.SetCurrentOperation(NULL); + return EFalse; + } + return ETrue; + } + return EFalse; + } + +void CSendMessageState::RunL() + { + // set the send to be complete + iSendComplete = ETrue; + + if (iCancelled) + { + // select the parent entry (usually the Outbox) for convenience + iClientTest.ObexTestUtils().SetEntryL( + iClientTest.ObexTestUtils().Entry().Parent()); + + // exit now, before progress is checked + return; + } + + // Check the progress so that we can extract the error code, to see + // whether the send operation succeeded or failed. + TPckgBuf package; + package.Copy(iClientTest.CurrentOperation().ProgressL()); + if (package().iError != KErrNone) + { + TInt err = iClientTest.IgnoreSendErrors() ? KErrNone : package().iError; + User::RequestComplete(iReportStatus, err); + } + else + { + User::RequestComplete(iReportStatus, iStatus.Int()); + } + + // NB: we can't delete the message operation if we need to + // check for progress etc., because it will be used by a timer event + // after this point. + if (!iCheckProgress && !iCancel) + iClientTest.SetCurrentOperation(NULL); + + // select the parent entry (usually the Outbox) for convenience + iClientTest.ObexTestUtils().SetEntryL( + iClientTest.ObexTestUtils().Entry().Parent()); + } + +void CSendMessageState::DoCancel() + { + iClientTest.CurrentOperation().Cancel(); + // delete the operation + iClientTest.SetCurrentOperation(NULL); + } + +CSendMessageState::~CSendMessageState() + { + delete iTimer; + if (iSelection) + iSelection->Reset(); + delete iSelection; + } + +// +// +