diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/multimodetsy/Multimode/Mownnum.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/multimodetsy/Multimode/Mownnum.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,400 @@ +// 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: +// Deal with Network & Operator information +// +// + +#include +#include "Mownnum.h" +#include "mSLOGGER.H" +#include "ATIO.H" +#include "Matstd.h" +#include +#include +#include "et_phone_util.h" + +// Get the own numbers from the phone +// NB - not supported by all phones. + +_LIT8(KGetOwnNumbersCommand,"AT+CNUM"); +_LIT8(KGetOwnNumbersResponse,"+CNUM"); + +CATOwnNumbers::CATOwnNumbers(CATIO* aIo, CTelObject* aTelObject, CATInit* aInit,CPhoneGlobals* aPhoneGlobals) + : CATCommands(aIo,aTelObject,aInit,aPhoneGlobals) + {} + +CATOwnNumbers* CATOwnNumbers::NewL(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals) + { + CATOwnNumbers* self = new(ELeave) CATOwnNumbers(aIo, aTelObject, aInit, aPhoneGlobals); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +CATOwnNumbers::~CATOwnNumbers() + { + if (iIo != NULL) + { + iIo->RemoveExpectStrings(this); + } + delete iOwnNumbers; + } + +void CATOwnNumbers::Start(TTsyReqHandle aTsyReqHandle, TAny* /*aParam*/) + { + LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tStarting Get Own Number")); + iReqHandle = aTsyReqHandle; + WriteExpectingResults(KGetOwnNumbersCommand, 3); + __ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL,Panic(EGeneral)); + iState=EATImsiWaitForWriteComplete; + } + +void CATOwnNumbers::EventSignal(TEventSource aSource) + { + if (aSource==ETimeOutCompletion) + { + LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tTimeout Error during Get Own Number read")); + RemoveStdExpectStrings(); + Complete(KErrTimedOut,aSource); + return; + } + + switch(iState) + { + case EATImsiWaitForWriteComplete: + __ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected)); + { + iIo->WriteAndTimerCancel(this); + StandardWriteCompletionHandler(aSource, 5); + iState=EATImsiReadComplete; + } + break; + + case EATImsiReadComplete: + __ASSERT_ALWAYS(aSource==EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected)); + { + iIo->WriteAndTimerCancel(this); + TInt ret(ValidateExpectString()); + RemoveStdExpectStrings(); + if (ret==KErrNone) + TRAP(ret,ParseResponseL()); + Complete(ret,aSource); + } + break; + + case EATWaitForStopState: + __ASSERT_ALWAYS(aSource==EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected)); + { + iIo->WriteAndTimerCancel(this); + Complete(KErrCancel, aSource); + } + break; + + + default: + break; + }//switch + }//EventSignal + +void CATOwnNumbers::Stop(TTsyReqHandle aTsyReqHandle) + { + if(iReqHandle == TSY_HANDLE_INIT_VALUE) // default value + { + // it seems the Own numbers service has not been started + // just return + LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tCancel called, Error - invalid request handle.")); + return; + } + + __ASSERT_ALWAYS(aTsyReqHandle == iReqHandle, Panic(EIllegalTsyReqHandle)); + LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tCancel called.")); + switch(iState) + { + case EATNotInProgress: + case EATImsiWaitForWriteComplete: + { + LOGTEXT2(_L8("Current state TSY is cancelling from %d"), iState); + Complete(KErrCancel, EReadCompletion); + } + break; + + default: + { + LOGTEXT(_L8("MMTsy:\tCATOwnNumbers:\tStop, now waiting for expected modem response")); + AddStdExpectStrings(); + iIo->SetTimeOut(this); + iState = EATWaitForStopState; + } + break; + + } + } + + +void CATOwnNumbers::Complete(TInt aError,TEventSource aSource) + { + if (aError==KErrNone || aError==KErrNotFound) + iState = EATCompleted; + else if (aError==KErrGeneral) + { + iState = EATNotSupported; + aError = KErrNotSupported; + } + else + iState = EATNotInProgress; + iIo->WriteAndTimerCancel(this); + iIo->RemoveExpectStrings(this); + iOKExpectString = NULL; + iErrorExpectString = NULL; + CATCommands::Complete(aError,aSource); + LOGTEXT2(_L8("GsmTsy:CATOwnNumbers:\tCATOwnNumbers completed with error code : %d"), aError); + iTelObject->ReqCompleted(iReqHandle, aError); + if (aSource==EWriteCompletion) + iIo->Read(); + } + +void CATOwnNumbers::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus) + { + if (iState!=EATNotInProgress) + { + iIo->WriteAndTimerCancel(this); + iState = EATNotInProgress; + iTelObject->ReqCompleted(iReqHandle, aStatus); + } + } + +void CATOwnNumbers::ParseResponseL() + { +// +CNUM: [text],number,type[,speed,service[,itc]] +// etc. + + + CMobilePhoneONList* oNList=CMobilePhoneONList::NewL(); + CleanupStack::PushL(oNList); + +// + ParseBufferLC(EFalse, ':'); +// + + TDblQueIter iter(iRxResults); + CATParamListEntry* entry=iter++; + while (entry) + { + if (entry->iResultPtr!=KGetOwnNumbersResponse) + User::Leave(KErrGeneral); + // + // provide some default values + RMobileONStore::TMobileONEntryV1 info; + info.iMode = RMobilePhone::ENetworkModeGsm; // Hard coded since this tsy just handles GSM. + + entry=iter++; + if (!entry) + User::Leave(KErrGeneral); + info.iText.Copy(entry->iResultPtr); + + entry=iter++; + if (!entry) + User::Leave(KErrGeneral); + info.iNumber.iTelNumber.Copy(entry->iResultPtr); + + entry=iter++; + info.iNumber.iTypeOfNumber = NumberTypefromGSMToMM(CATParamListEntry::EntryValL(entry)); // How is this to be used + + // now the optional values + entry=iter++; + if (entry && entry->iResultPtr!=KGetOwnNumbersResponse) + { + //The baerer speed that should have been set here is not supported in the TMobileONEntryV1 class + entry=iter++; + TInt service=CATParamListEntry::EntryValL(entry); + switch (service) + + { + case KServiceVoice: + info.iService = RMobilePhone::EVoiceService; + break; + case KServiceFax: + info.iService = RMobilePhone::EFaxService; + break; + case KAsynchModem: + case KSynchModem: + case KPADAccess: + case KPacketAccess: + info.iService = RMobilePhone::ECircuitDataService; + break; + + default: + info.iService = RMobilePhone::EServiceUnspecified; + break; + } + // + // further optionality + entry=iter++; + if (entry && entry->iResultPtr!=KGetOwnNumbersResponse) + { + // Information about the transfer capabilities are not used in + // TMobileONEntryV1(the "itc" field is optionaly reurned by AT+CNUM). + // If it had been available it hade been set here. + entry=iter++; + } + } + oNList->AddEntryL(info); + } + + CleanupStack::PopAndDestroy(); // results + CleanupStack::Pop(); // numbers + iOwnNumbers = oNList; + + switch (iCommand) + { + case EInfo: + Info(); + break; + case EEntry: + (void)User::LeaveIfError(Entry(iResultIndex)); + break; + } + } + +void CATOwnNumbers::Info() const +/** + * This method sets the information about the own number store to be passed + * back to the client with cached inforamtion. + */ + { + RMobilePhoneStore::TMobilePhoneStoreInfoV1& storeInfo = (*iInfoPckg)(); + + storeInfo.iType=RMobilePhoneStore::EOwnNumberStore; + storeInfo.iUsedEntries = iOwnNumbers->Enumerate(); + storeInfo.iTotalEntries = iOwnNumbers->Enumerate(); + storeInfo.iName.Copy(KETelOwnNumberStore); + storeInfo.iCaps=RMobilePhoneStore::KCapsIndividualEntry | RMobilePhoneStore::KCapsReadAccess; + + if (storeInfo.ExtensionId()==RMobilePhoneStore::KETelMobileONStoreV1) + { + RMobileONStore::TMobileONStoreInfoV1Pckg* onPckg + = reinterpret_cast(iInfoPckg); + RMobileONStore::TMobileONStoreInfoV1& onInfo = (*onPckg)(); + onInfo.iNumberLen=RMobilePhone::KMaxMobileTelNumberSize; + onInfo.iTextLen=RMobileONStore::KOwnNumberTextSize; + } + } + +TInt CATOwnNumbers::Entry(TInt aIndex) const +/** + * This method returnes the own number specified by aIndex. + * If aIndex should be out of range KErrNotFound is returned. + */ + { + __ASSERT_DEBUG(iOwnNumbers!= NULL, PanicClient(KErrGeneral)); + + RMobileONStore::TMobileONEntryV1& oNEntry = (*iEntryPckg)(); + if (TUint(aIndex)>=TUint(iOwnNumbers->Enumerate())) + { + // If the index is out of range + return KErrNotFound; + } + + // Get the entry specified by the aIndex. + TRAPD(ret,(oNEntry = iOwnNumbers->GetEntryL(aIndex))); + + return ret; + } + + +void CATOwnNumbers::GetInfo(TTsyReqHandle aTsyReqHandle, TDes8* aInfo) +/** + * Execute the command if we have not yet been run + * Report the own number info if we have already evaluated them + */ + { + iInfoPckg=static_cast(aInfo); + switch (iState) + { + case EATCompleted: + Info(); + iTelObject->ReqCompleted(aTsyReqHandle, KErrNone); + break; + case EATNotSupported: + iTelObject->ReqCompleted(aTsyReqHandle, KErrNotSupported); + break; + default: + iCommand=EInfo; + ExecuteCommand(aTsyReqHandle,aInfo); + break; + } + } + + +void CATOwnNumbers::GetEntry(TTsyReqHandle aTsyReqHandle, TDes8* aEntry) +/** + * Execute the command if we have not yet been run. + * @param aTsyReqHandle The request ID + * @param aEntry This argument is of type TMobileONEntryV1Pckg. + */ + { + // Unpack the the TMobileONEntryV1 (aEntry) + iEntryPckg = static_cast(aEntry); + RMobileONStore::TMobileONEntryV1& oNEntry = (*iEntryPckg)(); + + // Extract the index of the own number to get. + // Subtract 1 because SIM slots start at 1 but our list will start at 0 + // Client has asked for SIM slot number + iResultIndex = oNEntry.iIndex - 1 ; + + switch (iState) + { + case EATCompleted: + { + TInt r=Entry(iResultIndex); + if (r!=KErrNone) + { + iTelObject->ReqCompleted(aTsyReqHandle, r); + return; + } + iTelObject->ReqCompleted(aTsyReqHandle, KErrNone); + } + break; + case EATNotSupported: + iTelObject->ReqCompleted(aTsyReqHandle, KErrNotSupported); + break; + default: + iCommand=EEntry; + ExecuteCommand(aTsyReqHandle, &oNEntry); + break; + } + }//End of GetEntry + + +RMobilePhone::TMobileTON CATOwnNumbers::NumberTypefromGSMToMM(TUint aTypeOfNumberGSM) +/** Maping from MM Number Type To GSM Number Type + * + * This method maps the GSM way of representing a type of telefon number + * to the MM standard. + * + */ + { + switch (aTypeOfNumberGSM) + { + case 129: // Nationality unknown (GSM) + return RMobilePhone::EUnknownNumber; // (MM) + case 145: // International Number (GSM) + return RMobilePhone::EInternationalNumber; // (MM) + case 161: // National Number (GSM) + return RMobilePhone::ENationalNumber; // (MM) + default: + return RMobilePhone::EUnknownNumber; // (MM) + } + }