// 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 "gsmubuf.h"

#include "smspfacadestor.h"

/**

Static factory constructor. Uses two phase 

construction and leaves nothing on the CleanupStack.

@internalComponent

@return A pointer to the newly created CFacadeSmsReassemblyStore object.

@param aFs  File Server handle.

@param aSmsComm  Notification Event Reference.

@leave KErrNoMemory

@pre A connected file server session must be passed as parameter.

@post CFacadeSmsReassemblyStore object is now fully initialised

*/

CFacadeSmsReassemblyStore* CFacadeSmsReassemblyStore::NewL(RFs& aFs, MSmsComm& aSmsComm)

	{

	CFacadeSmsReassemblyStore*  self = new (ELeave) CFacadeSmsReassemblyStore(aFs, aSmsComm);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

 *  Constructor.

*/

CFacadeSmsReassemblyStore::CFacadeSmsReassemblyStore(RFs& aFs, MSmsComm& aSmsComm)

	:iFs(aFs), iSmsComm(aSmsComm), iReassemblyStore(NULL), iClass0ReassemblyStore(NULL)

	{

	// NOP

	}

/**

 *  Destructor. It destroys all the member variables.

*/

CFacadeSmsReassemblyStore::~CFacadeSmsReassemblyStore()

	{

	iReassemblyStore->Close();

	delete iReassemblyStore;

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->Close();

		delete iClass0ReassemblyStore;

		}

	}

/**

Second Phase construction. It creates re-assembly stores. If SMS stack is configured

for handling class 0 messages in out-of-disk condition. It creates class 0 

& non-class 0 re-assembly store. Otherwise it creates only one re-assembly store

which will be used to store all type of SMS messages.

@internalComponent

@leave KErrNoMemory

@pre A connected file server session must be passed as parameter.

@post CFacadeSmsReassemblyStore object is now fully constructed.

*/

void CFacadeSmsReassemblyStore::ConstructL()

	{

	iReassemblyStore = CSmsReassemblyStore::NewL(iFs);

	/*

	Read [ReassemblyStore] section from smswap.sms.esk file. If section is absent then there is

	no need to create class 0 re-assembly store. This sms stack is configured to work

	as before (class 0 message will be -vely ack in out-of-disk condition).

	If ReassemblyStore section is present then read the value of Class0.

	If the value of Class0 is 1. Then create class 0 re-assembly store object.

	For example:

	[ReassemblyStore]

	Class0= 1

	MaxClass0Messages=10

	NumberOfPDUSegements=20

	GuardTimeOut=12

	*/

	CESockIniData*  ini = NULL;

	ini=CESockIniData::NewL(_L("smswap.sms.esk"));

	CleanupStack::PushL(ini);

	TBool status(EFalse);

	if (ini->FindVar(_L("ReassemblyStore"), _L("Class0"), status))

		{

		if (status)

			{

			iClass0ReassemblyStore = CClass0SmsReassemblyStore::NewL(iFs, iSmsComm);

			}

		}

	// Set the default value for iMaxmumNumberOfCompleteMessagesInReassemblyStore.

	iMaxmumNumberOfCompleteMessagesInReassemblyStore = KDefaultMaxmumNumberOfCompleteMessagesInReassemblyStore;

	// Load up the user configurable setting for the maximum number of complete messages in 

	// the reassembly store.

	TPtrC value;

	if((ini->FindVar(_L("ReasmemblyStoreOptions"),_L("MaxNumOfComMessInReStore"),value)))

		{

		TLex16 valueconv(value);

		valueconv.Val(iMaxmumNumberOfCompleteMessagesInReassemblyStore); 

		}

	CleanupStack::PopAndDestroy(ini);

	}

/**

It open the re-assembly stores.

This function needs to be called before doing any operations (add/delete/update) in the 

re-assembly stores.

@internalComponent

*/

void CFacadeSmsReassemblyStore::OpenStoreL()

	{

	iReassemblyStore->OpenStoreL();

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->OpenStoreL();

		}

	}

/**

It closes the re-assembly stores.

@internalComponent

*/

void CFacadeSmsReassemblyStore::Close()

	{

	// Close general Re-assembly store.

	iReassemblyStore->Close();

	// Close Class0 re-assembly store.

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->Close();

		}

	}

/**

It returns the file session.

@internalComponent

@return returns the file session.

*/

RFs& CFacadeSmsReassemblyStore::FileSession() const

	{

	return iFs;

	}

/**

It initializes the re-assembly store.

It goes through all the entries in re-assembly store. It updates its header information.

If any sms message is either SIM based or combined storage based then it is deleted from re-assembly store.

For other type of SMS messages, its header info is updated to indicate that it is not passed to client.

This initialization process is required because SMS stack might have been re-started.

@internalComponent

*/

void CFacadeSmsReassemblyStore::InitL()

	{

	// Initialize Non-class 0 Re-assembly store.

	InitializeNonClass0StoreL();

	// Initialize Class0 re-assembly store.

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->InitializeL();

		}

	}

/**

Purges the reassembly file stores.

@param aTimeIntervalMinutes Purge time

@param aPurgeIncompleteOnly Purge complete messages flag

@internalComponent

*/

void CFacadeSmsReassemblyStore::PurgeL(const TTimeIntervalMinutes& aTimeIntervalMinutes,TBool aPurgeIncompleteOnly)

	{

	iReassemblyStore->PurgeL(aTimeIntervalMinutes, aPurgeIncompleteOnly);

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->PurgeL(aTimeIntervalMinutes, aPurgeIncompleteOnly);

		}

	}

/**

It returns a boolean value indicating whether re-assembly store is full or not.

If number of complete sms messages exceed the configured value (KMaxmumNumberOfCompleteMessagesInReassemblyStore),

it return TRUE. Otherwise it returns FALSE.

@internalComponent

*/

TBool CFacadeSmsReassemblyStore::IsFull()

	{

	//local variable for complete entries

	TInt count( 0 );

	count = NumberOfCompleteNonClass0Messages();

	if (iClass0ReassemblyStore)

		{

		count += iClass0ReassemblyStore->NumberOfCompleteMessages();

		}

	if (count > iMaxmumNumberOfCompleteMessagesInReassemblyStore)

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/**

It deletes all the enumerated SIM messages stored in re-assembly store.

This function will be called if user choses to cancel the enumeration.

@internalComponent

*/

void CFacadeSmsReassemblyStore::DeleteEnumeratedSIMEntries()

	{

	DeleteNonClass0EnumeratedSIMEntries();

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->DeleteEnumeratedSIMEntries();

		}

	}

/**

It externalizes all the enumerated messages.

It goes through the re-assembly store and sends all those SMS messages 

(which is SIM/Combined storage based) to client (aSmsProvider).

@param aSmsProvider  a reference to a service access point.

@param aCount	number of sms messages enumerated.

@return number of new segments.

@internalComponent

*/

TInt CFacadeSmsReassemblyStore::ExternalizeEnumeratedMessagesL(CSmsProvider& aProvider,TInt& aCount)

	{

	TInt numNewSegments(0);

	numNewSegments = ExternalizeEnumeratedNonClass0SmsMessagesL(aProvider, aCount);

	if (iClass0ReassemblyStore)

		{

		numNewSegments += ExternalizeEnumeratedClass0SmsMessagesL(aProvider, aCount);

		}

	return numNewSegments;

	}

/**

It searches the reassembly store for complete messages and then it sends that 

message for further processing. It is called when a new observer is added or 

a PDU has been received and successfully processed.

@param aSmsComm  a reference to the protocol.

@param aCurrentSmsMessage	a pointer to current SMS message.

@internalComponent

*/

void CFacadeSmsReassemblyStore::ProcessCompleteSmsMessagesL(MSmsComm& aSmsComm, const CSmsMessage* aCurrentSmsMessage)

	{

	ProcessCompleteNonClass0SmsMessagesL(aSmsComm, aCurrentSmsMessage);

	if (iClass0ReassemblyStore)

		{

		ProcessCompleteClass0SmsMessagesL(aSmsComm, aCurrentSmsMessage);

		}

	}

/**

It adds the message segment to the reassembly store.

This function first checks on which re-assembly store the message should be stored and then add

the message to appropriate re-assembly store.

@note Only SUBMIT or DELIVER PDUs can be added to the reassembly store.

@param aSmsMessage  a reference to the SMS message.

	It acts both as input & output. At the time of function call it contains the message.

	When the function returns it contains full decoded message if it is complete.

	But in case of class 0 messages it might not contain complete class 0 messages.

@param aGsmSms	a reference to GsmSms object which contain actual PDU.

	It acts as pure input.

@param aIsComplete  boolean value indicating whether the message is complete or not.

	It acts both as input & output.

	In case of multi-segment message, the value of aIsComplete will be true when function returns 

	if the added segment makes the messsage complete.

@param aIsEnumeration	boolean value indicating whether the function is called at the time of enumeration.

	It acts as only input.

@param aCount  value indicating the number of current PDUs in the re-assembly store for the given SMS message.

	It acts as only output.

@param aTotal	value indicating the total number of PDUs for the given sms message.

	It acts as only output.

@internalComponent

NOTE:

	When function returns, if the value of aIsComplete is True, then aSmsMesssage will contain the

	complete decoded SMS message.

	But the above statement might not be always true:

	In case of class 0 messages, it is possible to forward the incomplete messages. So after forwarding

	the incomplete message, if we receive other constituent PDU of that message then in that case we 

	might receive all the constituent PDU of that message but aSmsMesssage will contain partial complete message.

	To find out complete/incompletness of the message, CSmsMessage::IsComplete() message function has to be called.

*/

void CFacadeSmsReassemblyStore::AddSegmentToReassemblyStoreL(CSmsMessage& aSmsMessage,const TGsmSms& aGsmSms, TInt& aIndex, TBool& aIsComplete, TBool aIsEnumeration, TInt& aCount, TInt& aTotal)

	{

	TBool toBeStoredInClass0ReassemblyStore = IsForClass0ReassemblyStore(aSmsMessage);

	if (toBeStoredInClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->AddSegmentToReassemblyStoreL(aSmsMessage, aGsmSms, aIndex, aIsComplete, aIsEnumeration, aCount, aTotal);

		}

	else

		{

		AddSegmentToNonClass0ReassemblyStoreL(aSmsMessage, aGsmSms, aIndex, aIsComplete, aIsEnumeration, aCount, aTotal);

		}

	}

/**

It forwards the complete class 0 messages to client.

NOTE:

	This function needs to be called only in case of class 0 messages.

@param aSmsComm  a reference to aSmsComm object which implemented the events.

@param aSmsMessage	a reference to sms message object. This sms message must be class 0 messages.

@param aOriginalSmsAddr pointer to the address of the sender of a previously sent

@param aOriginalSmsMessage pointer to a message previously sent matched to the received 

							one (e.g. status report).	Null if not matched.

@param aDes user data for the deliver report acknowledging this message to the SC.

			Filled in by the observer.

@internalComponent

*/

void CFacadeSmsReassemblyStore::ForwardCompleteClass0SmsMessagesL(MSmsComm& aSmsComm, const CSmsMessage& aSmsMessage,const TSmsAddr* aOriginalSmsAddr,const CSmsMessage* aOriginalSmsMessage,TDes& aDes)

	{

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->ForwardCompleteClass0SmsMessagesL(aSmsComm, aSmsMessage, aOriginalSmsAddr, aOriginalSmsMessage, aDes);

		}

	}

/**

It frees the space by forwarding the class 0 message if class 0 re-assembly store 

exceeds limitation (max class 0 message, max reserved pdu segment).

NOTE:

	This function needs to be called only in case of class 0 messages.

@param aSmsComm  a reference to aSmsComm object which implemented the events.

@internalComponent

*/

void CFacadeSmsReassemblyStore::ProcessMessageIfExceedLimitationL(MSmsComm& aSmsComm)

	{

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->ProcessMessageIfExceedLimitationL(aSmsComm);

		}

	}

/**

It sets the incomplete messsage forwarded to client.

Internally it frees up the memory by removing the forwarded PDUs and also it stores forwarded PDU index.

NOTE:

	This function needs to be called only in case of class 0 messages.

@param aSmsMessage	a reference to sms message object. This sms message must be class 0 messages.

@internalComponent

*/

void CFacadeSmsReassemblyStore::SetIncompleteMessageForwardedToClientL(const CSmsMessage& aSmsMessage)

	{

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->SetIncompleteMessageForwardedToClientL(aSmsMessage);

		}

	}

/**

It sets the disk space status.

If disk space is full, then class 0 re-assembly store stores the incoming message in

pre-allocated file. Otherwise it stores the message in permanent store file.

*/

void CFacadeSmsReassemblyStore::SetDiskSpaceState(TSmsDiskSpaceMonitorStatus aDiskSpaceStatus)

	{

	if (iClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->SetDiskSpaceState(aDiskSpaceStatus);

		}

	}

/**

It deletes the given SMS message from re-assembly store.

@param aSmsMessage  Message to delete.

@param aPassed      Determines if we are searching for a message already

					passed to the client.

@internalComponent

*/

void CFacadeSmsReassemblyStore::DeleteMessageL(const CSmsMessage& aSmsMessage, TBool aPassed)

	{

	TBool toBeStoredInClass0ReassemblyStore = IsForClass0ReassemblyStore(aSmsMessage);

	if (toBeStoredInClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->DeleteMessageL(aSmsMessage, aPassed);

		}

	else

		{

		DeleteNonClass0MessageL(aSmsMessage, aPassed);

		}

	}

/**

It updates log server id of the passed message in re-assembly store.

@param aSmsMessage  a reference to a message.

@param aIndex	index number of sms message to be updated.

@internalComponent

*/

void CFacadeSmsReassemblyStore::UpdateLogServerIdL(const CSmsMessage& aSmsMessage, TInt aIndex)

	{

	TBool toBeStoredInClass0ReassemblyStore = IsForClass0ReassemblyStore(aSmsMessage);

	if (toBeStoredInClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->UpdateLogServerIdOfMessageL(aSmsMessage, aIndex);

		}

	else

		{

		UpdateLogServerIdOfNonClass0MessageL(aSmsMessage, aIndex);

		}

	}

/**

It updates that the given SMS message in re-assembly store is passed to client.

@param aSmsMessage  Message which is passed to client.

@internalComponent

*/

void CFacadeSmsReassemblyStore::SetMessagePassedToClientL(const CSmsMessage& aSmsMessage, TBool aPassed)

	{

	TBool toBeStoredInClass0ReassemblyStore = IsForClass0ReassemblyStore(aSmsMessage);

	if (toBeStoredInClass0ReassemblyStore)

		{

		iClass0ReassemblyStore->SetMessagePassedToClientL(aSmsMessage, aPassed);

		}

	else

		{

		SetNonClass0MessagePassedToClientL(aSmsMessage, aPassed);

		}

	}

/**

Returns a boolean value indicating whether this class contains separate

re-assembly store for class 0 message or not.

@internalComponent

*/

TBool CFacadeSmsReassemblyStore::IsSeparateClass0StoreSupported()

	{

	if (iClass0ReassemblyStore)