diff -r 000000000000 -r 3553901f7fa8 smsprotocols/smsstack/smsprot/Src/smsppara.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/smsprotocols/smsstack/smsprot/Src/smsppara.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,600 @@ +// Copyright (c) 2001-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 "smsppara.h" +#include "smsuset.h" +#include "smsulog.h" +#include "smspmain.h" + +#include "gsmubuf.h" +#include "Gsmumsg.h" +#include +#include "SmsuTimer.h" + + +/** + * Constructor + * + * @param aSmsComm a reference to the protocol. + * @param aSmsSettings a reference to the global SMS settings. + * @param aSmsMessaging a reference to the ETEL SMS messaging subsession. + * + */ +CSmsParamsBase::CSmsParamsBase(MSmsComm& aSmsComm,const TSmsSettings& aSmsSettings,RMobileSmsMessaging& aSmsMessaging) + : CSmsuActiveBase(KSmsSessionPriority), + iSmsComm(aSmsComm), + iSmsSettings(aSmsSettings), + iSmsMessaging(aSmsMessaging) + { + } // CSmsParamsBase::CSmsParamsBase + + +/** + * 2nd Phase of construction. + * + * Creates CSmsTimeout object. + * + */ +void CSmsParamsBase::ConstructL() + { + LOGSMSPROT1("CSmsParamsBase::ConstructL()"); + + ConstructTimeoutL(); + } // CSmsParamsBase::ConstructL + + +/** + * 2 Phase constructor. + * + * @param aSmsComm a reference to the protocol. + * @param aSmsSettings a reference to the global SMS settings. + * @param aSmsMessaging a reference to the ETEL SMS messaging subsession. + * @leave Leaves if ContructL() leaves, or not enough memory is available. + * @return a new CSmsReadParams object. + * + */ +CSmsReadParams* CSmsReadParams::NewL(MSmsComm& aSmsComm,const TSmsSettings& aSmsSettings,RMobileSmsMessaging& aSmsMessaging) + { + LOGSMSPROT1("CSmsReadParams::NewL()"); + + CSmsReadParams* smsReadParams=new(ELeave) CSmsReadParams(aSmsComm,aSmsSettings,aSmsMessaging); + CleanupStack::PushL(smsReadParams); + smsReadParams->ConstructL(); + CleanupStack::Pop(smsReadParams); + return smsReadParams; + } // CSmsReadParams::NewL + + +/** + * Destructor + * + * Cancel reading process and delete all created objects. + * + */ +CSmsReadParams::~CSmsReadParams() + { + Cancel(); + delete iRetrieveMobilePhoneSmspList; + delete iMobilePhoneSmspList; + } // CSmsReadParams::~CSmsReadParams + + +/** + * Start retrieving of SMS parameters. Called by CSmsProtocol. + * + * The behavour has been changed so that these parameters + * will always be retrieved from the TSY. [Previously the + * algorithm only retrieved the parameters from the TSY once + * and cached them so the TSY would not need to be polled if + * a client asked for the again, the assumption being that the + * SC number would never change. Subsequent client requests to + * read the SMS parameters would result in the cached parameters + * being returned rather than retrieving the parameters from the + * SIM. However this can cause problems (DEF40029) if the SIM is + * replaced with a new SIM that has an incorrect service center + * number: the stack can be requested to load the SMS parameters + * twice, once when the phone boots with the new SIM and again when + * the SIM is updated with the new Service Centre Number. If 2nd + * request only results in the cached parameters being returned then + * the incorrect SC Address will be returned.] + * + * @param aObserver a reference to the observer object. + */ +void CSmsReadParams::Start(MSmsMessageObserver& aObserver) + { + LOGSMSPROT1("CSmsReadParams::Start()"); + + __ASSERT_DEBUG(iSmsMessageObserver == NULL && iReport == NULL, + SmspPanic(KSmspPanicUnexpectedState)); + + // + // Store the observer interface object for and start the retrieve + // operation. + // + iSmsMessageObserver = &aObserver; + + iRetrieveMobilePhoneSmspList->Start(iStatus); + + TimedSetActive(iSmsSettings.Timeout()); + } // CSmsReadParams::Start + + +/** + * Start retrieving of SMS parameters. Called by CSmsWriteParams. + * + * The behavour has been changed so that these parameters + * will always be retrieved from the TSY. [Previously the + * algorithm only retrieved the parameters from the TSY once + * and cached them so the TSY would not need to be polled if + * a client asked for the again, the assumption being that the + * SC number would never change. Subsequent client requests to + * read the SMS parameters would result in the cached parameters + * being returned rather than retrieving the parameters from the + * SIM. However this can cause problems (DEF40029) if the SIM is + * replaced with a new SIM that has an incorrect service center + * number: the stack can be requested to load the SMS parameters + * twice, once when the phone boots with the new SIM and again when + * the SIM is updated with the new Service Centre Number. If 2nd + * request only results in the cached parameters being returned then + * the incorrect SC Address will be returned.] + * + * @param aStatus a reference to the outstanding request. + */ +void CSmsReadParams::Start(TRequestStatus& aStatus) + { + LOGSMSPROT1("CSmsReadParams::Start()"); + + __ASSERT_DEBUG(iSmsMessageObserver == NULL && iReport == NULL, + SmspPanic(KSmspPanicUnexpectedState)); + + // + // Store the TRequestStatus in the CSmsuActiveBase object for later + // completion and start the retrieve operation. + // + Queue(aStatus); + + iRetrieveMobilePhoneSmspList->Start(iStatus); + + TimedSetActive(iSmsSettings.Timeout()); + } // CSmsReadParams::Start + + +/** + * Retrieves parameter list from CRetrieveMobilePhoneSmspList object. + * Cancel timeout timer. Delete old SMSP list and retrieve new list from + * CMobilePhoneSmspList object if retrieving was successful. + * + * @leave Leave if RetrieveListL() leaves. + */ +void CSmsReadParams::DoRunL() + { + LOGSMSPROT2("CSmsReadParams::RunL [iStatus=%d]", iStatus.Int() ); + + // + // If the start retrieve was successful, then continue retrieving the list. + // A temporary variable is used to keep the old list until the new one is + // obtained successfully. + // + if (iStatus == KErrNone) + { + CMobilePhoneSmspList* tempList = iRetrieveMobilePhoneSmspList->RetrieveListL(); + + delete iMobilePhoneSmspList; + iMobilePhoneSmspList = tempList; + } + + // + // DoRunL() will now return to CSmsuActiveBase which if the object + // is not active, will call Complete(). + // + } // CSmsReadParams::DoRunL + + +/** + * Handles cancel read parameters request. + * + * Cancel timeout timer. + * Cancel also retrieving of parameters process. + * Call complete. + */ +void CSmsReadParams::DoCancel() + { + LOGSMSPROT1("CSmsReadParams::DoCancel()"); + + TimedSetActiveCancel(); + + // + // Cancel the request... + // + iRetrieveMobilePhoneSmspList->Cancel(); + + // + // 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); + } + } // CSmsReadParams::DoCancel + + +/** + * Constructor + * + * @param aSmsComm a reference to the protocol. + * @param aSmsSettings a reference to the global SMS settings. + * @param aSmsMessaging a reference to the ETEL SMS messaging subsession. + * + */ +CSmsReadParams::CSmsReadParams(MSmsComm& aSmsComm,const TSmsSettings& aSmsSettings,RMobileSmsMessaging& aSmsMessaging): + CSmsParamsBase(aSmsComm,aSmsSettings,aSmsMessaging) + { + } // CSmsReadParams::CSmsReadParams + + +/** + * 2nd Phase of construction. + * + * Creates CRetrieveMobilePhoneSmspList object. + * + */ +void CSmsReadParams::ConstructL() + { + LOGSMSPROT1("CSmsReadParams::ConstructL()"); + + CSmsParamsBase::ConstructL(); + + iRetrieveMobilePhoneSmspList = CRetrieveMobilePhoneSmspList::NewL(iSmsMessaging); + } // CSmsReadParams::ConstructL + + +/** + * Check validity of SMSP list. List shouldn't contain more entries that can be stored + * to phone-side storage. + * Set maximum number of enties value to the client's list. + * + * @param aMobilePhoneSmspList a reference to the CMobilePhoneSmspList object. + * @leave Leave if aMobilePhoneSmspList object contains too many SMSP sets. + * + */ +void CSmsReadParams::CheckListValidityL(CMobilePhoneSmspList& aMobilePhoneSmspList) + { + LOGSMSPROT1("CSmsReadParams::CheckListValidityL()"); + + // + // MaxNumberEntries method returns the maximum number of entries that can + // be stored in this list. This attribute is required because most phone-side + // storage will have an upper storage limit. If the TSY has not set this + // attribute during a list retrieval then the value returned will be -1. + // + if (iMobilePhoneSmspList->MaxNumberEntries() != -1) + { + if (aMobilePhoneSmspList.Enumerate() > iMobilePhoneSmspList->MaxNumberEntries()) + { + User::Leave(KErrArgument); + } + + aMobilePhoneSmspList.SetMaxNumberEntries(iMobilePhoneSmspList->MaxNumberEntries()); + } + } // CSmsReadParams::CheckListValidityL + + +/** + * Store successfully saved parameters also to SMSPROT's internal memory. Actually + * StoreParameters takes ownership of aMobilePhoneSmspList. + * + * Delete old list and set iMobilePhoneSmspList to point to the new SMSP list. + * + * @param aMobilePhoneSmspList a reference to the CMobilePhoneSmspList object. + * + */ +void CSmsReadParams::StoreParameters(CMobilePhoneSmspList* aMobilePhoneSmspList) + { + LOGSMSPROT1("CSmsReadParams::StoreParameters()"); + + __ASSERT_DEBUG(iMobilePhoneSmspList != NULL && aMobilePhoneSmspList != NULL && iMobilePhoneSmspList->MaxNumberEntries() == aMobilePhoneSmspList->MaxNumberEntries(),SmspPanic(KSmspPanicCorruptedSmspList)); + + delete iMobilePhoneSmspList; + iMobilePhoneSmspList = aMobilePhoneSmspList; + } // CSmsReadParams::StoreParameters + + +/** + * Completes read request or cancel read request. + * + * Cancel timeout timer. + * Complete request to the CSmsWriteParams object or observer. + * + * @param aStatus a status value. + * + */ +void CSmsReadParams::Complete(TInt aStatus) + { + LOGSMSPROT1("CSmsReadParams::Complete()"); + + // + // Call the base function to perform the actual complete... + // + CSmsuActiveBase::Complete(aStatus); + + if (iSmsMessageObserver != NULL && + iSmsComm.ObserverIsPresent(*iSmsMessageObserver)) + { + iSmsMessageObserver->ReadSmsParamsCompleted(aStatus, iMobilePhoneSmspList); + iSmsMessageObserver = NULL; + } + } // CSmsReadParams::Complete + + +/** + * 2 Phase constructor. + * + * @param aSmsComm a reference to the protocol. + * @param aSmsSettings a reference to the global SMS settings. + * @param aSmsMessaging a reference to the ETEL SMS messaging subsession. + * @param aSmsReadParams a reference to the CSmsReadParams object. + * @leave Leaves if ContructL() leaves, or not enough memory is available. + * @return a new CSmsReadParams object. + * + */ +CSmsWriteParams* CSmsWriteParams::NewL(MSmsComm& aSmsComm,const TSmsSettings& aSmsSettings,RMobileSmsMessaging& aSmsMessaging,CSmsReadParams& aSmsReadParams) + { + LOGSMSPROT1("CSmsWriteParams::NewL()"); + + CSmsWriteParams* smsWriteParams=new(ELeave) CSmsWriteParams(aSmsComm,aSmsSettings,aSmsMessaging,aSmsReadParams); + CleanupStack::PushL(smsWriteParams); + smsWriteParams->ConstructL(); + CleanupStack::Pop(smsWriteParams); + return smsWriteParams; + } // CSmsWriteParams::NewL + + +/** + * Destructor + * + * Cancel writing process and delete all created objects. + * + */ +CSmsWriteParams::~CSmsWriteParams() + { + Cancel(); + delete iMobilePhoneSmspList; + } // CSmsWriteParams::~CSmsWriteParams + + +/** + * Start writing of SMS parameters process. + * Set state to ESmsParamsStoringList. + * Read parameters to SMSPROT's internal memory if client tries to write + * parameters before SMSPROT has read them. This is because SMSPROT has to + * deliver whole SMSP list while making StoreSmspList request to the MM ETel. + * If client deliver only some SMSP sets while making write request, we have + * to add missing SMSP sets to the clients list. + * Set timeout timer on. + * + * @param aObserver a reference to the observer object. + * @param aMobilePhoneSmspList a pointer to SMSP list to be saved. + * + */ +void CSmsWriteParams::Start(MSmsMessageObserver& aObserver,CMobilePhoneSmspList* aMobilePhoneSmspList) + { + LOGSMSPROT1("CSmsWriteParams::Start()"); + + __ASSERT_DEBUG(iState==ESmsParamsIdle,SmspPanic(KSmspPanicUnexpectedState)); + + iState = ESmsParamsStoringList; + + iSmsMessageObserver= &aObserver; + iMobilePhoneSmspList=aMobilePhoneSmspList; + + // + //Read parameters to SMSPROT's internal memory before starting writing process... + // + iSmsReadParams.Start(iStatus); + + TimedSetActive(iSmsSettings.Timeout()); + } // CSmsWriteParams::Start + + +/** + * Store SMSP list to phone. If storing was successful, store list also + * to CSmsReadParams object. + * + * Cancel timeout timer. + * State ESmsParamsStoringList: + * Change state to ESmsParamsStoringListToInternal. + * Check validity of SMSP list using CSmsReadParams objects services. + * After that makes StoreSmspList request to the MM ETel. + * Set timeout timer on. + * State ESmsParamsStoringListToInternal: + * Store successfully stored parameters to CSmsReadParams object. + * + * @leave Leaves if there was an error. + * @leave Leave if RetrieveListL() leaves. + * @leave Leave if StoreSmspListL() leaves. + * @leave Panic if RunL is called while object is in idle state. + * + */ +void CSmsWriteParams::DoRunL() + { + LOGSMSPROT2("CSmsWriteParams::DoRunL [iStatus=%d]", iStatus.Int() ); + + switch (iState) + { + case ESmsParamsStoringList: + { + // + // Request the list to be stored... + // + if (iStatus.Int() == KErrNone) + { + iState = ESmsParamsStoringListToInternal; + + iSmsReadParams.CheckListValidityL(*iMobilePhoneSmspList); + iSmsMessaging.StoreSmspListL(iStatus, iMobilePhoneSmspList); + + TimedSetActive(iSmsSettings.Timeout()); + } + } + break; + + case ESmsParamsStoringListToInternal: + { + // + // If the list was stored successfully, then store it internally. + // + if (iStatus.Int() == KErrNone) + { + iSmsReadParams.StoreParameters(iMobilePhoneSmspList); + + // + // Set iMobilePhoneSmspList to NULL because it points now to SMSPROT's + // internal parameter storage. + // + iMobilePhoneSmspList = NULL; + } + } + break; + + default: + { + SmspPanic(KSmspPanicUnexpectedState); + } + break; + } + + // + // DoRunL() will now return to CSmsuActiveBase which if the object + // is not active, will call Complete(). + // + } // CSmsWriteParams::DoRunL + + +/** + * Handles cancel write parameters request. + * + * Cancel timeout timer. Cancel reading and writing processes + * if they are running. + * + */ +void CSmsWriteParams::DoCancel() + { + LOGSMSPROT1("CSmsWriteParams::DoCancel()"); + + TimedSetActiveCancel(); + + switch (iState) + { + case ESmsParamsStoringList: + { + iSmsReadParams.Cancel(); + } + break; + + case ESmsParamsStoringListToInternal: + { + iSmsMessaging.CancelAsyncRequest(EMobileSmsMessagingStoreSmspList); + } + 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); + } + } // CSmsWriteParams::DoCancel + + +/** + * Constructor + * + * @param aSmsComm a reference to the protocol. + * @param aSmsSettings a reference to the global SMS settings. + * @param aSmsMessaging a reference to the ETEL SMS messaging subsession. + * @param aSmsReadParams a reference to the CSmsReadParams object. + * + */ +CSmsWriteParams::CSmsWriteParams(MSmsComm& aSmsComm,const TSmsSettings& aSmsSettings,RMobileSmsMessaging& aSmsMessaging,CSmsReadParams& aSmsReadParams): + CSmsParamsBase(aSmsComm,aSmsSettings,aSmsMessaging), + iState(ESmsParamsIdle), + iSmsReadParams(aSmsReadParams) + { + } // CSmsWriteParams::CSmsWriteParams + + +/** + * 2nd Phase of construction. + * + * Creates CSmsuTimeout object. + * + */ +void CSmsWriteParams::ConstructL() + { + LOGSMSPROT1("CSmsWriteParams::ConstructL()"); + + CSmsParamsBase::ConstructL(); + } // CSmsWriteParams::ConstructL + + +/** + * Completes write request or cancel write request. + * + * Cancel timeout timer. Set state to ESmsParamsIdle. Complete request to the + * observer. + * + * @param aStatus a status value. + * @leave Panic if Complete is called while object is in ESmsParamsIdle state. + * + */ +void CSmsWriteParams::Complete(TInt aStatus) + { + LOGSMSPROT1("CSmsWriteParams::Complete()"); + + // + // Call the base function to perform the actual complete... + // + CSmsuActiveBase::Complete(aStatus); + + delete iMobilePhoneSmspList; + iMobilePhoneSmspList = NULL; + + iState = ESmsParamsIdle; + + if (iSmsComm.ObserverIsPresent(*iSmsMessageObserver)) + { + iSmsMessageObserver->WriteSmsParamsCompleted(aStatus); + iSmsMessageObserver = NULL; + } + } // CSmsWriteParams::Complete