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

// Implements CWapSapMessageSender and CWapProtocolObserver

// 

//

/**

 @file

*/

#include "ws_obsvr.h"

#include <commsdattypesv1_1.h>

#include "smsprot.h"

#include "ws_main.h"

#include "wapmain.h"

#include "WAPDGRM.H"

#include "gsmuieoperations.h"

#include "gsmunonieoperations.h"

using namespace CommsDat;

//

// Constant values

//

// KWapSmsmessageValidityPeriod - Hardcoded message validity period (in minutes)

//                                for WAPSMS and WAPSMS7 bearers.

//

//

const TInt KWapSmsMessageValidityPeriod = 5;

const TInt KSmsMsgArraySegmentSize = 8;

//

// CWapSapMessageSender

//

// Owned by CWapSmsProvider, implements MSmsMessageObserver.

// Splits up a CWapDatagram into one or more SMS messages and sends them to

// Sms.Prt one at a time.

//

_LIT(KWAPSMSBearer, "WAPSMSBearer");

/**

 *  Constructor

 */

CWapSapMessageSender::CWapSapMessageSender(CSmsProtocol* aSmsProtocol, CWapSmsProvider* aWapSap)

    {

    iSmsAddr.SetSmsAddrFamily(ESmsAddrSendOnly);

    iSmsProtocol = aSmsProtocol;

    iProvider = aWapSap;

    } // CWapSapMessageSender::CWapSapMessageSender

/**

 *  Destructor

 */

CWapSapMessageSender::~CWapSapMessageSender()

    {

    if (iSmsProtocol)

        {

        iSmsProtocol->RemoveSmsMessageObserver(*this);

        }

    delete iSmsMsgArray;

    } // CWapSapMessageSender::~CWapSapMessageSender

/**

 *  Factory

 */

CWapSapMessageSender* CWapSapMessageSender::NewL(CSmsProtocol* aSmsProtocol, CWapSmsProvider* aWapSap)

	{

	CWapSapMessageSender* msgSender = new(ELeave) CWapSapMessageSender(aSmsProtocol,aWapSap);

	CleanupStack::PushL(msgSender);

	msgSender->iSmsMsgArray = new(ELeave) CArrayPtrFlat<CSmsMessage>(KSmsMsgArraySegmentSize);

	aSmsProtocol->AddSmsMessageObserverL(*msgSender);

	User::LeaveIfError(aSmsProtocol->BindSmsMessageObserver(*msgSender,msgSender->iSmsAddr));

	CleanupStack::Pop();

	return msgSender;

	} // CWapSapMessageSender::NewL

/**

 *  Send a message to the SMSPROT.PRT

 *  Splits up the CWapDatagram into one or more SMS messages and sends them

 *  one at a time to SMSPROT.PRT

 */

void CWapSapMessageSender::SendDatagramL(CWapDatagram* aMsg)

	{

	__ASSERT_DEBUG(iSmsMsgArray->Count()==0,Panic(EWapSmsSapMessageSenderBusy));

	CleanupStack::PushL(aMsg);

	aMsg->EncodeConcatenatedMessagesL(iSmsProtocol->FileSession(), *iSmsMsgArray);

	SendNextSms();

	CleanupStack::PopAndDestroy();

	} // CWapSapMessageSender::SendDatagramL

/**

 *  Send an SMS message to SMSPROT.PRT

 */

void CWapSapMessageSender::SendNextSms()

	{

	__ASSERT_DEBUG(iSmsMsgArray->Count()>0,Panic(EWapSmsSapMessageSenderNothingToSend));

	CSmsMessage* smsMsg = iSmsMsgArray->At(0);

	TRAPD(ret, SetSmsMessageSettingsL(smsMsg) );

	if(ret != KErrNone)

		iProvider->Error(ret, MSocketNotify::EErrorSend);

	else

		{

		iSmsMsgArray->Delete(0);

		iSmsProtocol->SendSmsMessage(smsMsg,*this,0);

		}

	} // CWapSapMessageSender::SendNextSms

/**

 *  Setup the SMS message according to the settings stored in the CommDB

 */

void CWapSapMessageSender::SetSmsMessageSettingsL(CSmsMessage* aSmsMessage)

	{

	TBuf<KCommsDbSvrMaxFieldLength> msgCenterNumberValue;

	TUint32 msgValidityPeriodValue = KWapSmsMessageValidityPeriod;

	TBool msgDeliveryReportValue = EFalse;

	TUint32 modemId = 0;

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	CSmsSubmit* smsSubmit = reinterpret_cast<CSmsSubmit*>(&aSmsMessage->SmsPDU());

	if (iProvider->MessageType()==CWapSmsProvider::ESmartMessage)

		{

		CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);

		CleanupStack::PushL(globalSettingsField);

		globalSettingsField->SetRecordId(1);

		globalSettingsField->LoadL(*db);

		modemId = *globalSettingsField;

		CleanupStack::PopAndDestroy(globalSettingsField);

		CMDBField<TDesC>* msgCenterNumberValueField = new(ELeave) CMDBField<TDesC>(KCDTIdMessageCentreNumber);

		CleanupStack::PushL(msgCenterNumberValueField);

		msgCenterNumberValueField->SetRecordId(modemId);

		msgCenterNumberValueField->LoadL(*db);

		msgCenterNumberValue = *msgCenterNumberValueField;

		CleanupStack::PopAndDestroy(msgCenterNumberValueField);

		CMDBField<TUint32>* msgValidityPeriodValueField = new(ELeave) CMDBField<TUint32>(KCDTIdMessageValidityPeriod);

		CleanupStack::PushL(msgValidityPeriodValueField);

		msgValidityPeriodValueField->SetRecordId(modemId);

		msgValidityPeriodValueField->LoadL(*db);

		msgValidityPeriodValue = *msgValidityPeriodValueField;

		CleanupStack::PopAndDestroy(msgValidityPeriodValueField);

		CMDBField<TBool>* msgDeliveryReportValueField = new(ELeave) CMDBField<TBool>(KCDTIdMessageDeliveryReport);

		CleanupStack::PushL(msgDeliveryReportValueField);

		msgDeliveryReportValueField->SetRecordId(modemId);

		msgDeliveryReportValueField->LoadL(*db);

		msgDeliveryReportValue = *msgDeliveryReportValueField;

		CleanupStack::PopAndDestroy(msgDeliveryReportValueField);

		TTimeIntervalMinutes validityPeriod(msgValidityPeriodValue);

		smsSubmit->SetValidityPeriod(validityPeriod);

		if (msgDeliveryReportValue)

			{

			if ((iProvider->GetStatusReportScheme() == EWapSmsTPSRR) && (iProvider->GetDataCodingScheme() == EWapSms8BitDCS))

				{

				CSmsTPSRROperations& operation = (CSmsTPSRROperations&)aSmsMessage->GetOperationsForNonIEL(ESmsTPSRRParameter);

				operation.SetSchemeL();

				operation.SetLastSegmentStatusReportL(ETrue);

				}

			else 

				{

				smsSubmit->SetStatusReportRequest(msgDeliveryReportValue);	

				}	

			}

		}

	else // 8-bit WAP

		{

		CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdGlobalWapAcessPoint);

		CleanupStack::PushL(globalSettingsField);

		globalSettingsField->SetRecordId(1);

		globalSettingsField->LoadL(*db);

		modemId = *globalSettingsField;

		CleanupStack::PopAndDestroy(globalSettingsField);

		CMDBField<TDesC>* bearerField = new(ELeave) CMDBField<TDesC>(KCDTIdWAPCurrentBearer);

		CleanupStack::PushL(bearerField);

		bearerField->SetRecordId(modemId);

		bearerField->LoadL(*db);

		TBuf<KCommsDbSvrMaxFieldLength> bearerType;

		bearerType = *bearerField;

		CleanupStack::PopAndDestroy(bearerField);

		if (TPtrC(KWAPSMSBearer) != TPtrC(bearerType))

			{

			// We're not the current bearer - cancel msgs in send queue

			// and leave with not supported error indication

			iSmsMsgArray->ResetAndDestroy();

			User::Leave(KErrNotSupported);

			}

		CMDBField<TDesC>* centerNumberField = new(ELeave) CMDBField<TDesC>(KCDTIdWAPSMSServiceCentreAddress);

		CleanupStack::PushL(centerNumberField);

		centerNumberField->SetRecordId(modemId);

		centerNumberField->LoadL(*db);

		msgCenterNumberValue = *centerNumberField;

		CleanupStack::PopAndDestroy(centerNumberField);

		smsSubmit->SetValidityPeriodFormat(TSmsFirstOctet::ESmsVPFNone);

		CMDBField<TUint32>* globalSettingsField2 = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);

		CleanupStack::PushL(globalSettingsField2);

		globalSettingsField2->SetRecordId(1);

		globalSettingsField2->LoadL(*db);

		modemId = *globalSettingsField2;

		CleanupStack::PopAndDestroy(globalSettingsField2);

		CMDBField<TBool>* msgDeliveryReportValueField = new(ELeave) CMDBField<TBool>(KCDTIdMessageDeliveryReport);

		CleanupStack::PushL(msgDeliveryReportValueField);

		msgDeliveryReportValueField->SetRecordId(modemId);

		msgDeliveryReportValueField->LoadL(*db);

		msgDeliveryReportValue = *msgDeliveryReportValueField;

		CleanupStack::PopAndDestroy(msgDeliveryReportValueField);

		if (msgDeliveryReportValue)

			{

			if ((iProvider->GetStatusReportScheme() == EWapSmsTPSRR) && (iProvider->GetDataCodingScheme() == EWapSms8BitDCS))

				{

				CSmsTPSRROperations& operation = (CSmsTPSRROperations&)aSmsMessage->GetOperationsForNonIEL(ESmsTPSRRParameter);

				operation.SetSchemeL();

				operation.SetLastSegmentStatusReportL(ETrue);

				}

			else

				{

				smsSubmit->SetStatusReportRequest(msgDeliveryReportValue);	

				}	

			}

		}

	CleanupStack::PopAndDestroy(); // db

	aSmsMessage->SmsPDU().SetServiceCenterAddressL(msgCenterNumberValue);

	} // CWapSapMessageSender::SetSmsMessageSettingsL

/**

 *  Received notification that a message has been sent.

 *  Continue sending SMSs if we have more or complete the send.

 */

void CWapSapMessageSender::MessageSendCompleted(TInt aStatus)

	{

	if (aStatus!=KErrNone)

		iSmsMsgArray->ResetAndDestroy();

	if (iSmsMsgArray->Count()==0)

		{

		iProvider->Error(aStatus,MSocketNotify::EErrorSend);

		return;

		}

	SendNextSms();

	} // CWapSapMessageSender::MessageSendCompleted

/**

 *  Return the address

 */

const TSmsAddr& CWapSapMessageSender::GetLocalAddress() const

	{

	return iSmsAddr;

	} // CWapSapMessageSender::GetLocalAddress

/**

 *  Set the address

 */

void CWapSapMessageSender::SetLocalAddress(const TSmsAddr& aSmsAddr)

	{

	iSmsAddr = aSmsAddr;

	} // CWapSapMessageSender::SetLocalAddress

/**

 *  Notification that the modem has been connected or disconnected

 *  (Has no relevance for the wap stack)

 */

void CWapSapMessageSender::ModemNotificationCompleted(TInt /*aStatus*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

/**

 *  Notification that the enumeration has completed

 *  (Has no relevance for the wap stack)

 */

void CWapSapMessageSender::EnumeratePhoneCompleted(TInt /*aStatus*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

/**

 *  Notification that a message has been received

 *  Messages should never be directly received by a SAP

 */

TInt CWapSapMessageSender::MessageReceived(const CSmsMessage& /*aSmsMessage*/,TDes& /*aDes*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    __ASSERT_DEBUG(EFalse,Panic(EWapSmsReceiveOnMessageSender));

    return KErrNone;

    BULLSEYE_RESTORE

    }

/**

 *  Informs protocol whether client confirms received message

 */

TBool CWapSapMessageSender::ClientConfirmsMessage()const

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    __ASSERT_DEBUG(EFalse,Panic(EWapSmsReceiveOnMessageSender));

    return ETrue;

    BULLSEYE_RESTORE

    }

/**

 *  Informs protocol whether address is used by the observer

 */

TInt CWapSapMessageSender::SmsAddrIsDuplicate(const MSmsMessageObserver* /*aObserver*/,const TSmsAddr& /*aAddr*/)const

	{

	return EFalse;

	} // CWapSapMessageSender::SmsAddrIsDuplicate

/**

 *  Notification that a message has been written to the phone or SIM

 *  (Has no relevance for the wap stack)

 */

void CWapSapMessageSender::MessageWriteCompleted(TInt /*aStatus*/, const CSmsMessage* /*aSmsMessage*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

/**

 *  Notification that a PDU delete has completed

 *  (Has no relevance for the wap stack)

 */

void CWapSapMessageSender::MessageDeleteCompleted(TInt /*aStatus*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

/**

 *  Notification that a read SMS parameters has completed

 *  (Has no relevance for the wap stack)

 */

void CWapSapMessageSender::ReadSmsParamsCompleted(TInt /*aStatus*/,CMobilePhoneSmspList* /*aSmspList*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

/**

 *  Notification that a write SMS parameters has completed

 *  (Has no relevance for the wap stack)

 */

void CWapSapMessageSender::WriteSmsParamsCompleted(TInt /*aStatus*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

//

// CWapProtocolObserver

//

// This class implements the MSmsMessageObserver interface defined by Sms.Prt

// Receives Sms messages from sms.prt.

//

/**

 *  Factory

 */

CWapProtocolObserver* CWapProtocolObserver::NewL(CWapSmsProtocol* aProtocol)

	{

	CWapProtocolObserver* prot = new(ELeave) CWapProtocolObserver;

	prot->iWapSmsProtocol=aProtocol;

	return prot;

	} // CWapProtocolObserver::NewL

/**

 *  Return the address

 */

const TSmsAddr& CWapProtocolObserver::GetLocalAddress() const

	{

	return iSmsAddr;

	} // CWapProtocolObserver::GetLocalAddress

/**

 *  Set the address

 */

void CWapProtocolObserver::SetLocalAddress(const TSmsAddr& aSmsAddr)

	{

	iSmsAddr = aSmsAddr;

	} // CWapProtocolObserver::SetLocalAddress

/**

 *  Notification that the modem has been connected or disconnected

 *  (Has no relevance for the wap stack)

 */

void CWapProtocolObserver::ModemNotificationCompleted(TInt /*aStatus*/)

	{

	} // CWapProtocolObserver::ModemNotificationCompleted

/*

 * Notification that a message has been sent

 * (does nothing)

 */

void CWapProtocolObserver::MessageSendCompleted(TInt /*aStatus*/)

    {

    // Ignore in code coverage - implementation required by base class

    // but not relavent for WAP PROT.

    BULLSEYE_OFF

    BULLSEYE_RESTORE

    }

/**

 *  Informs protocol whether client confirms received message

 */

TBool CWapProtocolObserver::ClientConfirmsMessage()const

	{

	return EFalse;

	} // CWapProtocolObserver::ClientConfirmsMessage

/**

 *  Informs protocol whether client confirms received message

 */

TInt CWapProtocolObserver::SmsAddrIsDuplicate(const MSmsMessageObserver* aObserver,const TSmsAddr& aAddr)const

	{