// Copyright (c) 1997-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 "mmtsy.h"

#include "testdef.h"

#include "ETELMM.H"

#include <et_clsvr.h>

#include "Dmmlog.h"

CListReadAllAttempt* CListReadAllAttempt::NewL(RMobilePhone::TClientId* aId, TTsyReqHandle aReqHandle)

	{

	CListReadAllAttempt* read=new(ELeave) CListReadAllAttempt(aId, aReqHandle);

	CleanupStack::PushL(read);

	read->ConstructL();

	CleanupStack::Pop();

	return read;

	}

CListReadAllAttempt::CListReadAllAttempt(RMobilePhone::TClientId* aId, TTsyReqHandle aReqHandle)

	:CBase()

	{

	iClient.iSessionHandle=aId->iSessionHandle;

	iClient.iSubSessionHandle=aId->iSubSessionHandle;

	iReqHandle=aReqHandle;

	iListBuf = NULL;

	}

void CListReadAllAttempt::ConstructL()

	{

	}

CListReadAllAttempt::~CListReadAllAttempt()

	{

	delete iListBuf;

	}

/**************************************************************************/

//

//	CSmsStoreDMmTsy

//

/**************************************************************************/

CSmsStoreDMmTsy* CSmsStoreDMmTsy::NewL(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac,

									   const TDesC& aName)

	{

	CSmsStoreDMmTsy* subsession=new(ELeave) CSmsStoreDMmTsy(aPhone,aFac,aName);

	CleanupStack::PushL(subsession);

	subsession->ConstructL();

	CleanupStack::Pop();

	return subsession;

	}

void CSmsStoreDMmTsy::Init()

	{}

CSmsStoreDMmTsy::CSmsStoreDMmTsy(CPhoneDMmTsy *aPhone, CPhoneFactoryDummyBase* aFac,

								 const TDesC& aName)

	:CSubSessionExtDummyBase(aFac), iPhone(aPhone)

	{

	iSmsStoreName=aName;

	}

void CSmsStoreDMmTsy::ConstructL()

	{

	iSmsReadAll = new CArrayPtrFlat<CListReadAllAttempt>(1);

	LOGTEXT(_L8("CSmsStoreDMmTsy created"));

	}

CSmsStoreDMmTsy::~CSmsStoreDMmTsy()

	{

	for (TInt i=iSmsReadAll->Count()-1; i>=0; --i)

		{

		CListReadAllAttempt* ptr=iSmsReadAll->At(i);

		iSmsReadAll->Delete(i);

		delete ptr;

		}

	delete iSmsReadAll;

	LOGTEXT(_L8("CSmsStoreDMmTsy destroyed"));

	}

CTelObject* CSmsStoreDMmTsy::OpenNewObjectByNameL(const TDesC&)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject* CSmsStoreDMmTsy::OpenNewObjectL(TDes&)

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject::TReqMode CSmsStoreDMmTsy::ReqModeL(const TInt aIpc)

	{

	CTelObject::TReqMode ret=0;

	switch (aIpc)

		{

//

// Normal Services

//

//

// Flow Controlled Services

//

	case EMobilePhoneStoreRead:

	case EMobilePhoneStoreWrite:

	case EMobilePhoneStoreDelete:

	case EMobilePhoneStoreDeleteAll:

	case EMobilePhoneStoreReadAllPhase1:

	case EMobilePhoneStoreReadAllPhase2:

	case EMobilePhoneStoreGetInfo:

		ret=KReqModeFlowControlObeyed;

		break;

//

// Multiple Completion Services with Immediate Server Repost

// (Usually Notifications)

//

	case EMobilePhoneStoreNotifyStoreEvent:

		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

//

// Cancel Requests

//

	case EMobilePhoneStoreGetInfoCancel:

	case EMobilePhoneStoreReadCancel:

	case EMobilePhoneStoreWriteCancel:

	case EMobilePhoneStoreDeleteCancel:

	case EMobilePhoneStoreDeleteAllCancel:

	case EMobilePhoneStoreReadAllCancel:

	case EMobilePhoneStoreNotifyStoreEventCancel:

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return ret;

	}

TInt CSmsStoreDMmTsy::RegisterNotification(const TInt aIpc)

	{

	switch (aIpc)

		{

	case EMobilePhoneStoreNotifyStoreEvent:

		LOGTEXT(_L8("CSmsStoreDMmTsy: RegisterNotification - Store Event "));

		return KErrNone;

	default:

		// Unknown or invalid IPC

		LOGTEXT(_L8("CSmsStoreDMmTsy: Register error, unknown IPC"));

		return KErrNotSupported;

		}

	}

TInt CSmsStoreDMmTsy::DeregisterNotification(const TInt aIpc)

	{

	switch (aIpc)

		{

	case EMobilePhoneStoreNotifyStoreEvent:

		LOGTEXT(_L8("CSmsStoreDMmTsy: DeregisterNotification - Store Event "));

		return KErrNone;

	default:

		// Unknown or invalid IPC

		LOGTEXT(_L8("CSmsStoreDMmTsy: Deregister error, unknown IPC"));

		return KErrNotSupported;

		}

	}

TInt CSmsStoreDMmTsy::NumberOfSlotsL(const TInt aIpc)

	{

	TInt numberOfSlots=1;

	switch (aIpc)

		{

	case EMobilePhoneStoreNotifyStoreEvent:

		LOGTEXT(_L8("CSmsStoreDMmTsy: Registered with 10 slots"));

		numberOfSlots=10;

		break;

	default:

		// Unknown or invalid Phone IPC

		LOGTEXT(_L8("CSmsStoreDMmTsy: Number of Slots error, unknown IPC"));

		User::Leave(KErrNotSupported);

		break;

		}

	return numberOfSlots;

	}

TInt CSmsStoreDMmTsy::ExtFunc(const TTsyReqHandle aTsyReqHandle,const TInt aIpc,

							  const TDataPackage& aPackage)

	{

	TAny* dataPtr=aPackage.Ptr1();

	TAny* dataPtr2=aPackage.Ptr2();

	switch (aIpc)

		{

	case EMobilePhoneStoreRead:

		return Read(aTsyReqHandle, aPackage.Des1n());

	case EMobilePhoneStoreWrite:

		return Write(aTsyReqHandle, aPackage.Des1n());

	case EMobilePhoneStoreDelete:

		return Delete(aTsyReqHandle,

			REINTERPRET_CAST(TInt*,dataPtr));

	case EMobilePhoneStoreDeleteAll:

		return DeleteAll(aTsyReqHandle);

	case EMobilePhoneStoreGetInfo:

		return GetInfo(aTsyReqHandle,

			REINTERPRET_CAST(RMobilePhoneStore::TMobilePhoneStoreInfoV1*, dataPtr));

	case EMobilePhoneStoreReadAllPhase1:

		return ReadAllPhase1(aTsyReqHandle,

			REINTERPRET_CAST(CRetrieveMobilePhoneSmsList::TBatchRequestData*,dataPtr),

			REINTERPRET_CAST(TInt*,dataPtr2));

	case EMobilePhoneStoreReadAllPhase2:

		return ReadAllPhase2(aTsyReqHandle,

			REINTERPRET_CAST(RMobilePhone::TClientId*,dataPtr),aPackage.Des2n());

	case EMobilePhoneStoreNotifyStoreEvent:

		return NotifyStoreEvent(aTsyReqHandle,

			REINTERPRET_CAST(RMobilePhoneStore::TMobileStoreEvent*,dataPtr),

			REINTERPRET_CAST(TInt*,dataPtr2));

	default:

		return KErrNotSupported;

		}

	}

TInt CSmsStoreDMmTsy::CancelService(const TInt aIpc,const TTsyReqHandle aTsyReqHandle)

	{

	switch (aIpc)

		{

	case EMobilePhoneStoreGetInfo:

		return GetInfoCancel(aTsyReqHandle);

	case EMobilePhoneStoreRead:

		return ReadCancel(aTsyReqHandle);

	case EMobilePhoneStoreWrite:

		return WriteCancel(aTsyReqHandle);

	case EMobilePhoneStoreDelete:

		return DeleteCancel(aTsyReqHandle);

	case EMobilePhoneStoreDeleteAll:

		return DeleteAllCancel(aTsyReqHandle);

	case EMobilePhoneStoreReadAllPhase1:

	case EMobilePhoneStoreReadAllPhase2:

		return ReadAllCancel(aTsyReqHandle);

	case EMobilePhoneStoreNotifyStoreEvent:

		return NotifyStoreEventCancel(aTsyReqHandle);

		}

	return KErrGeneral;

	}

TInt CSmsStoreDMmTsy::Read(const TTsyReqHandle aTsyReqHandle, TDes8* aEntry)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::Read called"));

	RMobileSmsStore::TMobileGsmSmsEntryV1Pckg* entryPckg = (RMobileSmsStore::TMobileGsmSmsEntryV1Pckg*)aEntry;

	RMobileSmsStore::TMobileGsmSmsEntryV1& entry = (*entryPckg)();

	if (entry.iIndex!=DMMTSY_SMS_STORE_INDEX1)

		ReqCompleted(aTsyReqHandle,KErrCorrupt);

	else

		{

		entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU1;

		entry.iMsgStatus =DMMTSY_SMS_STORE_STATUS1;

		entry.iServiceCentre.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

		entry.iServiceCentre.iTypeOfNumber = DMMTSY_PHONE_TON;

		entry.iServiceCentre.iNumberPlan = DMMTSY_PHONE_NPI;

		iPhone->AddDelayedReq(aTsyReqHandle,this);

		}

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::ReadCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::ReadCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::Write(const TTsyReqHandle aTsyReqHandle, TDesC8* aEntry)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::Write called"));

	RMobileSmsStore::TMobileCdmaSmsEntryV1Pckg* entryPckg = (RMobileSmsStore::TMobileCdmaSmsEntryV1Pckg*)aEntry;

	RMobileSmsStore::TMobileCdmaSmsEntryV1& entry = (*entryPckg)();

	if ((entry.iIndex != DMMTSY_SMS_STORE_INDEX2) ||

		(entry.iMsgData.Compare(DMMTSY_SMS_MESSAGE_PDU2) != 0) ||

		(entry.iMsgStatus != DMMTSY_SMS_STORE_STATUS2) ||

		(entry.iRemoteParty.iTelNumber != DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER2) ||

		(entry.iTeleservice != DMMTSY_SMS_MESSAGE_TELESERVICE))

		ReqCompleted(aTsyReqHandle,KErrCorrupt);

	else

		iPhone->AddDelayedReq(aTsyReqHandle,this);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::WriteCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::WriteCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::Delete(const TTsyReqHandle aTsyReqHandle, TInt* aIndex)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::Delete called"));

	if (*aIndex!=DMMTSY_SMS_STORE_INDEX3)

		ReqCompleted(aTsyReqHandle,KErrCorrupt);

	else

		iPhone->AddDelayedReq(aTsyReqHandle,this);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::DeleteCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::DeleteCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::DeleteAll(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::DeleteAll called"));

	iPhone->AddDelayedReq(aTsyReqHandle,this);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::DeleteAllCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::DeleteAllCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::GetInfo(const TTsyReqHandle aTsyReqHandle, RMobilePhoneStore::TMobilePhoneStoreInfoV1* aInfo)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::GetInfo called"));

	aInfo->iName=DMMTSY_MESSAGE_STORE_NAME;

	aInfo->iType=DMMTSY_MESSAGE_STORE_TYPE;

	aInfo->iTotalEntries=DMMTSY_MESSAGE_STORE_TOTAL_ENTRIES;

	aInfo->iUsedEntries=DMMTSY_MESSAGE_STORE_USED_ENTRIES;

	aInfo->iCaps=DMMTSY_MESSAGE_STORE_CAPS;

	iPhone->AddDelayedReq(aTsyReqHandle,this);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::GetInfoCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::GetInfoCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::NotifyStoreEvent(const TTsyReqHandle aTsyReqHandle,

									   RMobilePhoneStore::TMobileStoreEvent *aEvent,

									   TInt* aIndex)

	{

	if (!iNotifyStoreEvent++)

		{

		LOGTEXT(_L8("CSmsStoreDMmTsy::NotifyStoreEvent called"));

		*aIndex=DMMTSY_SMS_STORE_INDEX4;

		*aEvent=DMMTSY_MESSAGE_STORE_EVENT;

		iPhone->AddDelayedReq(aTsyReqHandle,this);

		}

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::NotifyStoreEventCancel(const TTsyReqHandle aTsyReqHandle)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::NotifyStoreEventCancel called"));

	iPhone->RemoveDelayedReq(aTsyReqHandle);

	ReqCompleted(aTsyReqHandle,KErrCancel);

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::ReadAllPhase1(const TTsyReqHandle aTsyReqHandle, CRetrieveMobilePhoneSmsList::TBatchRequestData* aRequest, TInt* aBufSize)

	{

	LOGTEXT(_L8("CSmsStoreDMmTsy::ReadAllPhase1 called"));

	TInt ret=KErrNone;

	TInt leaveCode=KErrNone;

	if (aRequest->iBatchRequest)

		if ((aRequest->iBatchSize != DMMTSY_SMS_STORE_BATCH) ||

		    (aRequest->iStartIndex != DMMTSY_SMS_STORE_START))

			leaveCode = KErrCorrupt;

	if (leaveCode == KErrNone)

		{

		if (aRequest->iEntryType==DMMTSY_SMS_STORE_GSMENTRY_TYPE)

			{

			TRAP(leaveCode, ret=ProcessReadAllGsmPhase1L(aTsyReqHandle, &aRequest->iClient, aBufSize););

			}

		else

			{

			TRAP(leaveCode, ret=ProcessReadAllCdmaPhase1L(aTsyReqHandle, &aRequest->iClient, aBufSize););

			}

		}

	if (leaveCode != KErrNone)

		ReqCompleted(aTsyReqHandle,leaveCode);

	return ret;

	};

TInt CSmsStoreDMmTsy::ProcessReadAllGsmPhase1L(const TTsyReqHandle aTsyReqHandle,

											   RMobilePhone::TClientId* aId,

											   TInt* aBufSize)

	{

	// read the list, store its content and then return size of this buffer to client

	CMobilePhoneGsmSmsList* list=CMobilePhoneGsmSmsList::NewL();

	CleanupStack::PushL(list);

	RMobileSmsStore::TMobileGsmSmsEntryV1 entry;

	// fill up an example list

	for (TInt index=0; index < DMMTSY_SMS_STORE_COUNT; index++)

		{

		switch (index)

			{

		case 0:

			entry.iIndex = DMMTSY_SMS_STORE_INDEX1;

			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU1;

			entry.iServiceCentre.iTelNumber = DMMTSY_PHONE_TEL_NUMBER;

			entry.iServiceCentre.iTypeOfNumber = DMMTSY_PHONE_TON;

			entry.iServiceCentre.iNumberPlan = DMMTSY_PHONE_NPI;

			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS1;

			break;

		case 1:

			entry.iIndex = DMMTSY_SMS_STORE_INDEX2;

			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU2;

			entry.iServiceCentre.iTelNumber = DMMTSY_SMSP_STORE_SCA;

			entry.iServiceCentre.iTypeOfNumber = DMMTSY_PHONE_TON;

			entry.iServiceCentre.iNumberPlan = DMMTSY_PHONE_NPI;

			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS2;

			break;

		case 2:

			// No need to recopy other info parameters

			// as they are identical to the ones in case 1 for this test

			entry.iIndex=DMMTSY_SMS_STORE_INDEX3;

			break;

		case 3:

		default:

			// No need to recopy other info parameters

			// as they are identical to the ones in case 1 for this test

			entry.iIndex=DMMTSY_SMS_STORE_INDEX4;

			break;

			}

			// Add the entry into the list, at the next empty location

			list->AddEntryL(entry);

		}

	// Store the streamed list and the client ID

	CListReadAllAttempt* read=CListReadAllAttempt::NewL(aId, aTsyReqHandle);

	CleanupStack::PushL(read);

	read->iListBuf = list->StoreLC();

	CleanupStack::Pop(); // pop the CBufFlat allocated by StoreLC

	iSmsReadAll->AppendL(read);

	CleanupStack::Pop(); // pop the CListReadAllAttempt

	// return the CBufFlat’s size to client

	*aBufSize=(read->iListBuf)->Size();

	// Complete first phase of list retrieval

	iPhone->AddDelayedReq(aTsyReqHandle,this);

	CleanupStack::PopAndDestroy(); // pop&destroy list

	return KErrNone;

	}

TInt CSmsStoreDMmTsy::ProcessReadAllCdmaPhase1L(const TTsyReqHandle aTsyReqHandle,

											   RMobilePhone::TClientId* aId,

											   TInt* aBufSize)

	{

	// read the list, store its content and then return size of this buffer to client

	CMobilePhoneCdmaSmsList* list=CMobilePhoneCdmaSmsList::NewL();

	CleanupStack::PushL(list);

	RMobileSmsStore::TMobileCdmaSmsEntryV1 entry;

	// fill up an example list

	for (TInt index=0; index < DMMTSY_SMS_STORE_COUNT; index++)

		{

		switch (index)

			{

		case 0:

			entry.iIndex = DMMTSY_SMS_STORE_INDEX1;

			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU1;

			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS1;

			entry.iRemoteParty.iTelNumber = DMMTSY_SMS_MESSAGE_REMOTEPARTYNUMBER1;

			entry.iTeleservice = DMMTSY_SMS_MESSAGE_TELESERVICE;

			break;

		case 1:

			entry.iIndex = DMMTSY_SMS_STORE_INDEX2;

			entry.iMsgData = DMMTSY_SMS_MESSAGE_PDU2;

			entry.iMsgStatus = DMMTSY_SMS_STORE_STATUS2;

			break;

		case 2:

			// No need to recopy other info parameters

			// as they are identical to the ones in case 1 for this test

			entry.iIndex=DMMTSY_SMS_STORE_INDEX3;