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

//

#include "SmsSocketWatcher.h"

#include <e32std.h>

#include <bsp.h>

#include <biouids.h>

#include <biodb.h>

#include <msvstd.h>

#include <msventry.h>

#include <smut.h>

#include <smuthdr.h>

#include <msvuids.h>

#include <watcher.h>

#include <smutset.h>

#include <csmsemailfields.h>

#include <csmsaccount.h>

#include <e32property.h>

#include <smsuaddr.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 

#include <bifchangeobserver.h>

#include <biomessageuids.h>

#include <tmsvsmsentry.h>

#include "cwatcher.h"

#include "tmsvbioinfo.h"

#endif

const TInt KSmsThresholdDiskSpaceValue = 125000; // 125 KB

/*

 *	CBaseSmsActiveSocketWatcher

*/

EXPORT_C CBaseSmsActiveSocketWatcher::CBaseSmsActiveSocketWatcher(CWatcherLog& aWatcherLog, TInt aPriority, TUid aBioID, RFs& aFs)

:	CActive(aPriority), 

	iState(ESmsIsClass0Msg),

	iBioMsgUID(aBioID),

	iBioServiceId(KMsvLocalServiceIndexEntryId),

	iSmsServiceId(KMsvLocalServiceIndexEntryId),

	iWatcherLog(aWatcherLog),

	iFs(aFs)

	{

	// Add it to the scheduler

	CActiveScheduler::Add(this);

	}

EXPORT_C CBaseSmsActiveSocketWatcher::~CBaseSmsActiveSocketWatcher() 

	{

	iTimer.Close();

	delete iSettings;

	delete iGetDetDesc;

	REComSession::FinalClose();

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::Complete(TInt aStatus)

	{

 	DoComplete(aStatus);

	WatcherComplete(aStatus);

	}

EXPORT_C TInt CBaseSmsActiveSocketWatcher::RunError(TInt aError)

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L8("Bio: RunL Failed with %d"), aError));

	Complete(aError);

	return KErrNone;

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::RunL()

//

// When the AO is state driven, this form of Run() is very effective

// DoRunL() takes the AO through the states, queuing another asynch step as required

// if DoRunL() detects the end of the cycle it returns without queuing another cycle.

//

// If Run() would exit without queuing another cycle it reports completion to the client.

// This is true if the asynch step or DoRunL fails, or the state cycle is complete

//

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L("Bio: DoRunL: %S, iStatus %d"), &iBioMsgText, iStatus.Int()));

	DoRunL();

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::SetupL()

	{

	DoSetupL();

	// Start the RunL in the WaitForMessage

	if (iState != ESmsIsClass0Msg)

		{

		iState = ESmsWWaitForMsg;

		}

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::StartL()

	{

	BIOWATCHERLOG(iWatcherLog.Printf(_L("Bio: StartL: %S"), &iBioMsgText));

	TRequestStatus* pS=&iStatus;

	// Nothing Asynchronous, so just throw into the wait state RunL()

	User::RequestComplete(pS, KErrNone);

	SetActive();

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::RestoreSettingsL(CMsvSession& aSession)

	{

	SetBioServiceId(aSession);

	// access sms service settings

	CSmsAccount* smsAccount = CSmsAccount::NewLC();

	// load settings

	smsAccount->LoadSettingsL(*iSettings);

	CleanupStack::PopAndDestroy(smsAccount);

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::RestoreSettingsL(TMsvId aBioServiceId, TMsvId aSmsServiceId)

	{

	SetBioServiceId(aBioServiceId, aSmsServiceId);

	// access sms service settings

	CSmsAccount* smsAccount = CSmsAccount::NewLC();

	// load settings

	smsAccount->LoadSettingsL(*iSettings);

	CleanupStack::PopAndDestroy(smsAccount);

	}

EXPORT_C void CBaseSmsActiveSocketWatcher::StoreMsgL(CSmsMessage* aSmsMessage)

	{

	StoreMsgL(aSmsMessage, EFalse);

	}

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")));

		}

	}

void CBaseSmsActiveSocketWatcher::ReplaceTypeMessageL(CMsvEntry& aEntry, CSmsMessage& aMessage, TBool& aRetainOriginalMessage)

	{

    if (aMessage.Type() == CSmsPDU::ESmsDeliver)

        {

        TUint8 pid(0);

        const CSmsPDU& sms = aMessage.SmsPDU();

        const CSmsDeliver& smsTemp = STATIC_CAST(const CSmsDeliver&,sms);

        pid = (TUint8)*smsTemp.ProtocolIdentifier();

        if ((pid & TSmsProtocolIdentifier::ESmsPIDTypeMask) == TSmsProtocolIdentifier::ESmsPIDShortMessageType)

            {

            if ( ((pid & TSmsProtocolIdentifier::ESmsShortMessageTypeMask) <= TSmsProtocolIdentifier::ESmsReplaceShortMessageType7)

                || ((pid & TSmsProtocolIdentifier::ESmsShortMessageTypeMask) == TSmsProtocolIdentifier::ESmsReturnCallMesage) )

                {

                DeleteReplaceTypeMessagesL(aEntry, pid, aMessage, aRetainOriginalMessage);

                }

            }

        }   // Type()

	}

void CBaseSmsActiveSocketWatcher::DeleteReplaceTypeMessagesL(CMsvEntry& aEntry, TUint8 aPid, CSmsMessage& aMessage, TBool& aRetainOriginalMessage)

	{

	CSmsDeliver& smsTemp = STATIC_CAST(CSmsDeliver&, aMessage.SmsPDU());

	TTime sourceMessageTime;

	TInt quart;

	smsTemp.ServiceCenterTimeStamp(sourceMessageTime, quart);

	// get the children

 	TMsvId parentFolder = KMsvGlobalInBoxIndexEntryId;

 	// If this is a class2 message, do the replacement in the class2 folder

 	TSmsDataCodingScheme::TSmsClass classTemp(TSmsDataCodingScheme::ESmsClass0);

 	smsTemp.Class(classTemp);

 	if (aMessage.Storage() == CSmsMessage::ESmsSIMStorage)

 		{	

 		if (CheckMessageExistsL(aEntry.Session(), iSettings->Class2Folder()))

 			{			

 			parentFolder = iSettings->Class2Folder();

 			}

 		}

 	aEntry.SetEntryL(parentFolder);

	TInt count = aEntry.Count();

	while (count--)

		{

		const TMsvSmsEntry& entry = aEntry[count];

		if ((entry.iMtm == KUidMsgTypeSMS || entry.iMtm == KUidBIOMessageTypeMtm) && entry.iType == KUidMsvMessageEntry)

			{

			const TUint8 entryPID = entry.ProtocolIdentifier();

			if ((entryPID & TSmsProtocolIdentifier::ESmsPIDTypeMask) == TSmsProtocolIdentifier::ESmsPIDShortMessageType)

				{

				if ((entryPID & TSmsProtocolIdentifier::ESmsShortMessageTypeMask) == (aPid & TSmsProtocolIdentifier::ESmsShortMessageTypeMask))

					{

					CParaFormatLayer* paraLayer = CParaFormatLayer::NewL();

					CleanupStack::PushL(paraLayer);

					CCharFormatLayer* charLayer = CCharFormatLayer::NewL();

					CleanupStack::PushL(charLayer);

					CRichText* richtext = CRichText::NewL(paraLayer,charLayer);

					CleanupStack::PushL(richtext);

					CSmsHeader* header = CSmsHeader::NewL(CSmsPDU::ESmsDeliver, *richtext);

					CleanupStack::PushL(header);

					CMsvEntry* currentEntry = aEntry.ChildEntryL(entry.Id());

					CleanupStack::PushL(currentEntry);

					CMsvStore* store = NULL;

					TRAPD(error, store = currentEntry->ReadStoreL());

					//If message arrived with "replace short message functionality", and some how message deleted from Mail2 store 

					//but entry exist in Index file. In such case, need to delete entry from Index file and treat this as a new message.

					if(error == KErrNotFound)

						{

						aRetainOriginalMessage = ETrue;

						aEntry.DeleteL(entry.Id());

						CleanupStack::PopAndDestroy(5); //paraLayer, charLayer, richtext, header, currentEntry

						return;

						}

					CleanupStack::PushL(store);

					header->RestoreL(*store);

					CleanupStack::PopAndDestroy(2); //store, currentEntry

					if ((header->FromAddress().Compare(smsTemp.ToFromAddress()) == 0))

						{

						CSmsDeliver& smsDeliver = static_cast<CSmsDeliver&>(header->Message().SmsPDU());

						TTime foundMessageTime;

						smsDeliver.ServiceCenterTimeStamp(foundMessageTime, quart);

						if (sourceMessageTime > foundMessageTime)

							{

							aRetainOriginalMessage = ETrue;

							aEntry.DeleteL(entry.Id());

							}

						else

							aRetainOriginalMessage = EFalse;

						}

					CleanupStack::PopAndDestroy(4); //paraLayer, charLayer, richtext, header

					}

				}

			}

		}

	}

TBool CBaseSmsActiveSocketWatcher::CheckForSID(TPtr& aMessage, TSecureId& aSecureId)

	{

	_LIT(KSecureIDStr, "//SYM");

	const TInt KIdLen = 8;

	// Sanity check

	if (aMessage.Length() < (KIdLen + KSecureIDStr().Length()))

		return EFalse;

	TBool locatedSecureId = (aMessage.Find(KSecureIDStr) == 0);

	if (locatedSecureId)

		{

		TPtr idPtr = aMessage.MidTPtr(KSecureIDStr().Length(), KIdLen); // Extract the string for the id.

		TLex numConverter;

		numConverter.Assign(idPtr.Ptr());

		TUint32 hexId;

		if (numConverter.Val(hexId, EHex) == KErrNone)

			aSecureId = TSecureId(hexId); // Convert the string to a number

		else

			locatedSecureId = EFalse;

		}

	return locatedSecureId;

	}

void CBaseSmsActiveSocketWatcher::CreateMessageL(CMsvEntry& aEntry, CSmsMessage* aMessage, TBool aCheckForSecureId)

	{

	// This function destroys CSmsMessage.

	CleanupStack::PushL(aMessage);

	// Create a CSmsHeader based on this message. smsHdr takes ownership of aMessage

	CSmsHeader* header = CSmsHeader::NewL(aMessage);

	CleanupStack::Pop(aMessage);

	CleanupStack::PushL(header);

	TMsvSmsEntry entry;

	entry.iType = KUidMsvMessageEntry;

	entry.SetVisible(EFalse);

	entry.SetInPreparation(ETrue);

	entry.SetReadOnly(EFalse);

	entry.SetUnread(ETrue);

	entry.SetSendingState(KMsvSendStateNotApplicable);

	TInt length = iSettings->DescriptionLength();

	HBufC* buf = HBufC::NewLC(length);

	TPtr description = buf->Des();	

	const CSmsEmailFields& fields = header->EmailFields();

	TBool isEmail = fields.HasAddress();

	TMsvId parentFolder = KMsvGlobalInBoxIndexEntryId;

	// Fix for INC17771: This defect meant that a message in the outbox, e.g. would be put into the inbox;

	// therefore, we check the status of the message to see what folder it should go into

	if( aMessage->Status() == NMobileSmsStore::EStoredMessageUnsent )

		parentFolder = KMsvGlobalOutBoxIndexEntryId;

	if( iBioMsgUID != KNullUid )

		{

		// BioficateEntry!!!

		// Set up all the needed ids

		TSmsUtilities::PopulateMsgEntry(entry, *aMessage, iBioServiceId, *iSettings, KUidBIOMessageTypeMtm);

		entry.iBioType = iBioMsgUID.iUid;

		// Look up and set the description

		TInt index;

		CBIODatabase* bioDB = CBIODatabase::NewLC(aEntry.Session().FileSession());

		bioDB->GetBioIndexWithMsgIDL(iBioMsgUID, index);

		description.Copy(bioDB->BifReader(index).Description().Left(length));

		entry.iDescription.Set(description);

		CleanupStack::PopAndDestroy(bioDB);

		}

	else

		{

		TSmsUtilities::PopulateMsgEntry(entry, *aMessage, iSmsServiceId, *iSettings);

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

			{

			// For an email SMS should only set the description to be the subject

			// if there is a subject.

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

			}

		else

			{

			// For normal SMS and for email SMS messages that do not have a 

			// subject field, the description is the begining part of the body.

			User::LeaveIfError(iGetDetDesc->GetDescription(*aMessage, description, length));

			entry.iDescription.Set(description);

			}

		TBool classDefined(EFalse);

		TSmsDataCodingScheme::TSmsClass classTemp(TSmsDataCodingScheme::ESmsClass0);

		if( aMessage->Type() == CSmsPDU::ESmsDeliver )

			{

            const CSmsDeliver& deliver = static_cast<const CSmsDeliver&>(aMessage->SmsPDU());

            entry.SetProtocolIdentifier(*deliver.ProtocolIdentifier());

			classDefined = deliver.Class(classTemp);

			if( aMessage->Storage() == CSmsMessage::ESmsSIMStorage)

				{

				// This is a class 2 message - store the new SMS message in the 

				// folder specified in the SMS service settings (if that folder

				// exists, other wise default to Inbox).

				if( CheckMessageExistsL(aEntry.Session(), iSettings->Class2Folder()) )

					parentFolder = iSettings->Class2Folder();

				}

            }

		entry.SetClass(classDefined, classTemp);

		// Check the Existing sms message for User Prompt indicator

		const RPointerArray<const CEmsInformationElement>&  emsElements= aMessage->GetEMSInformationElementsL();

		// Loop through the array checking for a user prompt indicator element

		TInt count = emsElements.Count();

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

			{

			if( emsElements[i]->Identifier() == CSmsInformationElement::ESmsEnhancedUserPromptIndicator )

				{

				entry.SetUserPromptIndicator(ETrue);

				break;

				}

			}

		}

	// Set the details

 	TInt detailsLen = KSmsDetailsLength;

  	if(isEmail)

		{

		detailsLen = fields.Addresses().MdcaPoint(0).Length();

		}   

  	RBuf details;

  	details.CleanupClosePushL() ;

  	details.CreateL(detailsLen);

	TInt err = KErrNone;

	if( isEmail )

		{

		// For an email SMS, details is taken from the address field.

		details.Copy(fields.Addresses().MdcaPoint(0));

		}

	else

		{

		// For normal SMS message details is taken from the info from destination

		// address in the PDU.

		err = iGetDetDesc->GetDetails(aEntry.Session().FileSession(), *aMessage, details);

		}

	if( err == KErrNone )

		entry.iDetails.Set(details);

	// Create the entry

	aEntry.SetEntryL(parentFolder);

	aEntry.CreateL(entry);

	aEntry.Session().CleanupEntryPushL(entry.Id());

	aEntry.SetEntryL(entry.Id());

	// Save the message

	CMsvStore* store = aEntry.EditStoreL();

	CleanupStack::PushL(store);

	// Save off the CSmsHdr

	header->StoreL(*store);

	// Save the body - create and fill a CRichText object.

	CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL();

	CleanupStack::PushL(paraFormatLayer);

	CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL();

	CleanupStack::PushL(charFormatLayer);

	CRichText* richText = CRichText::NewL(paraFormatLayer,charFormatLayer);

	CleanupStack::PushL(richText);

	TInt len= aMessage->Buffer().Length();

	HBufC* bufBody = HBufC::NewLC(len);

	TPtr bufBodyPtr = bufBody->Des();

	aMessage->Buffer().Extract(bufBodyPtr, 0, len);

	richText->InsertL(0, bufBodyPtr); 

	store->StoreBodyTextL(*richText);

	TBool foundSecureId(EFalse);

	TSecureId secureId;

	if (aCheckForSecureId)

		foundSecureId = CheckForSID(bufBodyPtr, secureId); // Check for SID

	CleanupStack::PopAndDestroy(4, paraFormatLayer); //bufBody, richText, charFormatLayer, paraFormatLayer

	store->CommitL();

	// Update the index...

	entry.SetReadOnly(ETrue);

	entry.SetVisible(Visible());

	entry.SetInPreparation(EFalse);

	entry.iSize = store->SizeL();

	if (foundSecureId)

		aEntry.ChangeL(entry, secureId);

	else

		aEntry.ChangeL(entry);