// Copyright (c) 2003-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:
// Implements the SMS Store manipulation code.
//
//
/**
@file
*/
#include <mmlist.h>
#include <mmretrieve.h>
#include <testconfigfileparser.h>
#include "CSimSmsStore.h"
#include "csimsmsmess.h"
#include "Simlog.h"
#include "CSimTsyMode.h"
const TInt KSmsStoreGranularity=2;
const TInt KCorruptPDU=9999;
_LIT(KNullTelephoneNumber,"0");
CListReadAllAttempt* CListReadAllAttempt::NewL(RMobilePhone::TClientId& aId, TTsyReqHandle aReqHandle)
/**
* Standard two phase constructor.
* @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read.
* @param aReqHandle The TSY request handle of the client request associated with a two phase read.
* @return CListReadAllAttempt* The newly created object.
*/
{
CListReadAllAttempt* read=new(ELeave) CListReadAllAttempt(aId, aReqHandle);
CleanupStack::PushL(read);
read->ConstructL();
CleanupStack::Pop();
return read;
}
CListReadAllAttempt::CListReadAllAttempt(RMobilePhone::TClientId& aId, TTsyReqHandle aReqHandle)
: iListBuf(NULL),iReqHandle(aReqHandle)
/**
* Trivial first phase constructor.
* @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read.
* @param aReqHandle The TSY request handle of the client request associated with a two phase read.
*/
{
iClient.iSessionHandle=aId.iSessionHandle;
iClient.iSubSessionHandle=aId.iSubSessionHandle;
iReqHandle=aReqHandle;
iListBuf = NULL;
}
void CListReadAllAttempt::ConstructL()
/**
* Trivial second phase constructor.
*/
{
}
CListReadAllAttempt::~CListReadAllAttempt()
/**
* Trivial destructor.
*/
{
delete iListBuf;
}
//
// CSimSmsStore
//
void CSimSmsStore::ClosePhone(TAny* aObj)
/**
* A utility function for cleaning up the stack.
*/
{
((CObject*)aObj)->Close();
}
CSimSmsStore* CSimSmsStore::NewL(CSimSmsMessaging* aSimSmsMess, const TDesC8& aName, TInt aMaxNumSlots, CSimPhone* aPhone)
/**
* Standard two phase constructor.
* @param aSimSmsMess The SMS Messaging object from which this SMS Store was opened.
* @param aName The name of the created SMS Store.
* @param aMaxNumSlots The maximum number of slots in the SMS Store.
* @return CSimSmsStore* The newly created object.
*/
{
CSimSmsStore* store=new(ELeave) CSimSmsStore(aSimSmsMess, aPhone);
TCleanupItem newObjClose(ClosePhone,store);
CleanupStack::PushL(newObjClose);
store->ConstructL(aName,aMaxNumSlots);
CleanupStack::Pop();
return store;
}
CSimSmsStore::CSimSmsStore(CSimSmsMessaging* aSmsMess, CSimPhone* aPhone)
: iSmsMessaging(aSmsMess), iEvOutstandingReq(EFalse), iPhone(aPhone)
/**
* Trivial first phase constructor.
* @param aSimSmsMess The SMS Messaging object from which this SMS Store was opened.
*/
{}
void CSimSmsStore::ConstructL(const TDesC8& aName, TInt aMaxNumSlots)
/**
* Second phase constructor that allocates memory for the SMS store, batch read buffer and
* a delayed completion timer. The constructor also reads the individual and batch read
* delays from the configuration file.
*
* @param aName The name of the created SMS Store.
* @param aMaxNumSlots The maximum number of slots in the SMS Store.
*/
{
iGsmSmsStoreEntries=new(ELeave) RMobileSmsStore::TMobileGsmSmsEntryV1[aMaxNumSlots+1];//index 0 is not used
iSmsMaxNumSlots=aMaxNumSlots;
iSmsStoreName.Copy(aName);
iSmsReadAll=new(ELeave) CArrayPtrFlat<CListReadAllAttempt>(KSmsStoreGranularity);
LOGSMS1("Starting to parse SMS Store config parameters...");
iSmsIndividualPause=CfgFileSection()->ItemValue(KSmsStoreIndividualReqPause,KDefaultSmsStoreIndividualReqPause);
iSmsBatchPause=CfgFileSection()->ItemValue(KSmsStoreBatchReqPause,KDefaultSmsStoreBatchReqPause);
const CTestConfigItem* item0=NULL;
item0=CfgFileSection()->Item(KSmsPhoneStoreCaps,0);
if (item0)
{
TPtrC8 value0;
TInt ret0=CTestConfig::GetElement(item0->Value(),KStdDelimiter,0,value0);
if(ret0!=KErrNone)
{
LOGPARSERR("value0",ret0,0,&KSmsPhoneStoreCaps);
iSmsStoreCaps=KDefaultSmsPhoneStoreCaps+KDefaultSmsOnlySmsCaps;
}
else
{
TUint32 intValue;
TInt ret = AsciiToNum(value0, intValue);
if(ret!=KErrNone)
iSmsStoreCaps=KDefaultSmsPhoneStoreCaps+KDefaultSmsOnlySmsCaps;
else
iSmsStoreCaps = intValue+KDefaultSmsOnlySmsCaps;
}
}
else
iSmsStoreCaps=KDefaultSmsPhoneStoreCaps+KDefaultSmsOnlySmsCaps;
LOGSMS1("...Finished parsing SMS Store config parameters");
iTimer=CSimTimer::NewL(iSmsMessaging->iPhone);
iIncomingTimer=CSimTimer::NewL(iSmsMessaging->iPhone);
}
void CSimSmsStore::PopulateStoreFromConfigFile()
/**
* Populate the SMS Store from information in the configuration file. This is performed
* after the standard SMS Store construction in order to prevent reseting the configuation
* file accessor class' pointers while possibly multiple SMS Stores are created.
*
* The store entries comply to the following format:
* "SmsStoreEntry = <store name>, <slot number>, <entry status>, <pdu>"
*/
{
LOGSMS1("Starting reading SMS Store entries...");
TInt count=CfgFileSection()->ItemCount(KSmsStoreEntry);
const CTestConfigItem* item=NULL;
TInt ret=KErrNone;
for(TInt i=0;i<count;i++)
{
item=CfgFileSection()->Item(KSmsStoreEntry,i);
if(!item)
break;
TPtrC8 storeName;
ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,storeName);
if(ret!=KErrNone)
{
LOGPARSERR("storeName",ret,0,&KSmsStoreEntry);
continue;
}
if(storeName.MatchF(iSmsStoreName)!=0)
continue; // Not this store
TInt index,stat;
TPtrC8 pdu;
ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,index);
if((ret!=KErrNone)||(index>=iSmsMaxNumSlots))
{
LOGPARSERR("index",ret,1,&KSmsStoreEntry);
continue;
}
ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,stat);
if(ret!=KErrNone)
{
LOGPARSERR("stat",ret,2,&KSmsStoreEntry);
continue;
}
ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,pdu);
if(ret!=KErrNone)
{
LOGPARSERR("pdu",ret,3,&KSmsStoreEntry);
continue;
}
TPtrC8 sca;
ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,sca);
if(ret!=KErrNone)
{
LOGPARSERR("sca",ret,4,&KSmsStoreEntry);
continue;
}
iGsmSmsStoreEntries[index].iIndex=index;
iGsmSmsStoreEntries[index].iMsgStatus=(RMobileSmsStore::TMobileSmsStoreStatus)stat;
ConvertAsciiSms(pdu,iGsmSmsStoreEntries[index].iMsgData);
RecordSca(sca, index);
}
LOGSMS1("...Finished reading SMS Store entries");
}
void CSimSmsStore::RecordSca(const TDesC8& aAsciiAddr, TInt aIndex)
/**
* Used to set the sca number
*
*
* @param aAsciiSca Ascii representation of a telephone number such as the one found in the configuration file
* @param aType specifies whether aAsciiAddres should be used to fill in the sca or destination field of the smsp entry
* @param aIndex specifies at which index in the smsp list the number should be filled in
*/
{
if(aAsciiAddr.Length()>0)//only support for international numbers
{
iGsmSmsStoreEntries[aIndex].iServiceCentre.iNumberPlan=RMobilePhone::EIsdnNumberPlan;
iGsmSmsStoreEntries[aIndex].iServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;
iGsmSmsStoreEntries[aIndex].iServiceCentre.iTelNumber.Copy(aAsciiAddr);
}
}
CSimSmsStore::~CSimSmsStore()
/**
* Standard destructor. Any objects created by the ::ConstructL() function
* will be destroyed here.
*/
{
delete[] iGsmSmsStoreEntries;
if (iSmsReadAll)
{
iSmsReadAll->ResetAndDestroy();
delete iSmsReadAll;
}
delete iTimer;
delete iIncomingTimer;
}
#ifdef _DEBUG
void CSimSmsStore::LogRequest(TBool aEntering, TInt aIpc, TInt aError)
#else
void CSimSmsStore::LogRequest(TBool aEntering, TInt aIpc, TInt /*aError*/)
#endif
/**
* This method logs client requests to the t_reg.txt
* @param aEntering Tells if the request is entering into simtsy tsy or completing
* @param aIpc IPC number of request
* @param aError Error code that the request has
*/
{
TBuf8<64> ipcBuf;
switch (aIpc)
{
case EMobilePhoneStoreGetInfo:
ipcBuf = _L8("GetInfo");
break;
case EMobilePhoneStoreNotifyStoreEvent:
ipcBuf = _L8("NotifyStoreEvent");
break;
case EMobilePhoneStoreRead:
ipcBuf = _L8("Read");
break;
case EMobilePhoneStoreWrite:
ipcBuf = _L8("Write");
break;
case EMobilePhoneStoreDelete:
ipcBuf = _L8("Delete");
break;
case EMobilePhoneStoreReadAllPhase1:
ipcBuf = _L8("ReadAllPhase1");
break;
case EMobilePhoneStoreReadAllPhase2:
ipcBuf = _L8("ReadAllPhase2");
break;
case EMobilePhoneStoreDeleteAll:
ipcBuf = _L8("DeleteAll");
break;
default:
ipcBuf = _L8("OTHER");
break;
}
if (aEntering!=EFalse)
{
LOGSMS3(">>%d,CSimSmsStore::%S",aIpc, &ipcBuf );
}
else
{
LOGSMS4("<<%d,CSimSmsStore::%S with error %d",aIpc, &ipcBuf, aError);
}
}
TInt CSimSmsStore::ExtFunc(const TTsyReqHandle aReqHandle,const TInt aIpc, const TDataPackage& aPckg)
/**
* Dispatch function for all SMS Store requests.
* @param aReqHandle The TSY request handle for this request.
* @param aIpc The IPC number of this request.
* @param aPckg The parameter package related to this request.
* @return TInt The return error condition.
*/
{
// The following requests can be completed even if the completion of another request is pending.
TInt ret=KErrNone;//error is only used with LogRequest when at the end of ExtFunc
LogRequest(ETrue, aIpc, ret);
switch(aIpc)
{
case EMobilePhoneStoreGetInfo:
ret = GetInfo(aReqHandle,aPckg.Des1n());
LogRequest(EFalse, aIpc, ret);
return ret;
case EMobilePhoneStoreNotifyStoreEvent:
ret = NotifyStoreEvent(aReqHandle,aPckg.Des1n(),aPckg.Des2n());
LogRequest(EFalse, aIpc, ret);
return ret;
default:
break;
}
// The TSY can only process one of the following requests at a time. If a second is received
// while processing the first, then it will be errored with KErrInUse. This restriction will
// be removed later, by inserting a request queuing mechanism. Note that the standard TSY
// "flow control" mechanism works phone-wide and so is not suitable.
if(iTimer->IsActive())
{
ReqCompleted(aReqHandle,KErrInUse);
return KErrNone;
}
switch(aIpc)
{
case EMobilePhoneStoreRead:
ret = Read(aReqHandle,aPckg.Des1n());
break;
case EMobilePhoneStoreWrite:
ret = Write(aReqHandle,aPckg.Des1n());
break;
case EMobilePhoneStoreDelete:
ret = Delete(aReqHandle,aPckg.Des1n());
break;
case EMobilePhoneStoreReadAllPhase1:
ret = ReadAllPhase1(aReqHandle,aPckg.Des1n(),aPckg.Des2n());
break;
case EMobilePhoneStoreReadAllPhase2:
ret = ReadAllPhase2(aReqHandle,aPckg.Des1n(),aPckg.Des2n());
break;
case EMobilePhoneStoreDeleteAll:
ret = DeleteAll(aReqHandle);
break;
default:
return KErrNotSupported;
}
LogRequest(EFalse, aIpc, ret);
return ret;
}
CTelObject* CSimSmsStore::OpenNewObjectByNameL(const TDesC& /*aName*/)
/**
* The API does not support any objects that could be opened from this one.
*/
{
User::Leave(KErrNotSupported);
return NULL;
}
CTelObject* CSimSmsStore::OpenNewObjectL(TDes&)
/**
* The API does not support any objects that could be opened from this one.
*/
{
User::Leave(KErrNotSupported);
return NULL;
}
CTelObject::TReqMode CSimSmsStore::ReqModeL(const TInt aIpc)
/**
* This function returns the Request Mode for the request with the passed IPC value.
* @param aIpc The IPC number of the request.
* @return TReqMode The request mode.
*/
{
CTelObject::TReqMode ret=0;
switch(aIpc)
{
case EMobilePhoneStoreGetInfo:
case EMobilePhoneStoreRead:
case EMobilePhoneStoreWrite:
case EMobilePhoneStoreDelete:
case EMobilePhoneStoreReadAllPhase1:
case EMobilePhoneStoreReadAllPhase2:
case EMobilePhoneStoreDeleteAll:
break;
case EMobilePhoneStoreNotifyStoreEvent:
ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
break;
default:
User::Leave(KErrNotSupported);
break;
}
return ret;
}
TInt CSimSmsStore::RegisterNotification(const TInt /*aIpc*/)
/**
* The ETel Server calls this function when the first client makes a notification
* request. If supported by the underlying protocol controlling the
* signalling stack, this can be used to start requesting updates for the relevant
* service.
*/
{
return KErrNone;
}
TInt CSimSmsStore::DeregisterNotification(const TInt /*aIpc*/)
/**
* The ETel Server calls this function when the last client that had previously
* made a notification request closes its ETel Server handle. If supported by
* the underlying protocol controlling the signalling stack, this can be used
* to stop requesting updates for the relevant service.
*/
{
return KErrNone;
}
TInt CSimSmsStore::NumberOfSlotsL(const TInt /*aIpc*/)
/**
* Return the number of slots that the ETel Server should allocate for buffering requests
* of the given IPC number.
*/
{
return KDefaultNumberOfSlots;
}
TInt CSimSmsStore::CancelService(const TInt aIpc,const TTsyReqHandle /*aTsyReqHandle*/)
/**
* Cancel an outstanding request.
* @param aIpc The IPC number of the request that is to be cancelled.
* @param aTsyReqHandle The TSY request handle of the request that is to be cancelled.
* @param TInt Standard return value.
*/
{
switch(aIpc)
{
case EMobilePhoneStoreGetInfo:
case EMobilePhoneStoreRead:
case EMobilePhoneStoreWrite:
case EMobilePhoneStoreDelete:
if(iTimer->Running())
{
iTimer->Cancel();
ReqCompleted(iPendingReqCompletion,KErrCancel);
}
break;
case EMobilePhoneStoreReadAllPhase1:
ReadAllCancel();
break;
case EMobilePhoneStoreDeleteAll:
DeleteAllCancel();
break;
case EMobilePhoneStoreNotifyStoreEvent:
NotifyStoreEventCancel();
break;
default:
break;
}
return KErrNone;
}
void CSimSmsStore::Init()
/**
* This function can be used to perform any necessary synchronous initialisation.
*/
{
}
TInt CSimSmsStore::GetInfo(TTsyReqHandle aReqHandle, TDes8* aPckg)
/**
* Retrieve SMS Store information. This request is completed immediately, as it is assumed
* that in a real TSY, all this data will be cached in the TSY.
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg The parameter package associated with this request.
*/
{
RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg* getInfoPckg=(RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*)aPckg;
RMobilePhoneStore::TMobilePhoneStoreInfoV1& getInfo=(*getInfoPckg)();
// Check that the data structure is supported by the simulated TSY version
TInt err = iPhone->CheckSimTsyVersion(getInfo);
if(err != KErrNone)
{
ReqCompleted(aReqHandle, err);
return KErrNone;
}
getInfo.iType=RMobilePhoneStore::EShortMessageStore;
getInfo.iTotalEntries=MaxSlots();
getInfo.iCaps=iSmsStoreCaps;
getInfo.iName.Copy(iSmsStoreName);
getInfo.iUsedEntries=UsedEntries();
ReqCompleted(aReqHandle,KErrNone);
return KErrNone;
}
TInt CSimSmsStore::Read(TTsyReqHandle aReqHandle, TDes8* aPckg)
/**
* Read a single SMS store entry. The completion of this request is delayed in order to
* simulate a real TSY that would have to go and get the information from a SIM card.
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg The parameter package associated with this request.
*/
{
if (!(iSmsStoreCaps & RMobilePhoneStore::KCapsIndividualEntry && iSmsStoreCaps & RMobilePhoneStore::KCapsReadAccess))
{
ReqCompleted(aReqHandle, KErrAccessDenied);
return KErrNone;
}
RMobileSmsStore::TMobileSmsEntryV1Pckg* smsPckg=(RMobileSmsStore::TMobileSmsEntryV1Pckg*)aPckg;
RMobileSmsStore::TMobileSmsEntryV1& sms=(*smsPckg)();
// Check that the data structure is supported by the simulated TSY version
TInt err = iPhone->CheckSimTsyVersion(sms);
if(err != KErrNone)
{
ReqCompleted(aReqHandle, err);
return KErrNone;
}
switch (sms.ExtensionId())
{
case RMobileSmsStore::KETelMobileGsmSmsEntryV1:
{
RMobileSmsStore::TMobileGsmSmsEntryV1Pckg* gsmSmsPckg=(RMobileSmsStore::TMobileGsmSmsEntryV1Pckg*)aPckg;
RMobileSmsStore::TMobileGsmSmsEntryV1& gsmSms=(*gsmSmsPckg)();
// Check that the data structure is supported by the simulated TSY version
TInt err = iPhone->CheckSimTsyVersion(gsmSms);
if(err != KErrNone)
{
ReqCompleted(aReqHandle, err);
return KErrNone;
}
TInt& index=gsmSms.iIndex;
if((index<1)||(index>iSmsMaxNumSlots))
{
ReqCompleted(aReqHandle,KErrArgument);
return KErrNone;
}
if (iGsmSmsStoreEntries[index].iMsgStatus == KCorruptPDU)
{
ReqCompleted(aReqHandle,KErrCorrupt);
return KErrNone;
}
if(iGsmSmsStoreEntries[index].iMsgData.Length()==0)
{
ReqCompleted(aReqHandle, KErrNotFound);
return KErrNone;
}
gsmSms.iMsgData.Copy(iGsmSmsStoreEntries[index].iMsgData);
gsmSms.iMsgStatus=iGsmSmsStoreEntries[index].iMsgStatus;
gsmSms.iServiceCentre=iGsmSmsStoreEntries[index].iServiceCentre;
break;
}
case RMobileSmsStore::KETelMobileCdmaSmsEntryV1:
ReqCompleted(aReqHandle,KErrNotSupported);
return KErrNone;
default:
ReqCompleted(aReqHandle,KErrArgument);
return KErrNone;
}
DelayCompletion(iSmsIndividualPause,aReqHandle);
return KErrNone;
}
TInt CSimSmsStore::Write(TTsyReqHandle aReqHandle,TDes8* aPckg)
/**
* Write a single SMS store entry. The completion of this request is delayed in order to
* simulate a real TSY that would have to write the information to a SIM card. A store
* event may be triggered by this request.
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg The parameter package associated with this request.
*/
{
if (!(iSmsStoreCaps & RMobilePhoneStore::KCapsIndividualEntry && iSmsStoreCaps & RMobilePhoneStore::KCapsWriteAccess))
{
ReqCompleted(aReqHandle, KErrAccessDenied);
return KErrNone;
}
TStoreEvent event=EStoreEventNoEvent;
TInt index;
RMobileSmsStore::TMobileSmsEntryV1Pckg* smsPckg=(RMobileSmsStore::TMobileSmsEntryV1Pckg*)aPckg;
RMobileSmsStore::TMobileSmsEntryV1& sms=(*smsPckg)();
// Check that the data structure is supported by the simulated TSY version
TInt err = iPhone->CheckSimTsyVersion(sms);
if(err != KErrNone)
{
ReqCompleted(aReqHandle, err);
return KErrNone;
}
switch (sms.ExtensionId())
{
case RMobileSmsStore::KETelMobileGsmSmsEntryV1:
{
RMobileSmsStore::TMobileGsmSmsEntryV1Pckg* gsmSmsPckg=(RMobileSmsStore::TMobileGsmSmsEntryV1Pckg*)aPckg;
RMobileSmsStore::TMobileGsmSmsEntryV1& gsmSms=(*gsmSmsPckg)();
// Check that the data structure is supported by the simulated TSY version
TInt err = iPhone->CheckSimTsyVersion(gsmSms);
if(err != KErrNone)
{
ReqCompleted(aReqHandle, err);
return KErrNone;
}
index=gsmSms.iIndex;
if(index==-1)//check the 1st free slot
{
for(TInt i=1;i<=iSmsMaxNumSlots;i++)
{
if(iGsmSmsStoreEntries[i].iMsgData.Length()==0)
{
index=i;
//ret = KErrNone;
break;
}
}
}
//else ret = KErrNone;//if index is specified entry will be overwitten, not possible to exceed memory
if((index<1)||(index>iSmsMaxNumSlots))
{
ReqCompleted(aReqHandle,KErrArgument);
return KErrNone;
}
//
// This can never happen because either ret is KErrNone or
// index is still -1 and we have returned.
//
//if (ret==KErrNoMemory)
//ReqCompleted(aReqHandle,ret);
if(iGsmSmsStoreEntries[index].iMsgData.Length()==0)
event=EStoreEventAdded;
else
event=EStoreEventChanged;
gsmSms.iIndex = index; // Update index data member for the client
iGsmSmsStoreEntries[index].iIndex=index;
iGsmSmsStoreEntries[index].iMsgData.Copy(gsmSms.iMsgData);
iGsmSmsStoreEntries[index].iMsgStatus=gsmSms.iMsgStatus;
iGsmSmsStoreEntries[index].iServiceCentre=gsmSms.iServiceCentre;
break;
}
case RMobileSmsStore::KETelMobileCdmaSmsEntryV1:
ReqCompleted(aReqHandle,KErrNotSupported);
return KErrNone;
default:
ReqCompleted(aReqHandle,KErrArgument);
return KErrNone;
}
DelayCompletion(iSmsIndividualPause,aReqHandle,event,index);
return KErrNone;
}
TInt CSimSmsStore::StoreIncomingMessage(RMobileSmsStore::TMobileGsmSmsEntryV1* aSms)
/**
* This method is used to store Incoming sms messages with the status EMtMessageStored
* It is accessed by CSimSmsMessaging::AttemptSmsRxCompleteL.
* Note: this will not call ReqComplete as no client request has been posted on this class
* Note: the smsStack will delete the message from the store after ReceiveMessage has completed
**/
{
TInt& index=aSms->iIndex;
TInt ret=KErrNoMemory;
TStoreEvent event=EStoreEventNoEvent;
for(TInt i=1;i<=iSmsMaxNumSlots;i++)
{
if(iGsmSmsStoreEntries[i].iMsgData.Length()==0)
{
index=i;
event=EStoreEventAdded;
ret = KErrNone;
break;
}
}
aSms->iIndex=index;//set here to be used by CSimSmsMessaging
if (ret==KErrNone)
{
iGsmSmsStoreEntries[index].iIndex=index;
iGsmSmsStoreEntries[index].iMsgData.Copy(aSms->iMsgData);
iGsmSmsStoreEntries[index].iMsgStatus=aSms->iMsgStatus;
iGsmSmsStoreEntries[index].iServiceCentre=aSms->iServiceCentre;
iPendingEvent=event;
iPendingIndex=index;
iIncomingTimer->Start(iSmsIndividualPause,this, 1);//delay the notification
}
return ret;
}
TInt CSimSmsStore::Delete(TTsyReqHandle aReqHandle,TDes8* aPckg)
/**
* Delete a single SMS store entry. The completion of this request is delayed in order to
* simulate a real TSY that would have to write the information to a SIM card. A store
* event may be triggered by this request.
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg The parameter package associated with this request.
* @return Standard return value.
*/
{
if (!(iSmsStoreCaps & RMobilePhoneStore::KCapsIndividualEntry && iSmsStoreCaps & RMobilePhoneStore::KCapsWriteAccess))
{
ReqCompleted(aReqHandle, KErrAccessDenied);
return KErrNone;
}
TPckg<TInt>* intPckg=(TPckg<TInt>*)aPckg;
TInt& index=(*intPckg)();
if((index<1)||(index>iSmsMaxNumSlots))
{
ReqCompleted(aReqHandle,KErrArgument);
return KErrNone;
}
iGsmSmsStoreEntries[index].iMsgData.Zero();
iGsmSmsStoreEntries[index].iMsgStatus=RMobileSmsStore::EStoredMessageUnknownStatus;
iGsmSmsStoreEntries[index].iServiceCentre.iTelNumber=KNullTelephoneNumber;
DelayCompletion(iSmsIndividualPause,aReqHandle,EStoreEventDeleted,index);
return KErrNone;
}
TInt CSimSmsStore::ReadAllPhase1(TTsyReqHandle aReqHandle,TDes8* aPckg1,TDes8* aPckg2)
/**
* First phase of a batch SMS Store read. The completion of this request is delayed in
* order to simulate a real TSY that would have to get the information from a SIM card.
* If the GetSmspListPhase1L should leave this method takes care of that and
* makes a premature ReqCompleted to the client.
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg1 The first parameter package associated with this request.
* It contains the client ID information required to uniquely identify this request.
* It also contains the batch read information (first slot, number of slots).
* @param aPckg2 The parameter package associated with this request.
* The size of the information to be passed back to the client is returned in this package.
* @return Standard return value.
*/ {
if (!(iSmsStoreCaps & static_cast<TUint32>(RMobilePhoneStore::KCapsWholeStore) && iSmsStoreCaps & RMobilePhoneStore::KCapsReadAccess))
{
ReqCompleted(aReqHandle, KErrAccessDenied);
return KErrNone;
}
TPckg<CRetrieveMobilePhoneSmsList::TBatchRequestData>* clientIdPckg=(TPckg<CRetrieveMobilePhoneSmsList::TBatchRequestData>*) aPckg1;
CRetrieveMobilePhoneSmsList::TBatchRequestData& clientId=(*clientIdPckg)();
TPckg<TInt>* sizePckg=(TPckg<TInt>*)aPckg2;
TInt& size=(*sizePckg)();
TRAPD(leaveCode,ReadAllPhase1L(aReqHandle,clientId,size));
return leaveCode;
}
void CSimSmsStore::ReadAllPhase1L(TTsyReqHandle aReqHandle,CRetrieveMobilePhoneSmsList::TBatchRequestData& aClientId,
TInt& aBufSize)
/**
* Implementation of ReadAllPhase1.
*
*/
{
TInt cnt=0;
CMobilePhoneListBase* listBase = NULL;
if ((CSimTsyMode::GetMode() != CSimTsyMode::ECdmaV1) &&
(aClientId.iEntryType == RMobileSmsStore::KETelMobileGsmSmsEntryV1))
{
listBase = CMobilePhoneGsmSmsList::NewL();
}
else
{
// Nothing to read.
ReqCompleted(aReqHandle, KErrNone);
return;
}
CleanupStack::PushL(listBase);
if(!aClientId.iBatchRequest)
{
aClientId.iStartIndex=1;
aClientId.iBatchSize=iSmsMaxNumSlots;
}
for(TInt i = aClientId.iStartIndex; cnt < aClientId.iBatchSize; i++)
{
if (i > iSmsMaxNumSlots)
break;
if (aClientId.iEntryType == RMobileSmsStore::KETelMobileGsmSmsEntryV1)
{
if (iGsmSmsStoreEntries[i].iMsgData.Length() != 0)
{
((CMobilePhoneGsmSmsList*)listBase)->AddEntryL(iGsmSmsStoreEntries[i]);
cnt++;
}
}
}
// Store the streamed list and the client ID
CListReadAllAttempt* read=CListReadAllAttempt::NewL(aClientId.iClient, aReqHandle);
CleanupStack::PushL(read);
read->iListBuf = listBase->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();
CleanupStack::PopAndDestroy(); // pop&destroy list
// Complete first phase of list retrieval
DelayCompletion(iSmsBatchPause,aReqHandle);
// return KErrNone;
}
TInt CSimSmsStore::ReadAllPhase2(TTsyReqHandle aReqHandle,TDes8* aPckg1,TDes8* aBuffer)
/**
* Second phase of a batch SMS Store read. The completion of this request is not delayed
* as it is assumed that the TSY has already cached the required information (during the
* first phase of the read).
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg1 The first parameter package associated with this request.
* It contains the client ID information required to uniquely identify this request.
* @param aBuffer The parameter package associated with this request.
* It contains the read buffer in which the required information is returned.
* @return Standard return value.
*/
{
TPckg<RMobilePhone::TClientId>* clientIdPckg=(TPckg<RMobilePhone::TClientId>*) aPckg1;
RMobilePhone::TClientId& clientId=(*clientIdPckg)();
for (TInt i=0; i<iSmsReadAll->Count(); ++i)
{
CListReadAllAttempt* read = iSmsReadAll->At(i);
if ((read->iClient.iSessionHandle==clientId.iSessionHandle) &&
(read->iClient.iSubSessionHandle==clientId.iSubSessionHandle))
{
TPtr8 bufPtr((read->iListBuf)->Ptr(0));
// Copy the streamed list to the client
aBuffer->Copy(bufPtr);
delete read;
iSmsReadAll->Delete(i);
ReqCompleted(aReqHandle,KErrNone);
return KErrNone;
}
}
// Don't delay completion of this request, as we assume the TSY will have the results in
// memory from the first request.
ReqCompleted(aReqHandle,KErrNotFound);
return KErrNone;
}
TInt CSimSmsStore::DeleteAll(TTsyReqHandle aReqHandle)
/**
* Delete all entries in the SIM Store. The completion of this function is delayed in
* order to simulate the SIM operations a real TSY would have to carry out. This function
* may trigger an SMS Store notification.
*
* @param aReqHandle The TSY request handle associated with this request.
* @return Standard return value.
*/
{
if (!(iSmsStoreCaps & static_cast<TUint32>(RMobilePhoneStore::KCapsWholeStore) && iSmsStoreCaps & RMobilePhoneStore::KCapsWriteAccess))
{
ReqCompleted(aReqHandle, KErrAccessDenied);
return KErrNone;
}
for(TInt i=1;i<=iSmsMaxNumSlots;i++)
{
iGsmSmsStoreEntries[i].iIndex=i;
iGsmSmsStoreEntries[i].iMsgStatus=RMobileSmsStore::EStoredMessageUnknownStatus;
iGsmSmsStoreEntries[i].iMsgData.Zero();
iGsmSmsStoreEntries[i].iServiceCentre.iTelNumber=KNullTelephoneNumber;
}
DelayCompletion(iSmsBatchPause,aReqHandle,EStoreEventDeleted,-1);
return KErrNone;
}
TInt CSimSmsStore::NotifyStoreEvent(TTsyReqHandle aReqHandle,TDes8* aPckg1,TDes8* aPckg2)
/**
* Register a client's interest in SMS Store events.
*
* @param aReqHandle The TSY request handle associated with this request.
* @param aPckg1 The first parameter package associated with this request.
* It contains the event flags that will be returned to the client.
* @param aPckg2 The second parameter package associated with this request.
* It contains the index value associated with the event
* that will be returned to the client.
* @return Standard return value.
*/
{
if (!(iSmsStoreCaps & RMobilePhoneStore::KCapsNotifyEvent))
{
ReqCompleted(aReqHandle, KErrNotSupported);
return KErrNone;
}
__ASSERT_ALWAYS(iEvOutstandingReq==EFalse,SimPanic(ENotificationAlreadyPending));
TPckg<TUint32>* eventPckg=(TPckg<TUint32>*)aPckg1;
TUint32& event=(*eventPckg)();
TPckg<TInt>* indexPckg=(TPckg<TInt>*)aPckg2;
TInt& index=(*indexPckg)();
iEvOutstandingReq=ETrue;
iEvReqHandle=aReqHandle;
iEvEvent=&event;
iEvIndex=&index;
return KErrNone;
}
void CSimSmsStore::NotifyStoreEventCancel()
/**
* Cancel an outstanding notify store request.
*/
{
if(iEvOutstandingReq)
{
iEvOutstandingReq=EFalse;
ReqCompleted(iEvReqHandle,KErrCancel);
}
}
//coverity[bad_override]
TPtrC8 CSimSmsStore::Name()
/**
* Accessor function fot the SMS Store name.
*
* @return TPtrC8 The name of this SMS Store.
*/
{
return iSmsStoreName;
}
TInt CSimSmsStore::UsedEntries()
/**
* Count the number of used entries in the SMS Store.
* @return TInt The number of used entries in the store.
*/
{
TInt cnt=0;
for(TInt i=1;i<=iSmsMaxNumSlots;i++)
{
if(iGsmSmsStoreEntries[i].iMsgData.Length()!=0)
cnt++;
}
return cnt;
}
TInt CSimSmsStore::MaxSlots()
/**
* Retrieve the maximum number of slots in this SMS Store.
* @return TInt The maximum number of slots in this SMS Store.
*/
{
return iSmsMaxNumSlots;
}
void CSimSmsStore::DelayCompletion(TInt aDelayDuration,TTsyReqHandle aReqHandle)
/**
* A shell function for functions that wish to delay completion but do not trigger store
* events.
*/
{
DelayCompletion(aDelayDuration,aReqHandle,EStoreEventNoEvent,0);
}
TUint CSimSmsStore::StoreCaps()
{
return iSmsStoreCaps;
}
void CSimSmsStore::DelayCompletion(TInt aDelayDuration,TTsyReqHandle aReqHandle,TStoreEvent aEvent,TInt aIndex)
/**
* Delay the completion of a TSY request. It is assumed that the member variable
* manipulation associated with the request has already taken place, and so all that is
* left to do is call the ETel server's request completion function when the timer expires.
* So, just record the parameters and kick off the timer.
*
* @param aDelayDuration The time (in seconds) for which the request completion is to be delayed.
* @param aReqHandle The TSY request handle related to the delayed completion.
* @param aEvent The store event related to the delayed completion.
* @param aIndex The index related to the event passed in aEvent.
*/
{
iPendingReqCompletion=aReqHandle;
iPendingEvent=aEvent;
iPendingIndex=aIndex;
iTimer->Start(aDelayDuration,this);
}
void CSimSmsStore::ReadAllCancel()
/*
* Cancel an outstanding read/write smsp.
*/
{
iTimer->Cancel();
ReqCompleted(iPendingReqCompletion,KErrCancel);
}
void CSimSmsStore::DeleteAllCancel()
/*
* Cancel an outstanding read/write smsp.
*/
{
iTimer->Cancel();
ReqCompleted(iPendingReqCompletion,KErrNone);//The timer is cancelled but data has already been deleted
}
void CSimSmsStore::TimerCallBack(TInt aId)
/**
* Process a timer call back event. The timer is used to kick requests which have had their
* completions delayed.
*/
{
StoreEvent(iPendingEvent,iPendingIndex);
if (aId!=1)//aId is 1 if reuest is StoreIncomingMessage(coming from CSimSmsMessaging)
ReqCompleted(iPendingReqCompletion,KErrNone);
}
void CSimSmsStore::StoreEvent(TStoreEvent aEvent,TInt aIndex)
/**
* Determine if a store event notification should be completed.
* @param aEvent The store event.
* @param aIndex The index related to the store event.
*/
{
if(iEvOutstandingReq)
{
TUint event=0;
switch(aEvent)
{
case EStoreEventNoEvent:
return;
case EStoreEventAdded:
event|=RMobilePhoneStore::KStoreEntryAdded;
break;
case EStoreEventDeleted:
event|=RMobilePhoneStore::KStoreEntryDeleted;
break;
case EStoreEventChanged:
event|=RMobilePhoneStore::KStoreEntryChanged;
break;
}
if(UsedEntries()==0)
event|=RMobilePhoneStore::KStoreEmpty;
if(UsedEntries()==iSmsMaxNumSlots)
event|=RMobilePhoneStore::KStoreFull;
else
event|=RMobilePhoneStore::KStoreHasSpace;
*iEvEvent=event;
*iEvIndex=aIndex;
iEvOutstandingReq=EFalse;
ReqCompleted(iEvReqHandle,KErrNone);
}
}
const CTestConfigSection* CSimSmsStore::CfgFileSection()
/**
* Returns a pointer to the config file section
*
* @return CTestConfigSection a pointer to the configuration file data section
*/
{
LOGSMS1(">>CSimSmsStore::CfgFileSection");
return iSmsMessaging->CfgFileSection();
}