// Copyright (c) 1999-2010 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:

// SMSCLNT.CPP

//

#include <txtrich.h>	// CRichText

#include <msvuids.h>	// KUidMsvRootEntry etc.

#include <mtmdef.hrh>	// KUidMtmQuerySupports etc.

#include <mtmdef.h>		// KMsvMessagePartRecipient	etc.

#include <msvids.h>		// KMsvGlobalOutBoxIndexEntryId etc.

#include <msvftext.h>	// CMsvFindText

#include <biodb.h>		// CBIODatabase

#include <smss.rsg>

#include <barsc.h>

#include <barsread.h>

#include "SMSCLNT.H"	// smsclntmtm

#include "SMCMMAIN.H"	// panics

#include "smscmds.h"	// ESmsMtmCommandReadServiceCenter etc.

#include "smut.h"		// TSmsUtilities

#include "SMUTHDR.H"	// CSmsHeader

#include "SMUTSET.H"	// CSmsSettings

#include <smutsimparam.h>

#include <csmsemailfields.h>

#include <csmsaccount.h>

#include "csmssendmessageoperation.h"

#include <msvenhancesearchsortutil.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include "msvconsts.h"

#include <mtmuidsdef.hrh>

#include <tmsvsmsentry.h>

#endif

/**

The maximum number of SMS PDUs allowed in a concatenated SMS message.

Together with KSmcmMaxCharsInMessageConcatenated7Bit, this is the response to

the query for the KUidMtmQueryMaxTotalMsgSizeValue capability.

@see	CSmsClientMtm::QueryCapability

@see	KSmcmMaxCharsInMessageConcatenated7Bit

*/

const TInt KSmcmMaxMessageNumber=0x32;

/**

The maximum number of characters in a concatenated SMS PDU.

Together with KSmcmMaxMessageNumber, this is the response to the query for the

KUidMtmQueryMaxTotalMsgSizeValue capability.

@see	CSmsClientMtm::QueryCapability

@see	KSmcmMaxCharsInMessageConcatenated7Bit

*/

const TInt KSmcmMaxCharsInMessageConcatenated7Bit=0x99;

/**

The maximum number of characters in a non-concatenated SMS PDU.

This is the response to the query for the KUidMtmQueryMaxBodySizeValue

capability.

@see	CSmsClientMtm::QueryCapability

*/

const TInt KSmcmMaxTotalMsgSize=160;

/**

The granularity of the in-memory buffer for CRichText objects.

@see	CRichText::NewL

*/

const TInt KSmcmRichTextConstant=256;

// These default subject formats are used if the resource field has not been

// migrated to include a localised set of subject formats.

_LIT(KSmsDefaultForwardSubjectFormat,	"Fw: %S");

_LIT(KSmsDefaultReplySubjectFormat,		"Re: %S");

/**

Static factory constuctor.

@param	aRegisteredMtmDll

The registry information for the SMS MTM.

@param	aSession

The message server session

@leave KErrArgument

Invalid data read from the SMS resource file

@internalTechnology

@see	CRegisteredMtmDll

*/

EXPORT_C CSmsClientMtm* CSmsClientMtm::NewL(CRegisteredMtmDll& aRegisteredMtmDll,CMsvSession& aSession)

	{

	CSmsClientMtm* self=new(ELeave) CSmsClientMtm(aRegisteredMtmDll,aSession);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Destructor.

*/

CSmsClientMtm::~CSmsClientMtm()

	{

	delete iServiceSettings;

	delete iSmsHeader;

	delete iEmailForwardSubjectFormat;

	delete iEmailReplySubjectFormat;

	}

void CSmsClientMtm::HandleEntryEvent(enum MMsvEntryObserver::TMsvEntryEvent /*aEvent*/,TAny* ,TAny* ,TAny* )

	{

	}

/**

Reads SMS parameters from the SIM.

It starts a new CSmsSimParamOperation, which uses the SMS Server MTM to read the 

SMS parameters from the SIM. 

If the phone is unable to supply the SMS parameters from the SIM, then the progress

information of the CSmsSimParamOperation operation will contain an error. 

@param	aObserverRequestStatus

The request status to be completed when the read operation has completed.

@return

A SIM parameter reader operation. The read SIM parameters are stored in

CSmsSimParamOperation::iSimParams. 

*/

EXPORT_C CSmsSimParamOperation* CSmsClientMtm::ReadSimParamsL(TRequestStatus& aObserverRequestStatus)

	{

	RestoreServiceAndSettingsL();

	CMsvEntry* entry = Session().GetEntryL(iServiceId);

	CleanupStack::PushL(entry);

	CSmsSimParamOperation* op = CSmsSimParamOperation::ReadSimParamsL(entry->Entry().iMtm, iServiceId, Session(), aObserverRequestStatus);

	CleanupStack::PopAndDestroy(entry);

	return op;

	}

/**

Writes SMS parameters to the SIM.

It starts a new CSmsSimParamOperation, which uses the SMS Server to write the 

specified SIM parameters to the SIM.

If the phone is unable to write the SMS parameters to the SIM, then the progress

information of the CSmsSimParamOperation operation will contain an error.

@param	aList

The SIM parameters to be written.

@param	aObserverRequestStatus

The request status to be completed when the write operation has completed.

@return

A SIM parameter writer operation.

*/

EXPORT_C CSmsSimParamOperation* CSmsClientMtm::WriteSimParamsL(const CMobilePhoneSmspList& aList, TRequestStatus& aObserverRequestStatus)

	{

	RestoreServiceAndSettingsL();

	CMsvEntry* entry = Session().GetEntryL(iServiceId);

	CleanupStack::PushL(entry);

	CSmsSimParamOperation* op = CSmsSimParamOperation::WriteSimParamsL(aList, entry->Entry().iMtm, iServiceId, Session(), aObserverRequestStatus);

	CleanupStack::PopAndDestroy(entry);

	return op;

	}

/**

Restores the SMS service ID and SMS service settings.

The SMS service ID is obtained. The service settings for the obtained ID are 

restored from the message server. The SMS service ID can be obtained using the

CSmsClientMtm::ServiceId API and the SMS settings are accessed via the two

CSmsClientMtm::ServiceSettings API overloads.

This API should be used before using any of the other APIs that required the SMS

service ID and SMS service settings to be set.

@see	CSmsClientMtm::ServiceId

@see	CSmsClientMtm::ServiceSettings

*/

EXPORT_C void CSmsClientMtm::RestoreServiceAndSettingsL()

	{

	if (iServiceSettings == NULL)

		{

		iServiceSettings = CSmsSettings::NewL();

		}

	// Let's find the right service entry!

	TSmsUtilities::ServiceIdL(Session(), iServiceId, KUidMsgTypeSMS);

	CSmsAccount* account = CSmsAccount::NewLC();

	// just v2

	account->LoadSettingsL(*iServiceSettings);

	CleanupStack::PopAndDestroy(account);    

	}

CSmsClientMtm::CSmsClientMtm(CRegisteredMtmDll& aRegisteredMtmDll,CMsvSession& aSession)

: CBaseMtm(aRegisteredMtmDll,aSession)

	{

	}

void CSmsClientMtm::ConstructL()

	{

	SwitchCurrentEntryL(KMsvRootIndexEntryId);  //  Creates rich text

	RFs& fileSession = Session().FileSession();

	iSmsHeader=CSmsHeader::NewL(CSmsPDU::ESmsSubmit,Body(),fileSession);

	TRAPD(err, RestoreServiceAndSettingsL());

	if (err)

		{

		if (err != KErrNotFound)

			{

			User::Leave(err);

			}

		TMsvEntry entry;

		entry.iMtm = KUidMsgTypeSMS;

	    entry.iType = KUidMsvServiceEntry;

	    entry.SetReadOnly(EFalse);

	    entry.SetVisible(EFalse);

	    entry.iDate.UniversalTime();

	    entry.iDetails.Set(_L("Default SMS Message"));

    	CMsvEntry* root = Session().GetEntryL(KMsvRootIndexEntryId);

	    root->CreateL(entry);

	   	iServiceId = entry.Id();

	   	delete root;

		}

	//Initialise iRealAddressOpen and iRealAddressClose from the SMS resouce file

	RResourceFile resFile = TSmsUtilities::OpenResourceFileL(fileSession);

	CleanupClosePushL(resFile);

	TBuf<4> buf;

	TSmsUtilities::ReadResourceStringL(resFile, R_ADDRESSEE_TELEPHONE_OPEN, buf);

	if (buf.Length() > 0)

		{

		iRealAddressOpen = buf[0];

		}

	else

		{

		User::Leave(KErrArgument); 

		}

	TSmsUtilities::ReadResourceStringL(resFile, R_ADDRESSEE_TELEPHONE_CLOSE, buf);

	if (buf.Length() > 0)

		{

		iRealAddressClose = buf[0];

		}

	else

		{

		User::Leave(KErrArgument); 

		}

	iEmailForwardSubjectFormat	= ReadEmailSubjectFormatL(resFile, R_SMS_EMAIL_FORWARD_SUBJECT_FORMAT, KSmsDefaultForwardSubjectFormat);

	iEmailReplySubjectFormat	= ReadEmailSubjectFormatL(resFile, R_SMS_EMAIL_REPLY_SUBJECT_FORMAT, KSmsDefaultReplySubjectFormat);

	CleanupStack::PopAndDestroy(&resFile);

	}

HBufC* CSmsClientMtm::ReadEmailSubjectFormatL(RResourceFile& aResourceFile, TInt aResourceId, const TDesC& aDefaultFormat)

	{

	HBufC* format = NULL;

	if( aResourceFile.OwnsResourceId(aResourceId) )

		{

		HBufC8* buf = aResourceFile.AllocReadLC(aResourceId);

		TResourceReader reader;

		reader.SetBuffer(buf);

		format = (reader.ReadTPtrC()).AllocL();

		CleanupStack::PopAndDestroy(buf);	

		}

	else

		{

		format = aDefaultFormat.AllocL();

		}

	return format;

	}

CMsvOperation* CSmsClientMtm::CreateNewEntryL(TMsvEntry& aNewEntry, TMsvId aDestination,CSmsHeader& aSmsHeader,const CRichText& aBody,TRequestStatus& aCompletionStatus)

	{

	RestoreServiceAndSettingsL();

	CMsvEntry* cEntry = CMsvEntry::NewL(Session(), aDestination, TMsvSelectionOrdering());

	CleanupStack::PushL(cEntry);

	cEntry->CreateL(aNewEntry);

	const TMsvId msvid = aNewEntry.Id();

	Session().CleanupEntryPushL(msvid);

	// switch context to the new entry

	cEntry->SetEntryL(msvid);

	aNewEntry = cEntry->Entry(); //for the description and details fields

	aSmsHeader.SetSmsSettingsL(*iServiceSettings);

	// service centre was not being set 

	//If we haven't been provided with a service centre address then use the default one

	if(!aSmsHeader.ReplyPathProvided())

		{

		TInt defaultSC = iServiceSettings->DefaultServiceCenter();

		if(defaultSC > -1)

			{

			aSmsHeader.SetServiceCenterAddressL( iServiceSettings->GetServiceCenter(defaultSC).Address() );	

			}

		}

	// Check the context header to see an email message...

	if( iSmsHeader->EmailFields().Length() > 0 )

		{

		// Yep - update the message as follows

		// 1. Add the email <-> SMS gateway as the recipient of the new message.

		// 2. Set the PID for interworking with email.

		// 3. Set the entry description to be the email subject (if there is one).

		// 4. Set the entry details to be the email address (if there is one).

		DoAddRecipientL(&aSmsHeader, iSmsHeader->FromAddress(), KNullDesC);

		CSmsPDU& pdu = aSmsHeader.Message().SmsPDU();

		if( pdu.ProtocolIdentifierPresent() )

			{

			pdu.SetPIDType(TSmsProtocolIdentifier::ESmsPIDTelematicInterworking);

			pdu.SetTelematicDeviceIndicator(TSmsProtocolIdentifier::ESmsTelematicDevice);

			pdu.SetTelematicDeviceType(TSmsProtocolIdentifier::ESmsInternetElectronicMail);

			}

		const CSmsEmailFields& fields = aSmsHeader.EmailFields();

		if( fields.Subject().Length() > 0 )

			{

			// There is a subject - use this as the description

			aNewEntry.iDescription.Set(fields.Subject());

			}

		if( fields.HasAddress() )

			{

			// There is an address - use first address as the details.

			aNewEntry.iDetails.Set(fields.Addresses().MdcaPoint(0));			

			}

		}

	CMsvStore* msvstore=cEntry->EditStoreL();

	CleanupStack::PushL(msvstore);

	aSmsHeader.StoreL(*msvstore);

	msvstore->StoreBodyTextL(aBody);

	msvstore->CommitL();

	aNewEntry.iSize = msvstore->SizeL();

	cEntry->ChangeL(aNewEntry);

	CleanupStack::PopAndDestroy(msvstore);

	TPckg<TMsvId> prog(msvid);

	CMsvOperation* op = CMsvCompletedOperation::NewL(Session(), KUidMsgTypeSMS, prog, aNewEntry.iServiceId, aCompletionStatus);

	// Now safe to pop the entry off the message server cleanup stack, and any

	// other remaining resources.

	Session().CleanupEntryPop();

	CleanupStack::PopAndDestroy(cEntry);

	return op;

	}

TBool CSmsClientMtm::ValidRecipients() const

	{

	TInt numrecipients = iSmsHeader->Recipients().Count();

	TBool valid=numrecipients;

	while (numrecipients-- && valid)

		valid=ValidNumber(iSmsHeader->Recipients()[numrecipients]->Address());

	return valid;

	}

TBool CSmsClientMtm::ValidNumber(const TDesC& aNumber) const

	{

	TBool valid=EFalse;

	for (TInt i=0; i<aNumber.Length() && !valid; i++)  //  valid if at least one number in string

		valid=(aNumber[i]>='0') && (aNumber[i]<='9');

	return valid;

	}

void CSmsClientMtm::DoAddAddresseeL(const TDesC& aRealAddress, const TDesC& aAlias)

	{

	if (aAlias.Length())

		{

		HBufC* buf=HBufC::NewLC(aAlias.Length()+aRealAddress.Length()+3);

		TPtr ptr = buf->Des();

		ptr.Copy(aAlias);

		ptr.Append(_L(" "));

		ptr.Append(iRealAddressOpen);

		ptr.Append(aRealAddress);

		ptr.Append(iRealAddressClose);

		iAddresseeList->AppendL(ptr);

		CleanupStack::PopAndDestroy(buf);

		}

	else

		iAddresseeList->AppendL(aRealAddress);

	}

void CSmsClientMtm::AddRecipientL(const TDesC& aRealAddress, const TDesC& aAlias)

	{

	DoAddRecipientL(iSmsHeader, aRealAddress, aAlias);

	}

void CSmsClientMtm::DoAddRecipientL(CSmsHeader* aSmsHeader, const TDesC& aRealAddress, const TDesC& aAlias)

	{

	CSmsNumber* recipient=CSmsNumber::NewL();

	CleanupStack::PushL(recipient);

	if ( aRealAddress.Locate('@') != KErrNotFound )

        {

        CSmsEmailFields* emailFields = NULL;

        if ( aSmsHeader->EmailFields().Length() > 0 )

            {

            emailFields = CSmsEmailFields::NewL( aSmsHeader->EmailFields() );

            }

        else

            {

            emailFields = CSmsEmailFields::NewL();

            }

        CleanupStack::PushL( emailFields );

		recipient->SetEmailAddressL(aRealAddress, emailFields, aAlias);

        // Clears the CSmsHeaders EmailFields for non Email addresses

        aSmsHeader->SetEmailFieldsL( *emailFields );

        CleanupStack::PopAndDestroy( emailFields );

        }

	else

	    {

	    recipient->SetAddressL(aRealAddress);

	    if (aAlias.Length() > 0)

	    	{	

	        recipient->SetNameL(aAlias);

	    	}

	    }

    aSmsHeader->Recipients().AppendL(recipient);

    CleanupStack::Pop(recipient);

	}

void CSmsClientMtm::ResetHeader()

	{

	if (iSmsHeader)

		iSmsHeader->Recipients().ResetAndDestroy();

	if (iAddresseeList)

		iAddresseeList->Reset();

	}

void CSmsClientMtm::FindInBodyL(const TDesC& aTextToFind, const TMsvPartList& aFoundList, TMsvPartList& aResult)

	{

	CMsvFindText* text=CMsvFindText::NewL();

	CleanupStack::PushL(text);

	if (text->FindRichTextL(aTextToFind,Body(),aFoundList))

		aResult|=KMsvMessagePartBody;

	CleanupStack::PopAndDestroy(text);

	}

void CSmsClientMtm::FindL(const TDesC& aTextToFind, const TMsvPartList aPartList, TMsvPartList& aFoundList)

	{

	CMsvFindText* text=CMsvFindText::NewL();

	CleanupStack::PushL(text);

	// Enhance search and sort

  	// The setting variables are accessed by getting an instance to TMsvEnhanceSearchSortUtil  class

  	// This is accessed here by using GetExtensionData() defined in CBaseMtm which refers 

  	// to iExtensionData member variable

 	TMsvEnhanceSearchSortUtil* searchsortutil = (TMsvEnhanceSearchSortUtil*)(GetExtensionData());

	if(searchsortutil != NULL)

		{

		// For callees other than CMsvSearchsortOpOnHeaderBody class, searchsortutil pointer will be NULL	

		TInt index=0;

		TBool foundinname = EFalse;

		TBool foundinaddress = EFalse;

		// Retrieve the search sort setting flags

		TUint32 searchsortsetting=searchsortutil->GetSearchSortSetting();

		if(aPartList & KMsvMessagePartTo)

			{

			TInt count=iSmsHeader->Recipients().Count();

			/* 

			Search for the To field in the the SMS header

			First it looks in the Senders name

			if not found, it tries to find it in the senders numbers

			*/

			for(TInt i=0;i<count;i++)

				{

				if ((text->FindTextL(aTextToFind,(iSmsHeader->Recipients()).operator[](i)->Name(),aPartList)))

					{

					aFoundList|=KMsvMessagePartTo;

					foundinname = ETrue;

					index = i;

					}

				if(!foundinname)

					{

					if ((text->FindTextL(aTextToFind,(iSmsHeader->Recipients()).operator[](i)->Address(),aPartList)))

						{

						aFoundList|=KMsvMessagePartTo;

						foundinaddress = ETrue;

						index = i;