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

// Contains methods for all the PtrHolder classes used by the EtelMM

// subsessions.

// 

//

// From core API

#include <et_clsvr.h>

#include <etelext.h>

// Multimode header files

#include <etelmm.h>

#include <mmlist.h>

#include <mmretrieve.h>

#include "mm_hold.h"

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

//

//  RMobilePhoneStore

//

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

RMobilePhoneStore::RMobilePhoneStore()

	:iStorePtrHolder(NULL)

/** Constructor. */

	{

	}

EXPORT_C void RMobilePhoneStore::BaseConstruct(CMobilePhoneStorePtrHolder* aPtrHolder)

/**

@capability None

*/

	{

	iStorePtrHolder = aPtrHolder;

	}

EXPORT_C void RMobilePhoneStore::Destruct()

/** Standard destructor. 

@capability None

*/

	{

	delete iStorePtrHolder;

	iStorePtrHolder = NULL;

	ResetSessionHandle();

	}

RMobilePhoneStore::TMobilePhoneStoreEntryV1::TMobilePhoneStoreEntryV1()

:	iIndex(KIndexNotUsed)

	{

	iExtensionId = KETelExtMultimodeV1;

	}

void RMobilePhoneStore::TMobilePhoneStoreEntryV1::InternalizeL(RReadStream& aStream)

/**

 * This method internalizes the generic attributes of a store entry from a stream

 *

 * @param aStream The read stream containing the store entry

 */

	{

	TMultimodeType::InternalizeL(aStream);

	iIndex = aStream.ReadInt32L();

	}

void RMobilePhoneStore::TMobilePhoneStoreEntryV1::ExternalizeL(RWriteStream& aStream) const

/**

 * This method externalizes the generic attributes of a store entry into a stream

 *

 * @param aStream The write stream that will contain the store entry

 */

	{

	TMultimodeType::ExternalizeL(aStream);

	aStream.WriteInt32L(iIndex);

	}

EXPORT_C RMobilePhoneStore::TMobilePhoneStoreInfoV1::TMobilePhoneStoreInfoV1()

:	iType(EPhoneStoreTypeUnknown),

	iTotalEntries(-1),

	iUsedEntries(-1),

	iCaps(0)

	{

	iExtensionId=KETelMobilePhoneStoreV1;

	}

EXPORT_C void RMobilePhoneStore::GetInfo(TRequestStatus& aReqStatus, TDes8& aInfo) const

/** This member function gets information about the selected store.

This information includes the store's name, the type of thing it stores, the

total number of storage slots and the number of used slots. It does not give

information about which slots are filled and which are empty.

Defined in RMobilePhoneBookStore::TMobilePhoneStoreInfoV1::iExtensionId is

the type of class that is being used. See TMobilePhoneStoreInfoExtId for the

different possible types.

Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneStoreGetInfo) to cancel

a previously placed asynchronous GetInfo() request.

@param aReqStatus On return, KErrNone if successful.

@param aInfo On completion, a from RMobilePhoneBookStore::TMobilePhoneBookInfoV1

derived packaged class. 

@capability ReadUserData

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	Get(EMobilePhoneStoreGetInfo, aReqStatus, aInfo);

	}

EXPORT_C void RMobilePhoneStore::Read(TRequestStatus& aReqStatus, TDes8& aEntry) const

/** This overloaded member function reads the entry in the slot specified.

This member function is implemented using a TDes8 descriptor for aEntry so

that any kind of store entry can be read from any kind of store using this

common member function. For example, a client will have opened one of the

specialised store sub-sessions, e.g. RMobileONStore. The client will read

a store entry by packaging the specialised store's entry definition into its

associated packaged version. In the own number store example, the client will

have a RMobileONStore::TMobileONEntryV1 which it will put into a RMobileONStore::TMobileONEntryV1Pckg.

The packaged version will be passed to the Read() request.

This function has a specialised version in the RMobilePhoneBookStore

Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneStoreRead) to cancel

a previously placed asynchronous Read() request.

@param aReqStatus On return, KErrNone if successful, KErrNotFound if the slot

specified by iIndex is empty.

@param aEntry The iIndex field specifies what entry to read. On completion,

the entry data will be filled in. 

@capability ReadUserData

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	Get(EMobilePhoneStoreRead, aReqStatus, aEntry);

	}

EXPORT_C void RMobilePhoneStore::Write(TRequestStatus& aReqStatus, TDes8& aEntry)  const

/** This overloaded member function writes the entry into the store.

This member function is implemented using a TDes8 descriptor for aEntry so

that any kind of store entry can be read from any kind of store using this

common member function. For example, a client will have opened one of the

specialised store sub-sessions, eg. RMobileONStore. The client will read a

store entry by packaging the specialised store's entry definition into its

associated packaged version. In the own number store example, the client will

have a RMobileONStore::TMobileONEntryV1 which it will put into a RMobileONStore::TMobileONEntryV1Pckg.

The packaged version will be passed to the Write() request.

This function has a specialised version in the RMobilePhoneBookStore

Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneStoreWrite) to cancel

a previously placed asynchronous Write() request.

@param aReqStatus On return, KErrNone if successful.

@param aEntry The packaged entry to write in the store. If aEntry.index==-1

the TSY will store the entry in the first free location and then return this

location within aEntry.iIndex when it completes the request 

@capability WriteUserData

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	Get(EMobilePhoneStoreWrite, aReqStatus, aEntry);

	}

EXPORT_C void RMobilePhoneStore::Delete(TRequestStatus& aReqStatus, TInt aIndex)  const

/** This member function deletes the entry in the slot.

Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneStoreDelete) to cancel

a previously placed asynchronous Delete() request.

@param aReqStatus On return, KErrNone if successful, KErrNotFound if the slot

is empty

@param aIndex The slot entry to delete. 

@capability WriteUserData

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	iStorePtrHolder->iDeleteIndex=aIndex;

	TPtrC8& ptr1=iStorePtrHolder->SetC(CMobilePhoneStorePtrHolder::ESlot1Delete,iStorePtrHolder->iDeleteIndex);

	Set(EMobilePhoneStoreDelete, aReqStatus, ptr1);

	}

EXPORT_C void RMobilePhoneStore::DeleteAll(TRequestStatus& aReqStatus)  const

/** This member function deletes all the entries in the store.

Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneStoreDeleteAll) to

cancel a previously placed asynchronous DeleteAll() request.

@param aReqStatus On return, KErrNone if successful, KErrNotFound if the store

is empty 

@capability WriteUserData

*/

	{

	Blank(EMobilePhoneStoreDeleteAll, aReqStatus);

	}

EXPORT_C void RMobilePhoneStore::NotifyStoreEvent(TRequestStatus& aReqStatus, TUint32& aEvent, TInt& aIndex) const

/** This member functions allows a client to be notified when one or more of the

events occurs to the store.

These events allow a client to know the overall status of a store (full, empty

etc.) and also when a slot within a store changes. A slot could change because

another client or the phone has created, updated or deleted an entry.

Use RTelSubSessionBase::CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent)

to cancel a previously placed asynchronous NotifyStoreEvent() request.

@param aReqStatus On return, KErrNone if successful

@param aEvent On completion, the TMobileStoreEvent.

@param aIndex On completion, the index of the changed slot. If multiple entries

have been added or deleted then it will not be possible to return the indices

of these entries, so the TSY could trigger the KStoreDoRefresh event. 

@capability ReadUserData

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	TPtr8& ptr1=iStorePtrHolder->Set(CMobilePhoneStorePtrHolder::ESlot1NotifyStoreEvent,aEvent);

	TPtr8& ptr2=iStorePtrHolder->Set(CMobilePhoneStorePtrHolder::ESlot2NotifyStoreEvent,aIndex);

	Get(EMobilePhoneStoreNotifyStoreEvent, aReqStatus, ptr1, ptr2);

	}

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

//

//  RMobileSmsStore

//

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

EXPORT_C RMobileSmsStore::RMobileSmsStore()

/** Constructor */

	{

	}

EXPORT_C TInt RMobileSmsStore::Open(RMobileSmsMessaging& aMessaging, const TDesC& aStoreName)

/** This member function opens the message store.

@param aMessaging The Sms Messaging sub-session to use.

@param aStoreName Name of the store to open, the names of the stores can be

retrieved with RMobileSmsMessaging::GetMessageStoreInfo(). Must be one of

KETelMeSmsStore, KETelIccSmsStore, KETelCombinedSmsStore

@return KErrNone if successful.

@see RMobileSmsMessaging::GetMessageStoreInfo() 

@capability None

*/

	{

	RSessionBase* session=&aMessaging.SessionHandle();

	__ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle));

	TInt subSessionHandle=aMessaging.SubSessionHandle();

	__ASSERT_ALWAYS(subSessionHandle!=NULL,PanicClient(EEtelPanicNullHandle));

	TRAPD(ret,ConstructL());

	if (ret)

		return ret;

	TIpcArgs args(const_cast<TDesC*>(&aStoreName),TIpcArgs::ENothing,subSessionHandle);

	SetSessionHandle(*session);

	ret = CreateSubSession(*session,EEtelOpenFromSubSession,args);

	if (ret)

		Destruct();

	return ret;

	}

EXPORT_C void RMobileSmsStore::Close()

/** This member function closes a message store sub-session. 

@capability None

*/

 	{

	CloseSubSession(EEtelClose);

	Destruct();

	}

EXPORT_C void RMobileSmsStore::ConstructL()

/** Constructor. 

@capability None

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));

	CMobilePhoneStorePtrHolder* ptrHolder = CSmsStorePtrHolder::NewL(CSmsStorePtrHolder::EMaxNumberSmsStorePtrSlots,CSmsStorePtrHolder::EMaxNumberSmsStorePtrCSlots);

	RMobilePhoneStore::BaseConstruct(ptrHolder);

	}

RMobileSmsStore::TMobileSmsEntryV1::TMobileSmsEntryV1()

: iMsgStatus(EStoredMessageUnknownStatus)

	{

	iExtensionId=KETelExtMultimodeV1;

	}

void RMobileSmsStore::TMobileSmsEntryV1::InternalizeL(RReadStream& aStream)

/**

 * This method internalizes the SMS entry from a stream

 *

 * @param aStream The read stream containing the SMS fixed size entry

 */

	{

	TMobilePhoneStoreEntryV1::InternalizeL(aStream);

	iMsgStatus = static_cast<TMobileSmsStoreStatus>(aStream.ReadUint32L());

	}

void RMobileSmsStore::TMobileSmsEntryV1::ExternalizeL(RWriteStream& aStream) const

/**

 * This method externalizes the SMS entry into a stream

 *

 * @param aStream The write stream that will contain the SMS entry

 */

	{

	TMobilePhoneStoreEntryV1::ExternalizeL(aStream);

	aStream.WriteUint32L(iMsgStatus);

	}

EXPORT_C RMobileSmsStore::TMobileGsmSmsEntryV1::TMobileGsmSmsEntryV1()

	{

	iExtensionId=KETelMobileGsmSmsEntryV1;

	}

void RMobileSmsStore::TMobileGsmSmsEntryV1::InternalizeL(RReadStream& aStream)

/**

 * This method internalizes the SMS entry from a stream

 *

 * @param aStream The read stream containing the SMS fixed size entry

 */

	{

	TMobileSmsEntryV1::InternalizeL(aStream);

	aStream >> iServiceCentre;

	aStream >> iMsgData;

	}

void RMobileSmsStore::TMobileGsmSmsEntryV1::ExternalizeL(RWriteStream& aStream) const

/**

 * This method externalizes the SMS entry into a stream

 *

 * @param aStream The write stream that will contain the SMS entry

 */

	{

	TMobileSmsEntryV1::ExternalizeL(aStream);

	aStream << iServiceCentre;

	aStream << iMsgData;

	}

EXPORT_C RMobileSmsStore::TMobileCdmaSmsEntryV1::TMobileCdmaSmsEntryV1()

: iTeleservice(0), iServiceCategory(0)

	{

	iExtensionId=KETelMobileCdmaSmsEntryV1;

	}

void RMobileSmsStore::TMobileCdmaSmsEntryV1::InternalizeL(RReadStream& aStream)

/**

 * This method internalizes the SMS entry from a stream

 *

 * @param aStream The read stream containing the SMS fixed size entry

 */

	{

	TMobileSmsEntryV1::InternalizeL(aStream);

	iTeleservice = aStream.ReadInt32L();

	iServiceCategory = aStream.ReadInt32L();

	aStream >> iRemoteParty;

	aStream >> iMsgData;

	}

void RMobileSmsStore::TMobileCdmaSmsEntryV1::ExternalizeL(RWriteStream& aStream) const

/**

 * This method externalizes the SMS entry into a stream

 *

 * @param aStream The write stream that will contain the SMS entry

 */

	{

	TMobileSmsEntryV1::ExternalizeL(aStream);

	aStream.WriteInt32L(iTeleservice);

	aStream.WriteInt32L(iServiceCategory);

	aStream << iRemoteParty;

	aStream << iMsgData;

	}

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

//

//  RMobileNamStore

//

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

EXPORT_C RMobileNamStore::RMobileNamStore()

/** Constructor. */

	{

	}

EXPORT_C void RMobileNamStore::ConstructL()

/** Initializes and allocated the members of the RMobileNamStore object.

@leave KErrNoMemory Out of memory 

@capability None

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));

	CMobilePhoneStorePtrHolder* ptrHolder = CNamStorePtrHolder::NewL(CNamStorePtrHolder::EMaxNumberNamStorePtrSlots,CNamStorePtrHolder::EMaxNumberNamStorePtrCSlots);

	RMobilePhoneStore::BaseConstruct(ptrHolder);

	}

EXPORT_C TInt RMobileNamStore::Open(RMobilePhone& aPhone)

/** This member function opens a RMobileNamStore subsession from RMobilePhone.

@param aPhone The phone subsession to use.

@return KErrNone if successful, a system-wide error code if not. 

@capability None

*/

	{

	RSessionBase* session=&aPhone.SessionHandle();

	__ASSERT_ALWAYS(session!=NULL,PanicClient(EEtelPanicNullHandle));

	TInt subSessionHandle=aPhone.SubSessionHandle();

	__ASSERT_ALWAYS(subSessionHandle!=NULL,PanicClient(EEtelPanicNullHandle));

	TRAPD(ret,ConstructL());

	if (ret)

		return ret;

	TPtrC name(KETelNamStore);

	TIpcArgs args(&name,TIpcArgs::ENothing,subSessionHandle);

	SetSessionHandle(*session);

	ret = CreateSubSession(*session,EEtelOpenFromSubSession,args);

	if (ret)

		Destruct();

	return ret;

	}

EXPORT_C void RMobileNamStore::Close()

/** This member function closes a RMobileNamStore subsession. 

@capability None

*/

	{

	CloseSubSession(EEtelClose);

	Destruct();

	}

EXPORT_C RMobileNamStore::TMobileNamStoreInfoV1::TMobileNamStoreInfoV1()

:	iNamCount(0),

	iActiveNam(0)

	{

	iExtensionId=KETelMobileNamStoreV1;

	}

EXPORT_C void RMobileNamStore::SetActiveNam(TRequestStatus& aReqStatus, TInt aNamId) const

/** This member function sets a new value for the active NAM.

@param aReqStatus On return, KErrNone if successful, a system-wide error code

if not.

@param aNamId Specifies which NAM to activate. 

@capability WriteDeviceData

*/

	{

	__ASSERT_ALWAYS(iStorePtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));

	CNamStorePtrHolder* namStorePtrHolder = static_cast<CNamStorePtrHolder*>(iStorePtrHolder);

	namStorePtrHolder->iSetActiveNamNamId = aNamId;

	TPtrC8& ptr1=namStorePtrHolder->SetC(CNamStorePtrHolder::ESlot1SetActiveNam,namStorePtrHolder->iSetActiveNamNamId);

	Set(EMobileNamStoreSetActiveNam,aReqStatus,ptr1);

	}

EXPORT_C RMobileNamStore::TMobileNamEntryV1::TMobileNamEntryV1()

: 	iNamId(0),

	iParamIdentifier(0)

	{

	}

EXPORT_C RMobileNamStore::TMobileNamEntryV4::TMobileNamEntryV4()

: 	iNamId(0),

	iParamIdentifier(0)

	{

	iExtensionId = KETelExtMultimodeV4;

	}

void RMobileNamStore::TMobileNamEntryV1::InternalizeL(RReadStream& aStream)

/**

 * This method internalizes the NAM entry from a stream

 *

 * @param aStream The read stream containing the NAM entry

 */

	{

	TMobilePhoneStoreEntryV1::InternalizeL(aStream);

	iNamId = aStream.ReadInt32L();

	iParamIdentifier = aStream.ReadUint32L();

	aStream >> iData;

	}

void RMobileNamStore::TMobileNamEntryV1::ExternalizeL(RWriteStream& aStream) const

/**

 * This method externalizes the NAM entry into a stream

 *

 * @param aStream The write stream that will contain the NAM entry

 */

	{

	TMobilePhoneStoreEntryV1::ExternalizeL(aStream);

	aStream.WriteInt32L(iNamId);

	aStream.WriteUint32L(iParamIdentifier);

	aStream << iData;

	}

void RMobileNamStore::TMobileNamEntryV4::InternalizeL(RReadStream& aStream)

/**

 * This method internalizes the NAM entry from a stream

 *

 * @param aStream The read stream containing the NAM entry

 */

	{

	TMobilePhoneStoreEntryV1::InternalizeL(aStream);

	iNamId = aStream.ReadInt32L();

	iParamIdentifier = aStream.ReadInt32L();

	aStream >> iData;

	}

void RMobileNamStore::TMobileNamEntryV4::ExternalizeL(RWriteStream& aStream) const