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

//

/**

 @file

*/

#include "smspread.h"

#include "smspmain.h"

#include "smspproc.h"

#include "smspfacadestor.h"

#include "smsuset.h"

#include "smsulog.h"

#include "gsmubuf.h"

#include "Gsmumsg.h"

#include "smspcdb.h"

#include "SmsuTimer.h"

#include "exterror.h"

#include "es_ini.h"

#include <logwraplimits.h>

// Delay between sending NAK to TSY & posting Receive() SMS on ETel again

const TInt KWaitReadPduTime = 1000; // 1 millisecond

/**

 *  Creates new CSmsPDURead instance

 *  

 *  @param aSmsComm is used to complete read pdu reguest

 *  @param aSmsMessaging	used to set receive mode and start receive message

 */

CSmsPDURead* CSmsPDURead::NewL(MSmsComm& aSmsComm,

								const TSmsSettings& aSmsSettings,

								RMobileSmsMessaging& aSmsMessaging,

								CFacadeSmsReassemblyStore& aReassemblyStore,

								CSmsSegmentationStore& aSegmentationStore,

								const RMobileSmsMessaging::TMobileSmsCapsV1& aMobileSmsCaps,

								TInt aPriority,

								CSmspReceiveMode& aSmspReceiveMode,

								CSmsMonitorDiskSpace& aSmsMonitorDiskSpace)

    {

	CSmsPDURead* smsPduRead = new (ELeave) CSmsPDURead(aSmsComm,

													   aSmsSettings,

													   aSmsMessaging,

													   aReassemblyStore,

													   aSegmentationStore,

													   aMobileSmsCaps,

													   aPriority,

													   aSmspReceiveMode,

													   aSmsMonitorDiskSpace);

	CleanupStack::PushL(smsPduRead);

	smsPduRead->ConstructL();

	CleanupStack::Pop(smsPduRead);

	return smsPduRead;

    } // CSmsPDURead::NewL

void CSmsPDURead::ConstructL()

	{

	ConstructTimeoutL();

	User::LeaveIfError(iOOMTimer.CreateLocal());

	iLogger = CSmsPDUReadLogger::NewL(iReassemblyStore.FileSession(), Priority());

	ReadConfigurableSmsSettingsL();

	} // CSmsPDURead::ConstructL

/**

 *  Constructor

 *  Adds CSmsPDURead object to the Active Scheduler

 *  

 *  @param aSmsComm is used to complete read pdu reguest

 *  @param aSmsMessaging	used to set receive mode and start receive message

 *  @param aReassemblyStore used to set CSmsPDUProcess

 *  @param aSegmentationStore used to set CSmsPDUProcess

 *  @param aMobileSmsCaps used to set iMobileSmsCaps

 *  @param aPriority used to set CSmsPDUProcess

 *  @param aSmspReceiveMode used to set iReceiveMode

 *  @param aSmsMonitorDiskSpace used to set iSmsMonitorDiskSpace

 */

CSmsPDURead::CSmsPDURead(MSmsComm& aSmsComm,

						 const TSmsSettings& aSmsSettings,

						 RMobileSmsMessaging& aSmsMessaging,

						 CFacadeSmsReassemblyStore& aReassemblyStore,

						 CSmsSegmentationStore& aSegmentationStore,

						 const RMobileSmsMessaging::TMobileSmsCapsV1& aMobileSmsCaps,

						 TInt aPriority,

						 CSmspReceiveMode& aSmspReceiveMode,

						 CSmsMonitorDiskSpace& aSmsMonitorDiskSpace)

  : CSmsuActiveBase(aPriority),

	iState(ESmsPDUReadIdle),

	iSmsMessaging(aSmsMessaging),

	iMsgReceiveAttributesPckg(iMsgReceiveAttributes),

	iSmsComm(aSmsComm),

	iSmsSettings(aSmsSettings),

	iReassemblyStore(aReassemblyStore),

	iSegmentationStore(aSegmentationStore),

	iMobileSmsCaps(aMobileSmsCaps),

	iReceiveMode(aSmspReceiveMode),

	iSmsMonitorDiskSpace(aSmsMonitorDiskSpace)

	{

	} // CSmsPDURead::CSmsPDURead

/**

 *  Called by CSmsProtocol to start CSmsStoreRead active object

 *  Issues a Receive to the TSY

 */

void CSmsPDURead::Start()

    {

	if (IsSupported()  &&  IsActive() == EFalse  &&  iReassemblyStore.IsFull() == EFalse)

		{

		iState = ESmsPDUReadSetReceiveMode;

		iReceiveMode.Start(iStatus);

		SetActive();

		}

    } // CSmsPDURead::Start

void CSmsPDURead::ProcessPDUL()

	{

	//

	// Initilse the Slot location data...

	//

	iSlot.iIndex         = iMsgReceiveAttributes.iStoreIndex;

	iSlot.iStore         = iMsgReceiveAttributes.iStore;

	iSlot.iMsgData       = iMsgData;

	iSlot.iMsgStatus     = RMobileSmsStore::EStoredMessageUnread;

	iSlot.iServiceCentre = iMsgReceiveAttributes.iGsmServiceCentre;

	//

	// Initialise the PDU processor class...

	//

	delete iPduProcessor;

	iPduProcessor = NULL;

	iPduProcessor = CSmsPDUProcessor::NewL(iSmsComm, iSmsSettings,

										   iReassemblyStore, iSegmentationStore,

										   iSmsMonitorDiskSpace);

	iPduProcessor->SetApplyAutoDeletionToClass2(iConfigAutomaticDeletionForClass2);

	iPduProcessor->SetDiscardType0Class0(iConfigDiscardingType0Class0);

	iPduProcessor->SetDiscardType0Class2(iConfigDiscardingType0Class2);

	TRAPD(decodeError, iPduProcessor->DecodeAndProcessPDUL(iSlot, EFalse));

	iStatus = decodeError;

	//

	// If the PDU cannot be decoded, and this was not due to memory or disk

	// space problems, then get rid of it...

	//

	if (iStatus != KErrNone  &&  iStatus != KErrNoMemory  &&  iStatus != KErrDiskFull)

		{

		iPduProcessor->DeletePDUL();

		}

	//

	// Send ACK or NACK delivery report (depends on iState and iError)...

	//

	SendDeliverReport();

	} // CSmsPDURead::ProcessPDUL

/**

 *  Called by Active Scheduler to run this object

 *  State ESmsPDUSetReceiveMode:

 *  Calls private method Receive() to change state to ESmsPDUReadWaitingForPDU

 *  and start receive message

 *  State ESmsPDUReadWaitingForPDU:

 *  Calls method Complete to change state to ESmsPDUReadIdle and complete message receive

 *  

 *  @leave Leaves if there was an error

 *  @leave Panic if complete is called while state is ESmsStoreReadIdle

 */

void CSmsPDURead::DoRunL()

    {

	//

	// Handle state changes only for successful operations. Any errors will be

	// handled when Complete() is called following this DoRunL() call.

	// Complete() is not called if the object becomes active.

	//

    switch (iState)

        {

        case ESmsPDUReadSetReceiveMode:

            {

			if (iStatus.Int() == KErrNone)

				{

	            ResumeSmsReception();

	            }

            }

            break;

        case ESmsPDUReadResumeReception:

            {

			if (iStatus.Int() == KErrNone)

				{

    	        Receive();

    	        }

	        }

            break;

        case ESmsPDUReadWaitingForPDU:

            {

			if (iStatus.Int() == KErrNone)

				{

	            ProcessPDUL();

	            }

            }

            break;

        case ESmsPDUReadAcceptValidPduSendPositiveAck:

            {

			if (iStatus.Int() == KErrNone)

				{

	            AddLogEvent();

	            }

            }

            break;

        case ESmsPDUReadLogging:

            {

			if (iStatus.Int() == KErrNone)

				{

	            iPduProcessor->UpdateLogServerIdL();

				}

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

 				(iStatus.Int() == -KErrNotSupported))

 				{				

    	        iPduProcessor->ProcessMessageIfCompleteL();

    	        }

            }

            break;

        case ESmsPDUReadSystemOutOfMemorySendNegativeAck:

            {

			if (iStatus.Int() == KErrNone)

				{

        	    iState = ESmsPDUWaitTimerAfterOOM;

            	iOOMTimer.After(iStatus,KWaitReadPduTime);

            	SetActive();

            	}

            }

            break;

        case ESmsPDUWaitTimerAfterOOM:

            {

			if (iStatus.Int() == KErrNone)

				{

	            Receive();

	            }

            }

            break;

        case ESmsPDUReadInvalidPDUSendNegativeAck:

        case ESmsPDUReadAbsorbInvalidPduSendPositiveAck:

   		case ESmsPDUReadAbsorbValidPduSendPositiveAck:

            {

            // NOP

            }

            break;

        default:

        	{

            SmspPanic(KSmspPanicUnexpectedState);

            }

            break;

        }

	//

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

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

	//

    } // CSmsPDURead::DoRunL

/**

 *  public method for starting receive message

 */

void CSmsPDURead::ResumeSmsReception()

    {

    if (!IsActive())

        {

		iDelayedResumeSmsReceptionRequired = EFalse;

		iSmsReceptionSupended = EFalse;

        iState = ESmsPDUReadResumeReception;

        iSmsMessaging.ResumeSmsReception( iStatus );

        SetActive();

        }

	else if (iSmsReceptionSupended)

		{

		//

		// We will need to save this for later...

		//

		iDelayedResumeSmsReceptionRequired = ETrue;

		}

    } // CSmsPDURead::ResumeSmsReception

/**

 *  private method for starting receive message

 */

void CSmsPDURead::Receive()

    {

	//

	// Check if we need to resume reception first. This may be required if a

	// previous attempt to resume could not be actioned.

	//

	if (iDelayedResumeSmsReceptionRequired)

		{

		ResumeSmsReception();

		}

	else

		{

		//

		// Clears message data buffer before passing reference to the phone side

		//

		RMobileSmsMessaging::TMobileSmsReceiveAttributesV1  empty;

		iMsgData.Zero();

		iMsgReceiveAttributes = empty;

		//

		// Receive a message...

		//

    	iState = ESmsPDUReadWaitingForPDU;

		iSmsMessaging.ReceiveMessage( iStatus, iMsgData, iMsgReceiveAttributesPckg );

		SetActive();

	   	}

    } // CSmsPDURead::Receive

/**

 *  Cancels CSmsPDURead object

 *  Cancels reveive message

 *  Completes CSmsPDURead object

 */

void CSmsPDURead::DoCancel()

    {

	TimedSetActiveCancel();

	switch (iState)

		{

		case ESmsPDUReadResumeReception:

			{

 			iSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingResumeSmsReception);

			}

			break;

		case ESmsPDUReadSetReceiveMode:

			{

			iReceiveMode.Cancel();

			}

			break;

		case ESmsPDUReadWaitingForPDU:

			{

			iSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingReceiveMessage);

			}

			break;

		case ESmsPDUReadLogging:

			{

			iLogger->Cancel();

			}

			break;

		case ESmsPDUReadAcceptValidPduSendPositiveAck:

		case ESmsPDUReadAbsorbValidPduSendPositiveAck:

		case ESmsPDUReadAbsorbInvalidPduSendPositiveAck:

			{

 			iSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingAckSmsStored);

			}

			break;

		case ESmsPDUReadInvalidPDUSendNegativeAck:

		case ESmsPDUReadSystemOutOfMemorySendNegativeAck:

			{

 			iSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingNackSmsStored);

			}

			break;

		case ESmsPDUWaitTimerAfterOOM:

			{

			iOOMTimer.Cancel();

			}

			break;

		case ESmsPDUWaitingForDiskMonitor:

			{

			// NOP

			}

			break;

		default:

			{

			SmspPanic(KSmspPanicUnexpectedState);

			}

			break;

		};

	//

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

		}

    } // CSmsPDURead::DoCancel

void CSmsPDURead::AddLogEvent()

	{

	iState = ESmsPDUReadLogging;

	if (iPduProcessor->OriginalSmsMessage() == NULL)

		{

		iLogger->ChangeOrAddLogEvent(*iPduProcessor->SmsMessage(),

									 *iPduProcessor->SmsPDUData(), NULL, iStatus);

		}

	else

		{

		iPduProcessor->OriginalSmsMessage()->SetLogServerId(iPduProcessor->SmsMessage()->LogServerId());

        //If the original SMS TX log entry is to be updated because a

        // Status report has come in, pass as arguments both the orginal

        // TX SMS (*smsmessage) and the Status Report (contained in iSmsMessage).

        // This allows the discharge time in the Status Report to be logged.        

		CSmsMessage* pSmsMsg = iPduProcessor->SmsMessage();

	    CSmsStatusReport& statusReport = const_cast<CSmsStatusReport&>(static_cast<const CSmsStatusReport&>(pSmsMsg->SmsPDU()));

        TTime dischargeTime;

        TInt numQuarterHours = 0;

        statusReport.DischargeTime(dischargeTime, numQuarterHours);   

        iLogger->ChangeOrAddLogEvent(*(iPduProcessor->OriginalSmsMessage()), *iPduProcessor->SmsPDUData(), &dischargeTime,  iStatus);                	 		

		}

	SetActive();

	} // CSmsPDURead::AddLogEvent

void CSmsPDURead::DoEncodeDeliverReportL()

    {

    iDeliverReport.SetPdu(KNullDesC8);

    const TPtrC des(iPduProcessor->DeliverReportBuffer());

    CSmsBuffer* buffer = CSmsBuffer::NewL();

    CSmsMessage* smsMessage = CSmsMessage::NewL(iReassemblyStore.FileSession(), CSmsPDU::ESmsDeliverReport, buffer);

    CleanupStack::PushL(smsMessage);

    CSmsDeliverReport& deliverReport = ( CSmsDeliverReport& ) smsMessage->SmsPDU();

    switch(iState)

    {

        case ESmsPDUReadInvalidPDUSendNegativeAck:

        case ESmsPDUReadSystemOutOfMemorySendNegativeAck:

            {

            deliverReport.SetIsRPError(ETrue);

            const TInt failureCause = ErrorToTPError(iStatus.Int());

            deliverReport.SetFailureCause((TSmsFailureCause::TSmsFailureCauseError) failureCause);

            break;

            }

        case ESmsPDUReadAcceptValidPduSendPositiveAck:

        case ESmsPDUReadAbsorbInvalidPduSendPositiveAck:

       	case ESmsPDUReadAbsorbValidPduSendPositiveAck: