// 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:

// Implementation for the CSmsuActiveBase based class CSmsMessageSend.

// 

//

/**

 @file

 @internalAll

*/

#include "smspsend.h"

#include "smspstor.h"

#include "smspmain.h"

#include "smsuset.h"

#include "smsulog.h"

#include "exterror.h"

#include "gsmubuf.h"

#include "SmsuTimer.h"

#include <logwraplimits.h>

/** 

 *  Static object constructor for CSmsMessageSend.

 *

 *  @param aSegmentationStore  Segmentation Store.

 *  @param aSmsMessaging       ETel SMS messaging subsession.

 *  @param aSmsSettings        The global SMS settings.

 *  @param aMobileSmsCaps      SMS messaging capabilities of TSY/phone.

 *  @param aPriority           Priority to use for the Active Object.

 *  @param aSmspSetBearer      Set bearer object.

 */

CSmsMessageSend* CSmsMessageSend::NewL(CSmsSegmentationStore& aSegmentationStore,

									   const TSmsSettings& aSmsSettings,

									   const RMobileSmsMessaging::TMobileSmsCapsV1& aMobileSmsCaps,

									   RMobileSmsMessaging& aSmsMessaging,

									   TInt aPriority,

									   CSmspSetBearer& aSmspSetBearer)

	{

	CSmsMessageSend*  self = new (ELeave) CSmsMessageSend(aSegmentationStore,

														  aSmsSettings,

														  aMobileSmsCaps,

														  aSmsMessaging,

														  aPriority,

														  aSmspSetBearer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	} // CSmsMessageSend::NewL

/**

 *  2nd Phase of construction.

 *  

 *  Creates CSmsTimeout object and the SMS event logger.

 */

void CSmsMessageSend::ConstructL()

	{

	iSmsEventLogger = CSmsEventLogger::NewL(iSegmentationStore.FileSession(),

											Priority());

	ConstructTimeoutL();

	} // CSmsMessageSend::ConstructL

/** 

 *  Default constructor.

 *

 *  @param aSegmentationStore  Segmentation Store.

 *  @param aSmsSettings        The global SMS settings.

 *  @param aMobileSmsCaps      SMS messaging capabilities of TSY/phone.

 *  @param aSmsMessaging       ETel SMS messaging subsession.

 *  @param aPriority           Priority to use for the Active Object.

 *  @param aSmspSetBearer      Set bearer object.

 */

CSmsMessageSend::CSmsMessageSend(CSmsSegmentationStore& aSegmentationStore,

								 const TSmsSettings& aSmsSettings,

								 const RMobileSmsMessaging::TMobileSmsCapsV1& aMobileSmsCaps,

								 RMobileSmsMessaging& aSmsMessaging,

								 TInt aPriority,

								 CSmspSetBearer& aSmspSetBearer)

  : CSmsuActiveBase(aPriority),

	iState(ESmsMessageSendIdle),

	iSegmentationStore(aSegmentationStore),

	iSmspSetBearer(aSmspSetBearer),

	iSmsSettings(aSmsSettings),

	iMobileSmsCaps(aMobileSmsCaps),

	iSmsMessaging(aSmsMessaging),

	iMobileSmsSendAttributesV1Pckg(iMobileSmsSendAttributesV1),

	iSmsArray(8),

	iSegmentSequenceNumber(-1)

	{

	// NOP

	} // CSmsMessageSend::CSmsMessageSend

/** 

 *  Standard destructor.

 */

CSmsMessageSend::~CSmsMessageSend()

	{

	Cancel();

	delete iSmsEventLogger;

	} // CSmsMessageSend::~CSmsMessageSend

void CSmsMessageSend::Start(CSmsMessage& aSmsMessage, TInt aOptions,

							const TSmsAddr& aSmsAddr, TRequestStatus& aStatus)

	{

	__ASSERT_DEBUG(iState == ESmsMessageSendIdle,SmspPanic(KSmspPanicUnexpectedState));

	//

	// Store the request status that we will complete when finished...

	//

	Queue(aStatus);

	//

	// Initialise member data...

	//

	iSmsMessage=&aSmsMessage;

	iSmsMessage->ParsedToFromAddress(iToFromTelNumber);

	iOptions = aOptions;

	iSmsAddr = aSmsAddr;

	iSmsPDUData.iType      = aSmsMessage.Type();

	iSmsPDUData.iTotal     = 0;

	iSmsPDUData.iSent      = 0;

	iSmsPDUData.iDelivered = 0;

	iSendError = KErrNone;

	iSmsEventLogger->Event().SetId(KLogNullId);

	//

	// Begin by setting the bearer...

	//

	iState = ESmsMessageSendSetBearer;

	iSmspSetBearer.NotifyBearerSet(iStatus);

	SetActive();

	} // CSmsMessageSend::Start

void CSmsMessageSend::DoRunL()

	{

	switch (iState)

		{

		case ESmsMessageSendSetBearer:

			{

			//

			// If setting of bearer was successful then send the message.

			//

			// The TSY will complete with KErrNotSupported if it doesn't

			// support setting the send bearer.

			//

			if (iStatus.Int() == KErrNone  ||

				iStatus.Int() == KErrNotSupported)

				{

				if (iSmsEventLogger->ClientAvailable())

					{

					CreateLogServerEvent();

					}

				else

					{

					SegmentMessage();

					}

				}

			}

			break;

		case ESmsMessageSendCreatingLogServerEvent:

			{

			//

			// If a log event was created ok, then store the id...

			//

			if (iStatus.Int() == KErrNone)

				{

				iSmsMessage->SetLogServerId(iSmsEventLogger->Event().Id());

				}

			else

				{

				iSmsEventLogger->Event().SetId(KLogNullId);

				}

			//

			// Segment the message. This will send the first PDU as well...

			//

			SegmentMessage();

			}

			break;

		case ESmsMessageSendSegmentingMessage:

			{

			//

			// If the previous PDU was sent ok, then send the next one...

			//

			if (iStatus.Int() == KErrNone)

				{

				SendNextPDU();

				}

			else

				{

				//

				// An error occured. Save the error for later and either

				// update the log event, or drop to the end of RunL() so

				// that Complete() is called...

				//

				iSendError = iStatus.Int();

				if (iSmsEventLogger->Event().Id() != KLogNullId)

					{

					UpdateLogServerEvent();

					}

				}

			}

			break;

		case ESmsMessageSendPDU:

			{

			//

			// If the PDU is sent with an acknowledgement, then decode the

			// submit report...

			//

			if (iMobileSmsCaps.iSmsControl & RMobileSmsMessaging::KCapsSendWithAck  &&

				iMobileSmsSendAttributesV1.iFlags & RMobileSmsMessaging::KGsmSubmitReport)

				{

				DecodeSubmitReportL();

				}

			if (iStatus.Int() == KErrNone  &&  !IsRPError())

				{

				}

			else if (IsRPError())

				{

				}

			else

				{

				}

			//

			// If the PDU was sent okay, then update the segmentation store...

			//

			if (iStatus.Int() ==KErrNone)

				{

				iSegmentSequenceNumber++; 

				UpdateSegmentationStore();

				}

			else

				{

				//

				// An error occured. Save the error for later and either

				// update the log event, or drop to the end of RunL() so

				// that Complete() is called...

				//

				iSendError = iStatus.Int();

				if (iSmsEventLogger->Event().Id() != KLogNullId)

				 	{

				 	UpdateLogServerEvent();

				 	}

				}

			}

			break;

		case ESmsMessageSendUpdatingSegmentationStore:

			{

			if (iStatus.Int() == KErrNone)

				{

				//

				// The update has been successful, so update the log event or

				// send the next PDU. If the log event is updated, then it

				// will then send the next PDU...

				// 

				if (iSmsEventLogger->Event().Id() != KLogNullId)

					{

					UpdateLogServerEvent();

					}

				else

					{

					SendNextPDU();

					}

				}

			else

				{

				//

				// An error occured. Save the error for later and either

				// update the log event, or drop to the end of RunL() so

				// that Complete() is called...

				//

				iSendError = iStatus.Int();

				if (iSmsEventLogger->Event().Id() != KLogNullId)

					{

					UpdateLogServerEvent();

					}

				}

			}

			break;

		case ESmsMessageSendUpdatingLogEvent:

			{

			//

			// Ignore log server error and continue with the next PDU if

			// the last send was okay, otherwise drop to the bottom of the

			// RunL() and Complete().

			//

			if (iSendError == KErrNone)

				{

				SendNextPDU();

				}

			}

			break;

		default:

			{

			SmspPanic(KSmspPanicUnexpectedState);

			}

			break;

		};

	//

	// DoRunL() will now return to CSmsuActiveBase which if the object

	// is not active, will call Complete().

	//

	} // CSmsMessageSend::DoRunL

void CSmsMessageSend::DoCancel()

	{

	TimedSetActiveCancel();

	switch (iState)

		{

		case ESmsMessageSendSetBearer:

			{

			iSmspSetBearer.Cancel();

			}

			break;

		case ESmsMessageSendSegmentingMessage:

			{

			// NOP

			}

			break;

		case ESmsMessageSendCreatingLogServerEvent:

		case ESmsMessageSendUpdatingLogEvent:

			{

			iSmsEventLogger->Cancel();

			}

			break;

		case ESmsMessageSendPDU:

			{

			iSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingSendMessage);

			}

			break;

		case ESmsMessageSendUpdatingSegmentationStore:

			{

			// NOP

			}

			break;

		default:

			{

			SmspPanic(KSmspPanicUnexpectedState);

			}

			break;

		};

	iSendError = KErrCancel;

	//

	// Handle completion of this Active Object. Note that the object

	// may well still be active at this point...

	//

	if (TimedOut())

		{

		Complete(KErrTimedOut);

		}

	else

		{

		Complete(KErrCancel);

		}

	} // CSmsMessageSend::DoCancel

/**

 *  Decodes SMS-SUBMIT-REPORT PDU and checks if it is SMS-SUBMIT-REPORT for

 *  RP-ERROR.

 *  

 *  @leave Leaves if CSmsBuffer::NewL or CSmsMessage::NewL leaves.

 *  

 */

void CSmsMessageSend::DecodeSubmitReportL()

	{

	//

	// Only try to decode the submit report if error is a RP-error, in which case there should be a valid PDU

	//

	if (IsRPError())

		{

		TGsmSms sms;

		sms.SetPdu(iMobileSmsSendAttributesV1.iSubmitReport);

		CSmsBuffer* buffer=CSmsBuffer::NewL();

		// try to create a sms message from the submit report PDU (smsMessage takes ownership of the buffer)

		CSmsMessage*  smsMessage = CSmsMessage::NewL(iSegmentationStore.FileSession(),

													 sms,buffer,IsRPError(),ETrue);

		CleanupStack::PushL(smsMessage);

		if (smsMessage->SmsPDU().Type() == CSmsPDU::ESmsSubmitReport)

			{

			CSmsSubmitReport&  submitReport =(CSmsSubmitReport&) smsMessage->SmsPDU();

			TInt  failureCause = submitReport.FailureCause();

			if (failureCause != TSmsFailureCause::ESmsErrorFree)

				{

				iStatus = FailureCauseToError(failureCause);

				}

			}

		else

			{

			}

		CleanupStack::PopAndDestroy(smsMessage);

		}

	} // CSmsMessageSend::DecodeSubmitReportL

/**

 *  Checks if TSY completed send message request with RP-error.

 *  

 *  @return boolean.

 */

TBool CSmsMessageSend::IsRPError() const

	{

	TBool  isRPError = EFalse;

	switch (iStatus.Int())

		{

		case KErrGsmSMSUnassignedNumber:

		case KErrGsmSMSOperatorDeterminedBarring:

		case KErrGsmSMSCallBarred:

		case KErrGsmSMSReserved:

		case KErrGsmSMSNetworkFailure:

		case KErrGsmSMSShortMessageTransferRejected:

		case KErrGsmSMSMemoryCapacityExceeded:

		case KErrGsmSMSDestinationOutOfOrder:

		case KErrGsmSMSUnidentifiedSubscriber:

		case KErrGsmSMSFacilityRejected:

		case KErrGsmSMSUnknownSubscriber:

		case KErrGsmSMSNetworkOutOfOrder:

		case KErrGsmSMSTemporaryFailure:

		case KErrGsmSMSCongestion:

		case KErrGsmSMSResourcesUnavailable:

		case KErrGsmSMSRequestedFacilityNotSubscribed:

		case KErrGsmSMSRequestedFacilityNotImplemented:

		case KErrGsmSMSInvalidShortMessageTransferReferenceValue:

		case KErrGsmSMSUnspecifiedInvalidMessage:

		case KErrGsmSMSInvalidMandatoryInformation:

		case KErrGsmSMSNonExistentMessageType:

		case KErrGsmSMSIncompatibleMessageWithSmsProtocolState:

		case KErrGsmSMSInformationElementNotImplemented:

		case KErrGsmSMSUnspecifiedProtocolError:

		case KErrGsmSMSUnspecifiedInterworkingError:

			{

			isRPError = ETrue;

			}

			break;

		default:

			{

			// NOP

			}

			break;

		}

	return isRPError;

	} // CSmsMessageSend::IsRPError

void CSmsMessageSend::SegmentMessage()

	{

	iState = ESmsMessageSendSegmentingMessage;

	TRAPD(ret,DoSegmentMessageL());

	CompleteMyself(ret);

	} // CSmsMessageSend::SegmentMessage