diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/common_tsy/commontsy/src/mmcustomtsy/CMmCustomTsy.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/common_tsy/commontsy/src/mmcustomtsy/CMmCustomTsy.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,6977 @@ +// Copyright (c) 2006-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 FILES +#include "CMmCustomTsy.h" +#include "CMmCustomGsmExt.h" +#include "cmmcalllist.h" +#include "cmmphoneextinterface.h" +#include "CMmWimTsy.h" +#include "cmmcalltsy.h" +#include "CMmCommonStaticUtility.h" +#include "CMmSimLockTsy.h" +#include "MmTsy_conf.h" +#include +#include "cmmpblist.h" +#include "cmmphonebookstoretsy.h" +#include "CMmPacketTsy.h" +#include "CMmSIMTsy.h" +#include "CMmCustomSecurityTsy.h" +#include +#include +#include "cmmnettsy.h" // for CMmNetTsy::CipheringIndicatorForcedOff() +#include +#include "ctsyprivatecrpkeys.h" +#include + +// ======== MEMBER FUNCTIONS ======== + +CMmCustomTsy::CMmCustomTsy() + { + iMmPhoneTsy = NULL; + iMmCustomExtInterface = NULL; + Mem::FillZ( iMmSubTsy, sizeof( iMmSubTsy ) ); + + // initialize internal data + iCipheringInfo.iIndStatus = EFalse; + iCipheringInfo.iCiphStatus = EFalse; + } + +void CMmCustomTsy::ConstructL( + CMmPhoneTsy* aMmPhoneTsy ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL"); + iMmPhoneTsy = aMmPhoneTsy; + + iMmCustomExtInterface = CMmCustomGsmExt::NewL( aMmPhoneTsy, this ); + iMmSubTsy[ESubTsyIdxWIM] = CMmWimTsy::NewL( this ); + iMmSubTsy[ESubTsyIdxSimLock] = CMmSimLockTsy::NewL( this ); + iMmSubTsy[ESubTsyIdxPacket] = CMmPacketTsy::NewL( this, aMmPhoneTsy ); + + iMmSubTsy[ESubTsyIdxSIM] = CMmSIMTsy::NewL( this ); + + iMmSecurityTsy = CMmCustomSecurityTsy::NewL( this, aMmPhoneTsy ); + + // Create custom vendor extension + // Send request to the Domestic OS layer. + iMmCustomVendorExt = (CMmCustomVendorExt*) NULL; + CMmDataPackage package; + + package.PackData( &iMmCustomVendorExt ); // ptr to ptr + Phone()->MessageManager()->HandleRequestL( + EMmTsyGetCustomVendorExtPtrIPC, &package ); +TFLOGSTRING2("TSY: CMmCustomTsy::ConstructL -- iMmCustomVendorExt=0x%x", TUint(iMmCustomVendorExt)); + // The request above is 'completed' immediatedly (there is no need for + // actual complete) + + // iMmCustomVendorExt should now hold ptr to custom vendor extension. + // But if not, no problem, we just use the base class. + if ( NULL == iMmCustomVendorExt ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL -- no vendor IPC extensions"); + iMmCustomVendorExt = new(ELeave)CMmCustomVendorExt(); + } + + // initialize custom vendor extension + iMmCustomVendorExt->InitializeL( *this ); + +#ifdef REQHANDLE_TIMER + // Create req handle store + iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhoneTsy, + ECustomTsyMaxNumOfRequests, iCustomReqHandles ); +#else + // Create req handle store + iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( + ECustomTsyMaxNumOfRequests, iCustomReqHandles ); +#endif + + // register custom tsy in the message manager + Phone()->MessageManager()->RegisterTsyObject( + CMmMessageManagerBase::ECustomTsy, this ); + + iAdnCacheStatus = RMmCustomAPI::ECacheNotReady; + iFdnCacheStatus = RMmCustomAPI::ECacheNotReady; + + iISVDialNumberCheckObject = NULL; + iISVDialNumberCheck = EFalse; + iGetIccCfStatusBootUp = ETrue; + //Get pointer to public CenRep + iCFISCentRep = iMmPhoneTsy->GetCfisCenRep(); + iCFISPrivateCentRep = iMmPhoneTsy->GetCfisPRCenRep(); + TInt err = iFeatureControl.Open(); + iUsingFeatureManager = (err == KErrNone); + + // update/receive Icc Call forward information + if( iMmPhoneTsy->NosBootState()->iSIMReady ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL -- GET ICC call forward indicators"); + // Get Icc cfis values from LTSY + Phone()->MessageManager()->HandleRequestL( + ECustomGetIccCallForwardingStatusIPC ); + } + + // check if HomeZoneParams has been already read in NotifySimStatusReady + // if not, query again + if ( !iMmPhoneTsy->GetHomeZoneParamsChecked() ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - GetHomeZoneParamsChecked()"); + CMmSIMTsy* simCustomTsy = NULL; + simCustomTsy = ( CMmSIMTsy* )GetSIMTsyPtr(); +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - pointer created"); + + if ( simCustomTsy ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - CheckViagHomeZoneParamsL()"); + simCustomTsy->CheckViagHomezoneParamsL(); + iMmPhoneTsy->SetHomeZoneParamsChecked( ETrue ); + } + else + { +TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - CheckViagHomeZoneParamsL() False"); + iMmPhoneTsy->SetHomeZoneParamsChecked( EFalse ); + } + } + } + +CMmCustomTsy* CMmCustomTsy::NewL( + CMmPhoneTsy* aMmPhoneTsy ) + { +TFLOGSTRING("TSY: CMmCustomTsy::NewL"); + CMmCustomTsy* mmCustomTsy = new ( ELeave ) CMmCustomTsy(); + CleanupClosePushL( *mmCustomTsy ); + mmCustomTsy->ConstructL( aMmPhoneTsy ); + CleanupStack::Pop( mmCustomTsy ); + + return mmCustomTsy; + } + +CMmCustomTsy::~CMmCustomTsy() + { +TFLOGSTRING("TSY: CMmCustomTsy::~CMmCustomTsy"); + + iFeatureControl.Close(); + + // Delete subsystems + for ( TInt i = 0; ESubTsyIdxMaxNum > i; i++ ) + { + delete iMmSubTsy[i]; + } + + if ( iMmCustomVendorExt ) + { + // delete vendor extension + delete iMmCustomVendorExt; + } + + if ( iMmSecurityTsy ) + { + // Delete SecurityTsy + delete iMmSecurityTsy; + } + + if ( iMmCustomExtInterface ) + { + // Delete GSM extensions + delete iMmCustomExtInterface; + } + + if ( iTsyReqHandleStore ) + { + // delete req handle store + delete iTsyReqHandleStore; + } + + iMmCustomVendorExt = NULL; + iMmSecurityTsy = NULL; + iMmCustomExtInterface = NULL; + iTsyReqHandleStore = NULL; + iISVDialNumberCheckObject = NULL; + iCFISCentRep = NULL; + + if ( iMmPhoneTsy ) + { + iMmPhoneTsy->SetCustomTsy( NULL ); + + // unregister custom tsy in the message manager + iMmPhoneTsy->MessageManager()->DeregisterTsyObject(this); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::Phone +// Returns pointer to PhoneTsy object +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CMmPhoneTsy* CMmCustomTsy::Phone() + { + return iMmPhoneTsy; + } + + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ExtFunc +// Dispatches extension function requests. All functions that are not part +// of the core function set, are routed via the ExtFunc method. +// At the beginning of this method, packaged pointers are unpacked. Then +// the correct function is selected using the IPC number. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ExtFunc( + const TTsyReqHandle aTsyReqHandle, + const TInt aIpc, + const TDataPackage& aPackage ) + { + TInt ret = KErrNone; + TInt trapError = KErrNone; + iReqHandleType = ECustomTsyReqHandleUnknown; + + // before processing further the request, check if offline mode status + // is enabled and if the given request can be perfomed in that case. + if ( ERfsStateInfoInactive == iMmPhoneTsy->GetRfStateInfo() && + !IsRequestPossibleInOffline( aIpc ) ) + { +TFLOGSTRING2 ("TSY: Offline mode ON, request is not allowed: %d", aIpc ); + ret = CMmCommonStaticUtility::EpocErrorCode( KErrGeneral, + KErrGsmOfflineOpNotAllowed ); + + // Complete the request with appropiate error + ReqCompleted ( aTsyReqHandle, ret ); + } + else + { + TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); ); + + if ( KErrNone != trapError ) + { + // error handling. Object cannot be created. + ret = trapError; + } + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::DoExtFuncL +// This DoExtFuncL is called by Etel server when it has Custom API +// request for the TSY. To process a request handle, request type and request +// data are passed to the Custom TSY. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::DoExtFuncL( + const TTsyReqHandle aTsyReqHandle, + const TInt aIpc, + const TDataPackage& aPackage ) + { + TInt ret( KErrNotSupported ); + + // first check if request is supported in CMmSecurityTsy + // (due layering that class is no longer a part of extension modules) + + ret = iMmSecurityTsy->DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); + + if ( KErrNotSupported == ret ) + { + // then check if this is vendor extension IPC + // these IPCs are handled by VendorExt class in licensee tsy. + if ( iMmCustomVendorExt->SupportingIPC(aIpc) ) + { + ret = iMmCustomVendorExt->DoExtFuncL( aTsyReqHandle, aIpc, + aPackage ); + } + else + { + // then check all the Custom extension modules + ret = CMmTsyBase::DoBaseExtFuncL( aTsyReqHandle, aIpc, aPackage ); + } + + // if extension modules did not serve this request + if ( KErrNotSupported == ret ) + { + // reset last tsy request type + iReqHandleType = ECustomTsyReqHandleUnknown; + + switch ( aIpc ) + { + // Perform IMS Authentication + case EMobilePhoneIMSAuthenticate: + ret = ImsAuthenticationL( aTsyReqHandle, + REINTERPRET_CAST( + RMobilePhone::TImsAuthenticateDataV5*, + aPackage.Ptr1() ) ); + break; + // Get sim authentication data + case ECustomGetSimAuthenticationDataIPC: + ret = SimAuthenticationL( aTsyReqHandle, aPackage ); + break; + // Notify Dtmf event + case ECustomNotifyDtmfEventIPC: + ret = NotifyDtmfEvent( + REINTERPRET_CAST( RMmCustomAPI::TDtmfInfo*, + aPackage.Ptr1() ) ); + break; + // Get Diagnostic Octets - info + case ECustomGetDiagnosticOctetsIPC: + ret = GetDiagnosticInfo ( aTsyReqHandle, + REINTERPRET_CAST( TName*, aPackage.Ptr1() ) ); + break; + // Get Remote Alerting Tone Status + case ECustomGetRemoteAlertingToneStatusIPC: + ret = GetRemoteAlertingToneStatus ( aTsyReqHandle, + REINTERPRET_CAST( + RMmCustomAPI::TRemoteAlertingToneStatus*, + aPackage.Ptr1() ) ); + break; + // Call Origin + case ECustomCallOriginIPC: + ret = GetCallOrigin( aTsyReqHandle, + REINTERPRET_CAST( TName*, aPackage.Ptr1() ), + REINTERPRET_CAST( RMmCustomAPI::TCallOrigin*, + aPackage.Ptr2() ) ); + break; + // Terminate a Call/all calls + case ECustomTerminateCallIPC: + ret = TerminateCallL( aTsyReqHandle, + REINTERPRET_CAST( TName*, aPackage.Ptr1() ) ); + break; + // Get Als Blocked + case ECustomGetAlsBlockedIPC: + ret = GetAlsBlockedL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TGetAlsBlockStatus*, + aPackage.Ptr1() ) ); + break; + // Set Alternative Line Service Blocked + case ECustomSetAlsBlockedIPC: + ret = SetAlsBlockedL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TSetAlsBlock*, + aPackage.Ptr1() ) ); + break; + // Notify Als Blocked Change + case ECustomNotifyAlsBlockedChangedIPC: + ret = NotifyAlsBlockedChanged ( + REINTERPRET_CAST( RMmCustomAPI::TGetAlsBlockStatus*, + aPackage.Ptr1() ) ); + break; + // Get ALS pp support + case ECustomCheckAlsPpSupportIPC: + ret = GetAlsPpSupportL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TAlsSupport*, + aPackage.Ptr1() ) ); + break; + // Get ciphering information + case ECustomGetCipheringInfoIPC: + ret = GetCipheringInfoL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TCipheringInfo*, + aPackage.Ptr1() ) ); + break; + // Notify ciphering information change + case ECustomNotifyCipheringInfoChangeIPC: + ret = NotifyCipheringInfoChange( + REINTERPRET_CAST(RMmCustomAPI::TCipheringInfo*, + aPackage.Ptr1() ) ); + break; + // Notify NSPS status + case ECustomNotifyNSPSStatusIPC: + ret = NotifyNSPSStatus ( + REINTERPRET_CAST(RMmCustomAPI::TNspsStatus*, + aPackage.Ptr1() ) ); + break; + // Wake up network from NSPS status + case ECustomNetWakeupIPC: + ret = NetWakeupL( aTsyReqHandle ); + break; + case ECustomClearCallBlackListIPC: + ret = ClearCallBlackListL ( aTsyReqHandle ); + break; + // SS additional info notification + case ECustomSsAdditionalInfoNotificationIPC: + ret = SsAdditionalInfoNotification( + REINTERPRET_CAST( RMmCustomAPI::TSsAdditionalInfo*, + aPackage.Ptr1() ) ); + break; + // Get the air time duration + case ECustomGetAirTimeDurationIPC: + ret = GetAirTimeDuration ( aTsyReqHandle, + REINTERPRET_CAST( TTimeIntervalSeconds*, + aPackage.Ptr1() ) ); + break; + // Check emergency number + case ECustomCheckEmergencyNumberIPC: + ret = CheckEmergencyNumberL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TEmerNumberCheckMode*, + aPackage.Ptr1() ), + REINTERPRET_CAST( TBool*, aPackage.Ptr2() ) ); + break; + // Get Network Operator Name + case ECustomGetNetworkProviderNameIPC: + ret = GetNetworkOperatorNameL( aPackage.Des1u() ); + break; + // Get two digit dial support + case ECustomCheckTwoDigitDialSupportIPC: + ret = CheckTwoDigitDialSupportL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TTwoDigitDialSupport*, + aPackage.Ptr1() ) ); + break; + // Notify when phonebook cache is ready + case ECustomNotifyPndCacheReadyIPC: + ret = NotifyPhoneBookCacheReady( aTsyReqHandle, + REINTERPRET_CAST( TName*, aPackage.Ptr1() ) ); + break; + // Get phonebook cache status + case ECustomGetPndCacheStatusIPC: + ret = GetPndCacheStatus( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TPndCacheStatus*, + aPackage.Ptr1() ), + REINTERPRET_CAST( const TName*, aPackage.Des2u() ) ); + break; + // Get the programmable operator name + case ECustomGetOperatorNameIPC: + ret = GetOperatorNameL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TOperatorNameInfo*, + aPackage.Ptr1() ) ); + break; + // Notify SS Network event + case ECustomNotifySsNetworkEventIPC: + ret = NotifySsNetworkEvent( + REINTERPRET_CAST( RMmCustomAPI::TSsTypeAndMode*, + aPackage.Ptr1() ), + REINTERPRET_CAST( RMmCustomAPI::TSsInfo*, + aPackage.Ptr2() ) ); + break; + // Get the programmable operator logo + case ECustomGetProgrammableOperatorLogoIPC: + ret = GetProgrammableOperatorLogoL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TOperatorId*, + aPackage.Ptr1() ), + REINTERPRET_CAST( RMmCustomAPI::TOperatorLogo*, + aPackage.Ptr2() ) ); + break; + // Sat refresh complete notification + case ECustomSatRefreshCompleteNotificationIPC: + ret = SatRefreshCompleteNotification(); + break; + // Reset the net server + case ECustomResetNetServerIPC: + ret = ResetNetServerL( aTsyReqHandle ); + break; + // Notify Network Connection Failure + case ECustomNotifyNetworkConnectionFailureIPC: + ret = NotifyNetworkConnectionFailure( ); + break; + // Get supported network modes + case ECustomGetSystemNetworkModesIPC: + ret = GetSystemNetworkModesL( aTsyReqHandle, + REINTERPRET_CAST(TUint32*, aPackage.Ptr1()) ); + break; + // Set system network mode + case ECustomSetSystemNetworkModeIPC: + ret = SetSystemNetworkModeL( aTsyReqHandle, + REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*, + aPackage.Ptr1()) ); + break; + // Get current system network mode + case ECustomGetCurrentSystemNetworkModesIPC: + ret = GetCurrentSystemNetworkModeL( aTsyReqHandle, + REINTERPRET_CAST(TUint32*, aPackage.Ptr1()) ); + break; + // Get supported network bands + case ECustomGetBandSelectionIPC: + ret = GetSystemNetworkBandL( aTsyReqHandle, + REINTERPRET_CAST(RMmCustomAPI::TBandSelection*, + aPackage.Ptr1()), + REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*, + aPackage.Ptr2()) ); + break; + // Set system network band + case ECustomSetBandSelectionIPC: + ret = SetSystemNetworkBandL( aTsyReqHandle, + REINTERPRET_CAST(RMmCustomAPI::TBandSelection*, + aPackage.Ptr1() ), + REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*, + aPackage.Ptr2() ) ); + break; + // Notify SS request complete + case ECustomNotifySsRequestCompleteIPC: + ret = SsRequestCompleteNotification( + REINTERPRET_CAST( TInt*, aPackage.Ptr1() ) ); + break; + case ECustomGetLifeTimeIPC: + ret = GetLifeTimeL( aTsyReqHandle, aPackage.Des1n() ); + break; + case ECustomReadSimFileIPC: + ret = GetSimFileInfoL(aTsyReqHandle, aPackage.Des1n(), + aPackage.Des2n()); + break; + // Get 3G phonebook info + case EGet3GPBInfoIPC: + ret = Get3GPBInfo ( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::T3GPBInfo*, + aPackage.Ptr1() ) ); + break; + case ECustomSetDriveModeIPC: + ret = SetDriveModeL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TSetDriveMode*, + aPackage.Ptr1() ) ); + break; + case ECustomSetSimMessageStatusReadIPC: + ret = SetSimMessageStatusReadL( aTsyReqHandle, + *( REINTERPRET_CAST(TTime*, aPackage.Ptr1() ) ), + *( REINTERPRET_CAST(TInt*, aPackage.Ptr2() ) ) ); + break; + case ECustomNotifyRauEventIPC: + ret = NotifyRauEvent( + REINTERPRET_CAST( RMmCustomAPI::TRauEventStatus*, + aPackage.Ptr1() ) ); + break; + case ECustomReadHSxPAStatusIPC: + ret = ReadHSxPAStatusL( aTsyReqHandle, REINTERPRET_CAST( + RMmCustomAPI::THSxPAStatus*, aPackage.Ptr1() ) ); + break; + case ECustomWriteHSxPAStatusIPC: + ret = WriteHSxPAStatusL( aTsyReqHandle, REINTERPRET_CAST( + RMmCustomAPI::THSxPAStatus*, aPackage.Ptr1() ) ); + break; + case ECustomNotifyHSxPAStatusIPC: + ret = NotifyHSxPAStatus( REINTERPRET_CAST( + RMmCustomAPI::THSxPAStatus*, aPackage.Ptr1() ) ); + break; + case ECustomGetIccCallForwardingStatusIPC: + ret = GetIccCallForwardingStatusL( aTsyReqHandle, + aPackage.Des1n() ); + break; + case ECustomNotifyIccCallForwardingStatusChangeIPC: + ret = NotifyIccCallForwardingStatusChange( + aPackage.Des1n() ); + break; + case ECustomNotifyCellInfoChangeIPC: + ret = NotifyCellInfoChange( aPackage.Des1n() ); + break; + case ECustomGetCellInfoIPC: + ret = GetCellInfoL( aPackage.Des1n() ); + break; + case ECustomGetServiceTableSupportbyApplicationIPC: + ret = GetUSIMServiceSupportL( aTsyReqHandle, + REINTERPRET_CAST( RMmCustomAPI::TAppSupport*, + aPackage.Ptr1() ) ); + break; + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: + ret = NotifyRemoteAlertingToneStatusChange( + REINTERPRET_CAST( + RMmCustomAPI::TRemoteAlertingToneStatus*, + aPackage.Ptr1() ) ); + break; + default: + // ret is already set as KErrNotSupported +TFLOGSTRING2("TSY: CMmCustomTsy::DoExtFuncL unsupported ipc=%d", aIpc); + break; + } + + // save request handle + if ( ECustomTsyReqHandleUnknown != iReqHandleType ) + { +#ifdef REQHANDLE_TIMER + // set timer for the request + SetTypeOfResponse ( iReqHandleType, aTsyReqHandle ); +#else + iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, + aTsyReqHandle ); +#endif // REQHANDLE_TIMER + } + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::RegisterNotification +// Called when the server recognises that this notification is being posted +// for the first time on this sub-session object. It enables the TSY to +// "turn on" any regular notification messages that it may receive from DOS. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::RegisterNotification( + const TInt aIpc ) + { + TInt ret ( KErrNotSupported ); + + switch( aIpc ) + { + case ECustomNotifyRauEventIPC: + case ECustomNotifyDtmfEventIPC: + case ECustomNotifyAlsBlockedChangedIPC: + case ECustomNotifyCipheringInfoChangeIPC: + case ECustomNotifyNSPSStatusIPC: + case ECustomSsAdditionalInfoNotificationIPC: + case ECustomNotifySsRequestCompleteIPC: + case ECustomNotifyPndCacheReadyIPC: + case ECustomNotifySsNetworkEventIPC: + case ECustomSatRefreshCompleteNotificationIPC: + case ECustomNotifyNetworkConnectionFailureIPC: + case ECustomNotifyHSxPAStatusIPC: + case ECustomNotifyIccCallForwardingStatusChangeIPC: + case ECustomNotifyCellInfoChangeIPC: + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: + ret = KErrNone; + break; + + default: + if ( iMmCustomVendorExt->SupportingIPC( aIpc ) ) + { + ret = iMmCustomVendorExt->RegisterNotification( aIpc ); + } + else + { + ret = CMmTsyBase::RegisterNotification( aIpc ); + } + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::DeregisterNotification +// Called when the server recognises that this notification will not be posted +// again because the last client to have a handle on this sub-session object +// has just closed the handle. It enables the TSY to "turn off" any regular +// notification messages that it may receive from DOS. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::DeregisterNotification( + const TInt aIpc ) + { + TInt ret ( KErrNotFound ); + + switch( aIpc ) + { + case ECustomNotifyRauEventIPC: + case ECustomNotifyDtmfEventIPC: + case ECustomNotifyAlsBlockedChangedIPC: + case ECustomNotifyCipheringInfoChangeIPC: + case ECustomNotifyNSPSStatusIPC: + case ECustomSsAdditionalInfoNotificationIPC: + case ECustomNotifySsRequestCompleteIPC: + case ECustomNotifyPndCacheReadyIPC: + case ECustomNotifySsNetworkEventIPC: + case ECustomSatRefreshCompleteNotificationIPC: + case ECustomNotifyNetworkConnectionFailureIPC: + case ECustomNotifyHSxPAStatusIPC: + case ECustomNotifyIccCallForwardingStatusChangeIPC: + case ECustomNotifyCellInfoChangeIPC: + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: + ret = KErrNone; + break; + default: + if ( iMmCustomVendorExt->SupportingIPC( aIpc ) ) + { + ret = iMmCustomVendorExt->DeregisterNotification( aIpc ); + } + else + { + ret = CMmTsyBase::DeregisterNotification( aIpc ); + } + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ReqModeL +// Returns request mode for given IPC. If the IPC number belongs to some of +// the Custom API functions. +// Possible return values: +// tsy has own buffering =0x00000000 +// KReqModeMultipleCompletionEnabled=0x00000001 +// KReqModeFlowControlObeyed=0x00000002 +// KReqModeRePostImmediately=0x00000004 +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +CTelObject::TReqMode CMmCustomTsy::ReqModeL( + const TInt aIpc ) + { + CTelObject::TReqMode ret = 0; + + switch ( aIpc ) + { + // methods using DOS + case ECustomNetWakeupIPC: + case ECustomGetNetworkProviderNameIPC: + case ECustomCheckTwoDigitDialSupportIPC: + case ECustomGetOperatorNameIPC: + case ECustomResetNetServerIPC: + ret = KReqModeFlowControlObeyed; + break; + + //TSYs wishing to implement their own buffering can return 0 + case ECustomSetAlsBlockedIPC: + case ECustomSetDriveModeIPC: + ret = 0; + break; + + // Notifications + case ECustomNotifyRauEventIPC: + case ECustomNotifyDtmfEventIPC: + case ECustomNotifyAlsBlockedChangedIPC: + case ECustomNotifyCipheringInfoChangeIPC: + case ECustomNotifyNSPSStatusIPC: + case ECustomSsAdditionalInfoNotificationIPC: + case ECustomNotifyPndCacheReadyIPC: + case ECustomNotifySsNetworkEventIPC: + case ECustomSatRefreshCompleteNotificationIPC: + case ECustomNotifyNetworkConnectionFailureIPC: + case ECustomNotifySsRequestCompleteIPC: + case ECustomNotifyHSxPAStatusIPC: + case ECustomNotifyIccCallForwardingStatusChangeIPC: + case ECustomNotifyCellInfoChangeIPC: + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: + ret = KReqModeRePostImmediately | + KReqModeMultipleCompletionEnabled; + break; + + // methods that are using DOS but have own flow control system + case ECustomGetProgrammableOperatorLogoIPC: + case ECustomTerminateCallIPC: + case ECustomCheckEmergencyNumberIPC: + case ECustomCheckAlsPpSupportIPC: + case ECustomGetAlsBlockedIPC: + case ECustomGetCipheringInfoIPC: + case ECustomClearCallBlackListIPC: + case ECustomGetSystemNetworkModesIPC: + case ECustomSetSystemNetworkModeIPC: + case ECustomGetCurrentSystemNetworkModesIPC: + case ECustomReadHSxPAStatusIPC: + case ECustomWriteHSxPAStatusIPC: + case ECustomGetIccCallForwardingStatusIPC: + case ECustomGetCellInfoIPC: + case ECustomGetBandSelectionIPC: + case ECustomSetBandSelectionIPC: + + // methods not using DOS + case ECustomCallOriginIPC: + case ECustomGetDiagnosticOctetsIPC: + case ECustomGetAirTimeDurationIPC: + case ECustomGetRemoteAlertingToneStatusIPC: + case ECustomGetPndCacheStatusIPC: + case ECustomGetLifeTimeIPC: + case ECustomReadSimFileIPC: + case EGet3GPBInfoIPC: + case EMobilePhoneIMSAuthenticate: + case ECustomGetSimAuthenticationDataIPC: + case ECustomGetServiceTableSupportbyApplicationIPC: + + // from Security Tsy + case ECustomCheckSecurityCodeIPC: + case ECustomIsBlockedIPC: + case ECustomDisablePhoneLockIPC: + case ECustomGetActivePinIPC: + case ECustomSetSimMessageStatusReadIPC: + ret = 0; + break; + default: + if ( iMmCustomVendorExt->SupportingIPC( aIpc ) ) + { + ret = iMmCustomVendorExt->ReqModeL( aIpc ); + } + else + { + ret = CMmTsyBase::ReqModeL ( aIpc ); + } + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NumberOfSlotsL +// Returns number of slots to be used for given IPC. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NumberOfSlotsL( + const TInt aIpc ) + { + TInt numberOfSlots ( KMmCustomDefaultSlots ); + + switch ( aIpc ) + { + case ECustomNotifyDtmfEventIPC: + numberOfSlots = KMmCustomNotifyDtmfEventSlots; + break; + case ECustomNotifyRauEventIPC: + case ECustomNotifyAlsBlockedChangedIPC: + case ECustomNotifyCipheringInfoChangeIPC: + case ECustomNotifyNSPSStatusIPC: + case ECustomSsAdditionalInfoNotificationIPC: + case ECustomNotifySsRequestCompleteIPC: + case ECustomNotifyPndCacheReadyIPC: + case ECustomNotifySsNetworkEventIPC: + case ECustomSatRefreshCompleteNotificationIPC: + case ECustomNotifyNetworkConnectionFailureIPC: + case ECustomNotifyHSxPAStatusIPC: + case ECustomNotifyIccCallForwardingStatusChangeIPC: + case ECustomNotifyCellInfoChangeIPC: + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: + break; + + default: + if ( iMmCustomVendorExt->SupportingIPC( aIpc ) ) + { + numberOfSlots = iMmCustomVendorExt->NumberOfSlotsL( aIpc ); + } + else + { + numberOfSlots = CMmTsyBase:: NumberOfSlotsL( aIpc ); + } + break; + } + + return numberOfSlots; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetRequiredPlatSecCaps +// ETel server calls this method to find out capabilities of custom IPCs. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TSecurityPolicy CMmCustomTsy::GetRequiredPlatSecCaps( + const TInt aIpc ) + { +TFLOGSTRING2( "TSY: CMmCustomTsy::GetRequiredPlatSecCaps ipc=%d", aIpc ); + // assume fail as default return value + TSecurityPolicy policy( TSecurityPolicy::EAlwaysFail ); + + // deal with cancellations + TInt ipc ( aIpc ); + if (ipc >= KIpcCustomExt + EMobileCancelOffset) + { + ipc -= EMobileCancelOffset; +TFLOGSTRING2("TSY: CMmCustomTsy::GetRequiredPlatSecCaps cancel for ipc=%d", ipc); + } + + switch ( ipc ) + { + case ECustomNotifyRauEventIPC: + case ECustomSatRefreshCompleteNotificationIPC: // To be removed + case ECustomNotifyPndCacheReadyIPC: + case ECustomGetPndCacheStatusIPC: + case EGet3GPBInfoIPC: + case ECustomNotifyDtmfEventIPC: + case ECustomGetRemoteAlertingToneStatusIPC: + case ECustomCallOriginIPC: + case ECustomGetAlsBlockedIPC: + case ECustomNotifyAlsBlockedChangedIPC: + case ECustomCheckAlsPpSupportIPC: + case ECustomCheckEmergencyNumberIPC: + case ECustomGetCipheringInfoIPC: + case ECustomNotifyCipheringInfoChangeIPC: + case ECustomNotifyNSPSStatusIPC: + case ECustomNotifyProgrammableOperatorLogoChangeIPC: + case ECustomNotifyNetworkConnectionFailureIPC: + case ECustomNotifySsRequestCompleteIPC: + case ECustomGetActivePinIPC: + case ECustomGetSystemNetworkModesIPC: + case ECustomGetCurrentSystemNetworkModesIPC: + case ECustomGetATRIPC: + case ECustomNotifySimCardStatusIPC: + case ECustomGetSimCardReaderStatusIPC: + case ECustomNotifyHSxPAStatusIPC: + case ECustomNotifyIccCallForwardingStatusChangeIPC: + case ECustomNotifyCellInfoChangeIPC: + case ECustomGetBandSelectionIPC: + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=None"); + policy = TSecurityPolicy( TSecurityPolicy::EAlwaysPass ); + break; + + // NetworkControl + case ECustomResetNetServerIPC: + case ECustomSetSystemNetworkModeIPC: + case ECustomSimWarmResetIPC: + case ECustomSetBandSelectionIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkControl"); + policy = TSecurityPolicy( ECapabilityNetworkControl ); + break; + + // NetworkControl, PowerMgmt + case ECustomPowerSimOnIPC: + case ECustomPowerSimOffIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkControl, PowerMgmt"); + policy = TSecurityPolicy( ECapabilityNetworkControl, + ECapabilityPowerMgmt ); + break; + + // NetworkControl, ReadDeviceData + case ECustomReleaseFileIPC: + case ECustomRestartFileIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkControl, ReadDeviceData"); + policy = TSecurityPolicy( ECapabilityNetworkControl, + ECapabilityReadDeviceData ); + break; + + // NetworkServices + case ECustomTerminateCallIPC: + case ECustomCancelUssdSessionIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkServices"); + policy = TSecurityPolicy( ECapabilityNetworkServices ); + break; + + // NetworkServices, WriteDeviceData + case ECustomSetDriveModeIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=NetworkServices, WriteDeviceData"); + policy = TSecurityPolicy( ECapabilityNetworkServices, + ECapabilityWriteDeviceData ); + break; + + // ReadDeviceData + case EReadViagHomeZoneParamsIPC: + case ECustomGetNetworkProviderNameIPC: + case ECustomGetDiagnosticOctetsIPC: + case ECustomGetLifeTimeIPC: + case ECustomGetOperatorNameIPC: + case ECustomGetProgrammableOperatorLogoIPC: + case ECustomSsAdditionalInfoNotificationIPC: + case ECustomIsBlockedIPC: + case ECustomCheckTwoDigitDialSupportIPC: + case ECustomNotifyEGprsInfoChange: + case ECustomGetEGprsInfo: + case EMobilePhoneIMSAuthenticate: + case ECustomReadHSxPAStatusIPC: + case ECustomGetIccCallForwardingStatusIPC: + case ECustomGetCellInfoIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData"); + policy = TSecurityPolicy( ECapabilityReadDeviceData ); + break; + + // ReadDeviceData, Location + case EReadViagHomeZoneCacheIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, Location"); + policy = TSecurityPolicy( ECapabilityReadDeviceData, + ECapabilityLocation ); + break; + + // ReadDeviceData, ReadUserData + case ECustomNotifySsNetworkEventIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy= ReadDeviceData, ReadUserData"); + policy = TSecurityPolicy( ECapabilityReadDeviceData, + ECapabilityReadUserData ); + break; + + // ReadDeviceData, ReadUserData, Location + case ECustomReadSimFileIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, ReadUserData, Location"); + policy = TSecurityPolicy( ECapabilityReadDeviceData, + ECapabilityReadUserData, + ECapabilityLocation ); + break; + + // ReadDeviceData, ReadUserData, WriteUserData, NetworkControl + case ECustomGetSimAuthenticationDataIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, ReadUserData, WriteUserData, NetworkControl"); + policy = TSecurityPolicy( ECapabilityReadDeviceData, + ECapabilityReadUserData, + ECapabilityWriteUserData, + ECapabilityNetworkControl ); + break; + + case ECustomGetServiceTableSupportbyApplicationIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData"); + policy = TSecurityPolicy( ECapabilityReadDeviceData ); + break; + // ReadDeviceData, WriteDeviceData, ReadUserData, WriteUserData, + // Location, NetworkServices, NetworkControl + case ECustomSendAPDUReqIPC: + case ECustomSendAPDUReqV2IPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadDeviceData, WriteDeviceData, ReadUserData, WriteUserData, Location, NetworkServices, NetworkControl"); + policy = TSecurityPolicy( ECapabilityReadDeviceData, + ECapabilityWriteDeviceData, + ECapabilityReadUserData, + ECapabilityWriteUserData, + ECapabilityLocation, + ECapabilityNetworkServices, + ECapabilityNetworkControl ); + break; + + // ReadUserData + case ECustomStartSimCbTopicBrowsingIPC: + case ECustomGetNextSimCbTopicIPC: + case ECustomGetAirTimeDurationIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=ReadUserData"); + policy = TSecurityPolicy( ECapabilityReadUserData ); + break; + + // WriteDeviceData + case ECustomSetAlwaysOnMode: + case ECustomSimLockActivateIPC: + case ECustomSimLockDeActivateIPC: + case ECustomSetAlsBlockedIPC: + case ECustomClearCallBlackListIPC: + case ECustomNetWakeupIPC: + case ECustomCheckSecurityCodeIPC: + case ECustomDisablePhoneLockIPC: + case ECustomSetSimMessageStatusReadIPC: + case ECustomWriteHSxPAStatusIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteDeviceData"); + policy = TSecurityPolicy( ECapabilityWriteDeviceData ); + break; + + // WriteDeviceData, Location + case EWriteViagHomeZoneCacheIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteDeviceData, Location"); + policy = TSecurityPolicy( ECapabilityWriteDeviceData, + ECapabilityLocation ); + break; + + // WriteUserData + case ECustomDeleteSimCbTopicIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteUserData"); + policy = TSecurityPolicy( ECapabilityWriteUserData ); + break; + + // WriteDeviceData + case EWriteViagHomeZoneUHZIUESettingsIPC: +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=WriteDeviceData"); + policy = TSecurityPolicy( ECapabilityWriteDeviceData ); + break; + default: + if ( iMmCustomVendorExt->SupportingIPC(ipc) ) + { + policy = iMmCustomVendorExt->GetRequiredPlatSecCaps(ipc); + } + else + { + // if none of the above then we end up here, + // as a default we already have caps as alwaysfail. +TFLOGSTRING("TSY: CMmCustomTsy::GetRequiredPlatSecCaps policy=AlwaysFail"); + } + break; + } + + return policy; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CancelService +// When the clients close their sub-sessions (eg. by calling RPhone::Close), +// they may not have cancelled all their outstanding asynchronous requests +// before closing. It is up to the ETel server to clean up in this situation, +// so the server will find the list of outstanding requests related to that +// sub-session object and pass these outstanding IPC request numbers, one at +// a time, to the CancelService function in the TSY. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CancelService( + const TInt aIpc, + const TTsyReqHandle aTsyReqHandle ) + { + TInt ret ( KErrGeneral ); + + // When the clients close their sub-sessions (eg. by calling + // RPhone::Close), they may not have cancelled all their outstanding + // asynchronous requests before closing. It is up to the ETel server to + // clean up in this situation, so the server will find the list of + // outstanding requests related to that sub-session object and pass these + // outstanding IPC request numbers, one at a time, to the CancelService + // function in the TSY. + + switch ( aIpc ) + { + case ECustomTerminateCallIPC: + case ECustomSetAlsBlockedIPC: + case ECustomNetWakeupIPC: + case ECustomClearCallBlackListIPC: + case ECustomResetNetServerIPC: + case ECustomGetPndCacheStatusIPC: + case ECustomSetDriveModeIPC: + case ECustomSetBandSelectionIPC: + case ECustomSetSystemNetworkModeIPC: + // TSY has started a request and it is not possible to then + // cancel it. The best thing for the TSY to do in + // this case is to proceed as though the Cancel never happened. + // The server's call to the TSY cancel function will return + // synchronously. The TSY then continues to wait for the methods + // acknowledgement and when it receives it, the TSY will complete + // the original request. + ret = KErrNone; + break; + case ECustomNotifyRauEventIPC: + ret = NotifyRauEventCancel(); + break; + case ECustomNotifyDtmfEventIPC: + ret = NotifyDtmfEventCancel( aTsyReqHandle ); + break; + case ECustomGetAlsBlockedIPC: + ret = GetAlsBlockedCancel (); + break; + case ECustomGetCipheringInfoIPC: + ret = GetCipheringInfoCancel(); + break; + case ECustomNotifyCipheringInfoChangeIPC: + ret = NotifyCipheringInfoChangeCancel( aTsyReqHandle ); + break; + case ECustomNotifyNSPSStatusIPC: + ret = NotifyNSPSStatusCancel( aTsyReqHandle ); + break; + case ECustomNotifyAlsBlockedChangedIPC: + ret = NotifyAlsBlockedChangedCancel( aTsyReqHandle ); + break; + case ECustomCheckAlsPpSupportIPC: + ret = GetAlsPpSupportCancel(); + break; + case ECustomSsAdditionalInfoNotificationIPC: + ret = SsAdditionalInfoNotificationCancel( aTsyReqHandle ); + break; + case ECustomNotifySsRequestCompleteIPC: + ret = SsRequestCompleteNotificationCancel( aTsyReqHandle ); + break; + case ECustomNotifyPndCacheReadyIPC: + ret = NotifyPhoneBookCacheReadyCancel( aTsyReqHandle ); + break; + case ECustomCheckEmergencyNumberIPC: + ret = CheckEmergencyNumberCancel(); + break; + case ECustomGetNetworkProviderNameIPC: + ret = GetNetworkOperatorNameCancel(); + break; + case ECustomCheckTwoDigitDialSupportIPC: + ret = CheckTwoDigitDialSupportCancel(); + break; + case ECustomGetOperatorNameIPC: + ret = GetOperatorNameCancel(); + break; + case ECustomNotifySsNetworkEventIPC: + ret = NotifySsNetworkEventCancel(); + break; + case ECustomGetProgrammableOperatorLogoIPC: + ret = GetProgrammableOperatorLogoCancel(); + break; + case ECustomSatRefreshCompleteNotificationIPC: + ret = SatRefreshCompleteNotificationCancel( aTsyReqHandle ); + break; + case ECustomGetCurrentSystemNetworkModesIPC: + ret = GetCurrentSystemNetworkModeCancel( aTsyReqHandle ); + break; + case ECustomNotifyNetworkConnectionFailureIPC: + ret = NotifyNetworkConnectionFailureCancel(); + break; + case ECustomReadSimFileIPC: + ret = GetSimFileInfoCancel( aTsyReqHandle ); + break; + case ECustomGetLifeTimeIPC: + ret = GetLifeTimeCancel(); + break; + case EGet3GPBInfoIPC: + ret = Get3GPBInfoCancel (); + break; + case ECustomGetSystemNetworkModesIPC: + ret = GetSystemNetworkModesCancel( aTsyReqHandle ); + break; + case EMobilePhoneIMSAuthenticate: + ret = ImsAuthenticationCancel(); + break; + case ECustomGetSimAuthenticationDataIPC: + ret = SimAuthenticationCancel(); + break; + case ECustomReadHSxPAStatusIPC: + ret = ReadHSxPAStatusCancel(); + break; + case ECustomWriteHSxPAStatusIPC: + ret = WriteHSxPAStatusCancel(); + break; + case ECustomNotifyHSxPAStatusIPC: + ret = NotifyHSxPAStatusCancel(); + break; + case ECustomNotifyIccCallForwardingStatusChangeIPC: + ret = NotifyIccCallForwardingStatusChangeCancel( aTsyReqHandle ); + break; + case ECustomGetIccCallForwardingStatusIPC: + ret = GetIccCallForwardingStatusCancel(); + break; + case ECustomNotifyCellInfoChangeIPC: + ret = NotifyCellInfoChangeCancel(); + break; + case ECustomGetCellInfoIPC: + ret = GetCellInfoCancel(); + break; + case ECustomGetBandSelectionIPC: + ret = GetSystemNetworkBandCancel( aTsyReqHandle ); + break; + case ECustomGetServiceTableSupportbyApplicationIPC: + ret = GetUSIMServiceSupportCancel(); + break; + case ECustomNotifyRemoteAlertingToneStatusChangeIPC: + ret = NotifyRemoteAlertingToneStatusChangeCancel(); + break; + case ECustomTsyGetIccCallForwardingStatus: + ret = GetIccCallForwardingStatusCancel( aTsyReqHandle ); + break; + default: + if ( iMmSecurityTsy->SupportingIPC( aIpc ) ) + { + ret = iMmSecurityTsy->CancelService ( aIpc, + aTsyReqHandle ); + } + else if ( iMmCustomVendorExt->SupportingIPC( aIpc ) ) + { + ret = iMmCustomVendorExt->CancelService ( aIpc, + aTsyReqHandle ); + } + else + { + ret = CMmTsyBase::CancelService ( aIpc, aTsyReqHandle ); + } + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::IMSAuthenticationL +// Requests authentication data generatation from input parameters +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ImsAuthenticationL( + const TTsyReqHandle aTsyReqHandle, + RMobilePhone::TImsAuthenticateDataV5* aAuthenticationData ) + { + // Save pointer to client space + iIMSAuthenticationData = aAuthenticationData; + + CMmDataPackage authenticationDataPackage; + authenticationDataPackage.PackData( iIMSAuthenticationData ); + + TInt ret = ( iMmPhoneTsy->MessageManager()->HandleRequestL( + EMobilePhoneIMSAuthenticate, &authenticationDataPackage ) ); + + // Check response of the extension + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyIMSAuthenticate; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteImsAuthentication +// Requests authentication data generatation from input parameters +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteImsAuthentication( + CMmDataPackage* aDataPackage, + TInt aResult ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyIMSAuthenticate ); + + if ( KErrNone == aResult ) + { + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + RMobilePhone::TImsAuthenticateDataV5* authenticationData; + aDataPackage->UnPackData( &authenticationData ); + + // Copy data to client + iIMSAuthenticationData->iRES.Copy( authenticationData->iRES ); + iIMSAuthenticationData->iCK.Copy( authenticationData->iCK ); + iIMSAuthenticationData->iIK.Copy( authenticationData->iIK ); + + iIMSAuthenticationData = NULL; + + ReqCompleted( reqHandle, aResult ); + } + } + else if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrTimedOut == aResult ) + { + iIMSAuthenticationData = NULL; + } + else + { + RMobilePhone::TImsAuthenticateDataV5* authenticationData; + aDataPackage->UnPackData( &authenticationData ); + + // It is possible that request is completed whithout any data + // inside datapackage + if ( NULL != authenticationData ) + { + iIMSAuthenticationData->iAUTS.Copy( + authenticationData->iAUTS ); + + iIMSAuthenticationData = NULL; + } + } + + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ImsAuthenticationCancel +// Cancels sim authentication request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ImsAuthenticationCancel() + { + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyIMSAuthenticate ); + + // reset pointer to client data + iIMSAuthenticationData = NULL; + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SimAuthenticationL +// Gets authentication parameters from sim +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SimAuthenticationL( + const TTsyReqHandle aTsyReqHandle, + const TDataPackage& aAuthData ) + { + TInt ret ( KErrNone ); + TInt rfStateInfo ( ERfsStateInfoNormal ); + +TFLOGSTRING( "CMmCustomTSY: CMmCustomTsy::SimAuthentication" ); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle(ECustomTsyGetSimAuthenticationData); + if(0 < reqHandle) + { + return KErrServerBusy; + } + + + + RMmCustomAPI::TSimAuthenticationBase* basePtr = + REINTERPRET_CAST( RMmCustomAPI::TSimAuthenticationBase*, + aAuthData.Ptr1() ); + + CMmDataPackage authenticationDataPackage; + + rfStateInfo = iMmPhoneTsy->GetRfStatus(); + + // Declare a RAND sized buffer + TBuf8<16> rand; + + if ( RMmCustomAPI::TSimAuthenticationBase::EEapSim == + basePtr->ExtensionId() ) + { + iEapSim = REINTERPRET_CAST( RMmCustomAPI::TSimAuthenticationEapSim*, + basePtr ); + + rand.Append( iEapSim->iRandomParameters ); + + authenticationDataPackage.PackData( iEapSim, &rfStateInfo ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EEapAka == + basePtr->ExtensionId() ) + { + iEapAka = REINTERPRET_CAST( RMmCustomAPI::TSimAuthenticationEapAka*, + basePtr ); + + rand.Append( iEapAka->iRandomParameters ); + + authenticationDataPackage.PackData( iEapAka, &rfStateInfo ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrap == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::in EGbaBootstrap" ); + iGbaBootstrap = REINTERPRET_CAST( + RMmCustomAPI::TSimAuthenticationGbaBootstrap*, basePtr ); + + rand.Append( iGbaBootstrap->iRandomParameters ); + + authenticationDataPackage.PackData( iGbaBootstrap, &rfStateInfo ); +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::out EGbaBootstrap" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapUpdate == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::in EGbaBootstrapUpdate" ); + iGbaBootstrapUpdate = REINTERPRET_CAST( + RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate*, basePtr ); + + authenticationDataPackage.PackData( iGbaBootstrapUpdate, &rfStateInfo ); +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::out EGbaBootstrapUpdate" ); + } + else if ( + RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapNafDerivation == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::in EGbaBootstrapNafDerivation" ); + iGbaNafDerivation = REINTERPRET_CAST( + RMmCustomAPI::TSimAuthenticationGbaNafDerivation*, basePtr ); + + authenticationDataPackage.PackData( iGbaNafDerivation, &rfStateInfo ); +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::out EGbaBootstrapNafDerivation" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EMgvMskUpdate == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::in EMgvMskUpdate" ); + iMgvMskUpdate = REINTERPRET_CAST( + RMmCustomAPI::TSimAuthenticationMgvMskUpdate*, basePtr ); + + authenticationDataPackage.PackData( iMgvMskUpdate, &rfStateInfo ); +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::out EMgvMskUpdate" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EMgvMtkGeneration == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::in EMgvMtkGeneration" ); + iMgvMtkGeneration = REINTERPRET_CAST( + RMmCustomAPI::TSimAuthenticationMgvMtkGeneration*, basePtr ); + + authenticationDataPackage.PackData( iMgvMtkGeneration, &rfStateInfo ); +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::out EMgvMtkGeneration" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EMgvMskDeletion == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::in EMgvMskDeletion" ); + iMgvMskDeletion = REINTERPRET_CAST( + RMmCustomAPI::TSimAuthenticationMgvMskDeletion*, basePtr ); + + authenticationDataPackage.PackData( iMgvMskDeletion, &rfStateInfo ); +TFLOGSTRING( "CMmCustomTSY: SimAuthenticationL::out EMgvMskDeletion" ); + } + else + { +TFLOGSTRING2( "CMmCustomTSY: Invalid authentication type specified: %d", basePtr->ExtensionId() ); + ret = KErrNotSupported; + + iEapSim = NULL; + iEapAka = NULL; + iGbaBootstrap = NULL; + iGbaBootstrapUpdate = NULL; + iGbaNafDerivation = NULL; + iMgvMskUpdate = NULL; + iMgvMtkGeneration = NULL; + iMgvMskDeletion = NULL; + + //ReqCompleted( aTsyReqHandle, ret ); + } + + // Check if Rand received from network is valid + // when if basePtr has ExtensionId of EEapSim or EEapAka + if ( RMmCustomAPI::TSimAuthenticationBase::EEapSim == + basePtr->ExtensionId() || RMmCustomAPI::TSimAuthenticationBase:: + EEapAka == basePtr->ExtensionId())/* || RMmCustomAPI:: + TSimAuthenticationBase::EGbaBootstrap == basePtr->ExtensionId())*/ + { + ret = CheckRandValidityL( rand ); + } + + if ( KErrNone == ret ) + { + ret = ( iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomGetSimAuthenticationDataIPC, &authenticationDataPackage ) ); + + // check result + if ( KErrNone == ret ) + { + // Save the req handle type + iReqHandleType = ECustomTsyGetSimAuthenticationData; + } + else + { + iEapSim = NULL; + iEapAka = NULL; + iGbaBootstrap = NULL; + iGbaBootstrapUpdate = NULL; + iGbaNafDerivation = NULL; + iMgvMskUpdate = NULL; + iMgvMtkGeneration = NULL; + iMgvMskDeletion = NULL; + + ReqCompleted( aTsyReqHandle, ret ); + } + } + else + { + iEapSim = NULL; + iEapAka = NULL; + iGbaBootstrap = NULL; + iGbaBootstrapUpdate = NULL; + iGbaNafDerivation = NULL; + iMgvMskUpdate = NULL; + iMgvMtkGeneration = NULL; + iMgvMskDeletion = NULL; + + ReqCompleted( aTsyReqHandle, ret ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSimAuthentication +// Completes sim authenticaiton request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSimAuthentication( + CMmDataPackage* aDataPackage, + TInt aResult ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::CompleteSimAuthentication" ); + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSimAuthenticationData ); + + if ( KErrNone == aResult ) + { + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + RMmCustomAPI::TSimAuthenticationBase* basePtr; + aDataPackage->UnPackData( &basePtr ); + + // if 2G authentication needs to be completed + if ( RMmCustomAPI::TSimAuthenticationBase::EEapSim == + basePtr->ExtensionId() ) + { + RMmCustomAPI::TSimAuthenticationEapSim* eapSim; + + aDataPackage->UnPackData( &eapSim ); + + // Copy data to client + iEapSim->iSRES.Copy( eapSim->iSRES ); + iEapSim->iKC.Copy( eapSim->iKC ); + + iEapSim = NULL; + + ReqCompleted( reqHandle, aResult ); + } + // if 3G authentication needs to be completed + else if ( RMmCustomAPI::TSimAuthenticationBase::EEapAka == + basePtr->ExtensionId() ) + { + RMmCustomAPI::TSimAuthenticationEapAka* eapAka; + + aDataPackage->UnPackData( &eapAka ); + + // Copy data to client + iEapAka->iRES.Copy( eapAka->iRES ); + iEapAka->iCK.Copy( eapAka->iCK ); + iEapAka->iIK.Copy( eapAka->iIK ); + + iEapAka = NULL; + + ReqCompleted( reqHandle, aResult ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrap == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::in EGbaBootstrap" ); + RMmCustomAPI::TSimAuthenticationGbaBootstrap* gbaBootstrap; + + aDataPackage->UnPackData( &gbaBootstrap ); + + // Copy data to client + iGbaBootstrap->iRES.Copy( gbaBootstrap->iRES ); + iGbaBootstrap->iAUTS.Copy( gbaBootstrap->iAUTS ); + + iGbaBootstrap = NULL; + + ReqCompleted( reqHandle, aResult ); +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::out EGbaBootstrap" ); + } + else if ( + RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrapUpdate == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::in EGbaBootstrapUpdate" ); + RMmCustomAPI::TSimAuthenticationGbaBootstrapUpdate* + gbaBootstrapUpdate; + + aDataPackage->UnPackData( &gbaBootstrapUpdate ); + + // Copy data to client + iGbaBootstrapUpdate->iRandomParameters.Copy( + gbaBootstrapUpdate->iRandomParameters ); + + iGbaBootstrapUpdate = NULL; + + ReqCompleted( reqHandle, aResult ); +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::out EGbaBootstrapUpdate" ); + } + else if ( + RMmCustomAPI::TSimAuthenticationBase:: + EGbaBootstrapNafDerivation == basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::in EGbaBootstrapNafDerivation" ); + RMmCustomAPI::TSimAuthenticationGbaNafDerivation* + gbaNafDerivation; + + aDataPackage->UnPackData( &gbaNafDerivation ); + + // Copy data to client + iGbaNafDerivation->iKsExtNaf.Copy( + gbaNafDerivation->iKsExtNaf ); + + iGbaNafDerivation = NULL; + + ReqCompleted( reqHandle, aResult ); +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::out EGbaBootstrapNafDerivation" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase::EMgvMskUpdate == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::in EMgvMskUpdate" ); + RMmCustomAPI::TSimAuthenticationMgvMskUpdate* mgvMskUpdate; + + aDataPackage->UnPackData( &mgvMskUpdate ); + + // Copy data to client + iMgvMskUpdate->iMikey.Copy( mgvMskUpdate->iMikey ); + // Smartcard support for MobileTV + iMgvMskUpdate->iBCASTManagement.Copy( mgvMskUpdate->iBCASTManagement ); + iMgvMskUpdate->iParentalRating.Copy( mgvMskUpdate->iParentalRating ); + iMgvMskUpdate->iSecurityPolicyExt.Copy( mgvMskUpdate->iSecurityPolicyExt ); + + iMgvMskUpdate = NULL; + + ReqCompleted( reqHandle, aResult ); +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::out EMgvMskUpdate" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase:: + EMgvMtkGeneration == basePtr->ExtensionId() ) + { +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::in EMgvMtkGeneration" ); + RMmCustomAPI::TSimAuthenticationMgvMtkGeneration* + mgvMtkGeneration; + + aDataPackage->UnPackData( &mgvMtkGeneration ); + + // Copy data to client + iMgvMtkGeneration->iMtkSalt.Copy( mgvMtkGeneration->iMtkSalt ); + // Smartcard support for MobileTV + iMgvMtkGeneration->iBCASTManagement.Copy( mgvMtkGeneration->iBCASTManagement ); + iMgvMtkGeneration->iParentalControl.Copy( mgvMtkGeneration->iParentalControl ); + iMgvMtkGeneration->iTrafficEncryptionKey.Copy( mgvMtkGeneration->iTrafficEncryptionKey ); + iMgvMtkGeneration = NULL; + + ReqCompleted( reqHandle, aResult ); +TFLOGSTRING( "CMmCustomTSY: CompleteSimAuthentication::out EMgvMtkGeneration" ); + } + else if ( RMmCustomAPI::TSimAuthenticationBase:: + EMgvMskDeletion == basePtr->ExtensionId() ) + { + ReqCompleted( reqHandle, aResult ); + } + else + { +TFLOGSTRING2( "CMmCustomTSY: Invalid authentication type specified: %d", basePtr->ExtensionId() ); + aResult = KErrArgument; + ReqCompleted( reqHandle, aResult ); + } + } + } + else if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrTimedOut == aResult ) + { + iEapSim = NULL; + iEapAka = NULL; + } + else + { + RMmCustomAPI::TSimAuthenticationBase* basePtr; + aDataPackage->UnPackData( &basePtr ); + + // if no datapackage is received in error response + if ( NULL == basePtr ) + { + iEapAka = NULL; + iEapSim = NULL; + } + else + { + // if 3G authentication needs to be completed + // copy AUTS sequence to client + if ( RMmCustomAPI::TSimAuthenticationBase::EEapAka == + basePtr->ExtensionId() ) + { + RMmCustomAPI::TSimAuthenticationEapAka* eapAka; + aDataPackage->UnPackData( &eapAka ); + + iEapAka->iAUTS.Copy( eapAka->iAUTS ); + + iEapAka = NULL; + } + + else if( RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrap == + basePtr->ExtensionId() ) + { +TFLOGSTRING( "TSYMH: CompleteSimAuthentication RMmCustomAPI::TSimAuthenticationBase::EGbaBootstrap" ); + RMmCustomAPI::TSimAuthenticationGbaBootstrap* gbabootstrap; + aDataPackage->UnPackData( &gbabootstrap ); + + iGbaBootstrap->iAUTS.Copy( gbabootstrap->iAUTS ); + } + + iEapSim = NULL; + } + } + + // reset pointer to client data + iGbaBootstrap = NULL; + iGbaBootstrapUpdate = NULL; + iMgvMskUpdate = NULL; + iMgvMtkGeneration = NULL; + iMgvMskDeletion = NULL; + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SimAuthenticationCancel +// Cancels sim authentication request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SimAuthenticationCancel() + { + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSimAuthenticationData ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset pointer to client data + iEapSim = NULL; + iEapAka = NULL; + iGbaBootstrap = NULL; + iGbaBootstrapUpdate = NULL; + iMgvMskUpdate = NULL; + iMgvMtkGeneration = NULL; + iMgvMskDeletion = NULL; + + // complete + ReqCompleted( reqHandle, KErrCancel ); + + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CheckRandValidityL +// Checks if rand received from network is valid +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CheckRandValidityL( + TBuf8<16> aRand ) + { + TInt ret( KErrNone ); + + TDesC8& rand = aRand; + + CSHA1* sha1 = CSHA1::NewL(); + + sha1->Reset(); + + TPtrC8 messageDigest = sha1->Final( rand ); + + ret = FindSetBitsFromBackup( messageDigest ); + + // If bits were not found from rand_db.prv or + // if rand_db.prv itself was not found + if ( KErrNone == ret || KErrNotFound == ret ) + { + ret = InsertBlobsToRandDb( messageDigest ); + } + + delete sha1; + sha1 = NULL; + + if ( KErrArgument == ret && 0 == iFreshBitCounter ) + { +TFLOGSTRING( "CMmCustomTsy: RAND rejected" ); + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CreateRandDb +// Creates rand_db.cur +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CreateRandDb() + { + TInt ret = ( KErrNone ); + + // local variable initialized to zero + TInt counter = 0; + + // empty tbuf for rand_db initialization + TBuf8<1> empty; + empty.Append( 0 ); + + // fileSize is initialized to 2 because of filesize calculation method + TInt fileSize = 2; + + RFs fs; + RFile file; + + ret = fs.Connect(); + + TDriveNumber driveNumber; + driveNumber = fs.GetSystemDrive(); + fs.CreatePrivatePath( driveNumber ); + fs.SetSessionToPrivate( driveNumber ); + + if ( KErrNone == ret ) + { + ret = file.Create( fs, KRandDb, EFileShareAny ); + + if ( KErrNone != ret ) + { +TFLOGSTRING( "TSY: CMmCustomTsy: 'rand_db.cur' creation failed!" ); + } + else if ( KErrNone == ret ) + { + ret = file.Open( fs, KRandDb, EFileShareAny | EFileWrite ); + + if ( KErrNone == ret ) + { + // calculates how many bits can be addressed with current + // BLOB_SIZE + for ( counter = 1; counter < BLOB_SIZE; counter++ ) + { + fileSize = ( fileSize * 2 ); + } + // max number of bits is divided by 8 to get the actual + // filesize + fileSize = ( fileSize / 8 ); + + ret = file.SetSize( fileSize + METADATA_SIZE ); + + // reset every byte of newly created rand_db to zero + for ( counter = 0; counter < ( fileSize + METADATA_SIZE ); + counter++ ) + { + ret = file.Write( counter, empty ); + } + + if ( KErrNone != ret ) + { +TFLOGSTRING( "TSY: CMmCustomTsy: 'rand_db.cur' initialization failed!" ); + file.Close(); + } + } + else + { +TFLOGSTRING( "TSY: CMmCustomTsy: 'rand_db.cur' open failed!" ); + } + } + + if ( KErrNone == ret ) + { + file.Close(); + fs.Close(); + } + else + { + fs.Close(); + } + } + else + { +TFLOGSTRING( "TSY: CMmCustomTsy: Could not connect to file server!" ); + } + + // Give some time for file.Close() and fs.Close() to complete + User::After( 200000 ); + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::InsertBlobsToRandDb +// Inserts blobs to rand_db.cur +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::InsertBlobsToRandDb( + TPtrC8 aMessageDigest ) + { + RFs fs; + RFile file; + + TBuf8<1> byteFromRandDb; + + TInt ret = KErrNone; + + // Many local variables initialized to zero + TInt8 counter = 0; + TInt8 counter2 = 0; + + TUint16 hexDigit = 0; + TUint8 blob = 0; + TInt byteNumber = 0; + TInt bit = 0; + + TUint16 assignedBits = 0; + iFreshBitCounter = 0; + + ret = fs.Connect(); + + TDriveNumber driveNumber; + driveNumber = fs.GetSystemDrive(); + fs.CreatePrivatePath( driveNumber ); + fs.SetSessionToPrivate( driveNumber ); + + if ( KErrNone == ret ) + { + ret = file.Open( fs, KRandDb, EFileShareExclusive | EFileWrite ); + if ( KErrNotFound == ret ) + { + ret = CreateRandDb(); + + if ( KErrNone == ret ) + { + ret = file.Open( fs, KRandDb, EFileShareExclusive | + EFileWrite ); + if( KErrNone != ret ) + { +TFLOGSTRING( "TSY: CMmCustomTsy: rand_db open failed" ); + } + } + if ( KErrNone != ret ) + { + fs.Close(); + + return ret; + } + } + + for ( counter = 0; counter < 20; counter++ ) + { + // reset loop variables + hexDigit = 0; + assignedBits = 0; + + // read one hexDigit from message digest + hexDigit = static_cast< TUint16 > ( aMessageDigest[counter] ); + hexDigit <<= 8; + counter++; + hexDigit |= static_cast< TUint16 > ( aMessageDigest[counter] ); + + bit = 1; + + // read as many bits from hexDigit as blobSize indicates + for ( counter2 = 0; counter2 < BLOB_SIZE; counter2++ ) + { + assignedBits |= bit & hexDigit; + bit <<= 1; + } + + byteNumber = ( assignedBits / 8 ); + bit = ( assignedBits - ( byteNumber * 8 ) ); + + ret = file.Read( byteNumber, byteFromRandDb ); + if( KErrNone != ret ) + { + break; + } + + blob = 128; + blob >>= bit; + + // if bit is not already set + if ( !blob == ( blob & byteFromRandDb[0] ) ) + { + + byteFromRandDb[0] |= blob; + + ret = file.Write( byteNumber, byteFromRandDb ); + if( KErrNone != ret ) + { + break; + } + + iFreshBitCounter++; + } + } + + file.Close(); + fs.Close(); + } + else + { +TFLOGSTRING( "TSY: CMmCustomTsy: Could not connect to file server!" ); + return ret; + } + + // if no new bits were found e.g. RAND will be rejected + if ( 0 == iFreshBitCounter ) + { + ret = KErrArgument; + } + else + { + ret = UpdateBitCounter(); + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::UpdateBitCounter +// Updates bitcounter information on rand_db.cur +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::UpdateBitCounter() + { + TInt ret( KErrNone ); + + RFs fs; + RFile file; + + TBuf8<2> bitCounterBytes; + + // local varibales initialized to zero + TUint16 bitCounter = 0; + TUint16 temporaryBitCounter = 0; + TInt8 counter = 0; + + // fileSize is initialized to 2 because of filesize calculation method + TInt fileSize = 2; + + ret = fs.Connect(); + + TDriveNumber driveNumber; + driveNumber = fs.GetSystemDrive(); + fs.CreatePrivatePath( driveNumber ); + fs.SetSessionToPrivate( driveNumber ); + + if ( KErrNone == ret ) + { + ret = file.Open( fs, KRandDb, EFileShareExclusive | EFileWrite ); + if ( KErrNone == ret ) + { + // calculate filesize + for ( counter = 1; counter < BLOB_SIZE; counter++ ) + { + fileSize = ( fileSize * 2 ); + } + fileSize = ( fileSize / 8 ); + + ret = file.Read( fileSize, bitCounterBytes, 2 ); + if ( KErrNone == ret ) + { + // read bitcounter info from rand_db + bitCounter = STATIC_CAST( TUint16, bitCounterBytes[0] ); + bitCounter <<= 8; + bitCounter |= bitCounterBytes[1]; + + // add fresh bits to bit counter info + bitCounter += iFreshBitCounter; + + temporaryBitCounter = bitCounter; + bitCounterBytes[1] = STATIC_CAST( TUint8, + temporaryBitCounter ); + temporaryBitCounter >>= 8; + bitCounterBytes[0] = STATIC_CAST( TUint8, + temporaryBitCounter ); + + ret = file.Write( fileSize, bitCounterBytes, 2 ); + + // if more than half of the available bits are set + if ( ( fileSize * 4 ) < bitCounter ) + { + ret = fs.Delete( KRandDbPrev ); + + if ( KErrNotFound == ret || KErrNone == ret ) + { + ret = file.Rename( KRandDbPrev ); + } + } + } + + file.Close(); + } + + fs.Close(); + } + else + { +TFLOGSTRING( "TSY: CMmCustomTsy: Could not connect to file server!" ); + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::FindSetBitsFromBackup +// Checks rand_db.prv for set bits +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::FindSetBitsFromBackup( + TPtrC8 aMessageDigest ) + { + RFs fs; + RFile file; + TBuf8<1> byteFromRandDb; + + TInt ret = KErrNone; + + // Many local variables initialized to zero + TInt8 counter = 0; + TInt8 counter2 = 0; + + TUint16 hexDigit = 0; + TUint8 blob = 0; + TInt byteNumber = 0; + TInt bit = 0; + + TUint16 assignedBits = 0; + iFreshBitCounter = 0; + + ret = fs.Connect(); + + TDriveNumber driveNumber; + driveNumber = fs.GetSystemDrive(); + fs.CreatePrivatePath( driveNumber ); + fs.SetSessionToPrivate( driveNumber ); + + if( KErrNone == ret ) + { + ret = file.Open( fs, KRandDbPrev, EFileShareAny | EFileRead ); + + if ( KErrNone == ret ) + { + for ( counter = 0; counter < 20; counter++ ) + { + // reset loop variables + hexDigit = 0; + assignedBits = 0; + + // read one hexDigit from message digest + hexDigit = STATIC_CAST( TUint16, aMessageDigest[counter] ); + hexDigit <<= 8; + counter++; + hexDigit |= STATIC_CAST( TUint16, aMessageDigest[counter] ); + + // Initialize bit to 1 + bit = 1; + + // read as many bits from hexDigit as blobSize indicates + for ( counter2 = 0; counter2 < BLOB_SIZE; counter2++ ) + { + assignedBits |= bit & hexDigit; + bit <<= 1; + } + + // calculate the byte and bit to be read from rand_db backup + byteNumber = ( assignedBits / 8 ); + bit = ( assignedBits - ( byteNumber * 8 ) ); + + ret = file.Read( byteNumber, byteFromRandDb ); + if ( KErrNone != ret ) + { + break; + } + + // Initialize blob to 10000000 + blob = 128; + blob >>= bit; + + // if bit is not found from old db + if ( !blob == ( blob & byteFromRandDb[0] ) ) + { + iFreshBitCounter++; + + file.Close(); + fs.Close(); + + return ret; + } + } + + file.Close(); + fs.Close(); + + if ( 0 == iFreshBitCounter ) + { + ret = KErrArgument; + } + else + { + ret = KErrNone; + } + } + + if ( KErrNotFound == ret ) + { + fs.Close(); + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::TerminateCallL +// This method is used for terminating a call or all calls. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::TerminateCallL( + const TTsyReqHandle aTsyReqHandle, + const TName* aCallName ) + { + // set return value to KErrNotFound + TInt ret( KErrNotFound ); + + TTsyReqHandle terminateCallHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsyTerminateCall ); + + if ( 0 < terminateCallHandle ) + { + //The request is already in processing because of previous request + //Complete request with status value informing the client about + //the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // Cases are: + // if parameter is ALL_CALLS + // if any active or held call exists + // hangup active and held calls + // else + // complete with KErrNone + // else (parameter is single call) + // if call exists + // hangup call + // else + // complete with KErrNotFound + // + + // call id + TInt callId = -1; + + // indicates if this is called in an error situation (ETrue) + // or by user request (EFalse); + TBool isError = EFalse; + + // terminate all calls + // CompareF returns 0 if names are equal + if ( 0 == aCallName->CompareF( KTerminateAllCalls ) ) + { + CMmCallTsy* activeCall = + iMmPhoneTsy->CallList()->GetMmCallByStatus( + RMobileCall::EStatusConnected ); + CMmCallTsy* heldCall = + iMmPhoneTsy->CallList()->GetMmCallByStatus( + RMobileCall::EStatusHold ); + CMmCallTsy* connectingCall = + iMmPhoneTsy->CallList()->GetMmCallByStatus( + RMobileCall::EStatusDialling ); + if ( NULL == connectingCall ) + { + connectingCall = + iMmPhoneTsy->CallList()->GetMmCallByStatus( + RMobileCall::EStatusConnecting ); + } + + if ( activeCall || heldCall || connectingCall ) + { + // Let's have negative or zero mean "all active and held calls + // and the call id given by taking absolute value of + // parameter" as we need to somehow pass alerting call id, + // which is neither active or held call.. + callId = ( NULL != connectingCall ) ? + -TInt( connectingCall->CallId() ) : ( 0 ); + CMmDataPackage dataPackage; + dataPackage.PackData( &callId, &isError ); + ret = iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomTerminateCallIPC, &dataPackage ); + } + else + { + ReqCompleted( aTsyReqHandle, KErrNone ); + // return immediately, otherwise KErrNone would cause the + // request handle to be saved! + return KErrNone; + } + } + // terminate call by name + else + { + // change the cause value, a specific call termination is called + // when error has ocurred + isError = ETrue; + + // get call object by name + CMmCallTsy* namedCall = + iMmPhoneTsy->CallList()->GetMmCallByName( aCallName ); + + // get call ID + if ( namedCall ) + { + callId = namedCall->CallId(); + CMmDataPackage dataPackage; + dataPackage.PackData( &callId, &isError ); + ret = iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomTerminateCallIPC, &dataPackage ); + } + } + + if ( KErrNone != ret ) + { + // request failed, complete with error value + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Store the request handle + iReqHandleType = ECustomTsyTerminateCall; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteTerminateCall +// This method completes a TerminateCall or a DialCancel request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteTerminateCall( + TInt aError ) + { +TFLOGSTRING2( "TSY: CMmCustomTsy::CompleteTerminateCall - aError: %d", aError ); + + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyTerminateCall ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete the request with reqhandle and aError + ReqCompleted( reqHandle, aError ); + } + // Set 3rd party Dial check number to EFalse + iISVDialNumberCheck = EFalse; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyDtmfEvent +// This method allows a client to be notified when the DTMF phase of a call +// has begun and completed +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyDtmfEvent( + RMmCustomAPI::TDtmfInfo* aInfo ) + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyDtmfEvent"); + // save pointer to client data + iNotifyInfo = aInfo; + + // save handle type + iReqHandleType = ECustomTsyNotifyDtmfEvent; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyDtmfEvent +// Completes a NotifyDtmfEvent request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyDtmfEvent( + RMmCustomAPI::TDtmfInfo aInfo, + TInt aErrorCode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteNotifyDtmfEvent"); + // reset request handle. Returns the deleted req handle. + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyDtmfEvent ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + *iNotifyInfo= aInfo; + } + + // reset the internal variable + iNotifyInfo = NULL; + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyDtmfEventCancel +// This method cancels an outstanding notification of dtmf event, placed with +// the NotifyDtmfEvent function. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyDtmfEventCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset pointer to client data + iNotifyInfo = NULL; + + // reset reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsyNotifyDtmfEvent ); + + // complete with KErrCancel + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetDiagnosticInfo +// This function gets the SS diagnostic info (octets) of a call object. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetDiagnosticInfo( + const TTsyReqHandle aTsyReqHandle, + TName* aCallName ) + { + TInt errorValue = KErrNone; + // get call object by name + CMmCallTsy* mmCall = iMmPhoneTsy->CallList()->GetMmCallByName( + aCallName ); + + // if call exists + if ( mmCall ) + { + TUint8 diags = mmCall->GetDiagnostics(); + //gets diagnostic value - check value - return error code + + if ( 0 != diags ) + { +TFLOGSTRING3( "TSY:CMmCustomTsy::GetDiagnosticInfo: Diagnostic info=%d asked for call id=%d", diags, mmCall->CallId() ); + switch ( diags ) + { + case KDiagnosticInfoBarredWithCUG: + errorValue = KErrDiagnosticInfoBarredWithCUG; + break; + case KDiagnosticInfoBarredNoCUG: + errorValue = KErrDiagnosticInfoBarredNoCUG; + break; + case KDiagnosticInfoBarredUnknownCUG: + errorValue = KErrDiagnosticInfoBarredUnknownCUG; + break; + case KDiagnosticInfoBarredIncompatibleCUG: + errorValue = KErrDiagnosticInfoBarredIncompatibleCUG; + break; + case KDiagnosticInfoBarredFailureCUG: + errorValue = KErrDiagnosticInfoBarredFailureCUG; + break; + case KDiagnosticInfoBarredClirNotSubscribed: + errorValue = KErrDiagnosticInfoBarredClirNotSubscribed; + break; + case KDiagnosticInfoBarredCCBSPossible: + errorValue = KErrDiagnosticInfoBarredCCBSPossible; + break; + case KDiagnosticInfoBarredCCBSNotPossible: + errorValue = KErrDiagnosticInfoBarredCCBSNotPossible; + break; + default: + errorValue = KErrNone; + break; + } + } +TFLOGSTRING2( "TSY: CMmCustomTsy::GetDiagnosticInfo - ReqCompleted - Error code: %d", errorValue ); + // complete errorvalue to client - inform change + ReqCompleted( aTsyReqHandle, errorValue ); + } + else + { + // call is not found +TFLOGSTRING("TSY: CMmCustomTsy::GetDiagnosticInfo - Call is not found"); + ReqCompleted( aTsyReqHandle, KErrNotFound ); + } +TFLOGSTRING2( "TSY: CMmCustomTsy::GetDiagnosticInfo - Error code: %d", errorValue ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetDiagnosticOctects +// This function sets the SS diagnostic octets of a call object when received +// from DOS. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetDiagnosticOctects( + TInt aCallId, + TUint8 aDiags ) + { + // get call object by id + CMmCallTsy* mmCall = iMmPhoneTsy->CallList()->GetMmCallById( aCallId ); + + // if call exists, set diagnostics + if ( mmCall ) + { + mmCall->SetDiagnostics( aDiags ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetRemoteAlertingToneStatus +// This function returns the remote alerting tone status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetRemoteAlertingToneStatus( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TRemoteAlertingToneStatus* aToneStatus ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetRemoteAlertingToneStatus"); + TInt ret = iMmCustomExtInterface->GetRemoteAlertingToneStatus( + aToneStatus ); + + ReqCompleted( aTsyReqHandle, ret ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCallOrigin +// This function returns the origin of the call (ETel or other), defined by +// aCallName parameter. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCallOrigin( + const TTsyReqHandle aTsyReqHandle, + TName* aCallName, + RMmCustomAPI::TCallOrigin* aOrigin ) + { + // get call object by name + CMmCallTsy* mmCall = iMmPhoneTsy->CallList()->GetMmCallByName( + aCallName ); + + // if call exists + if ( mmCall ) + { + // get the call origin from Call Object + // if the call is a ghost call it means that is not made by ETEL + if ( mmCall->ETelOriginated() ) + { + *aOrigin = RMmCustomAPI::EETelCall; + } + else + { + *aOrigin = RMmCustomAPI::EOutsider; + } + } + else // call not found + { + *aOrigin = RMmCustomAPI::EUnknown; + } + + ReqCompleted( aTsyReqHandle, KErrNone ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetAlsBlockedL +// This method gets the alternating line service block status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetAlsBlockedL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TGetAlsBlockStatus* aBlockStatus ) + { +TFLOGSTRING3( "TSY: CMmCustomTsy::GetAlsBlockedL - Req handle: %d, Block status: %d", aTsyReqHandle, *aBlockStatus ); + TTsyReqHandle getAlsBlockedHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsyGetAlsBlocked ); + + if ( 0 < getAlsBlockedHandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to client data + iRetAlsBlockStatus = aBlockStatus; + + // call DOS (no packed parameters) + TInt ret = iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomGetAlsBlockedIPC ); + + // check the result of the call + if ( KErrNone != ret ) + { + ReqCompleted ( aTsyReqHandle, ret ); + } + else + { + // Store the request handle + iReqHandleType = ECustomTsyGetAlsBlocked; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetAlsBlocked +// Completes a GetAlsBlocked operation. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetAlsBlocked( + RMmCustomAPI::TGetAlsBlockStatus aBlockStatus, + TInt aErrorCode ) + { +TFLOGSTRING3( "TSY: CMmCustomTsy::CompleteGetAlsBlocked - Block status: %d, Error code: %d", aBlockStatus, aErrorCode ); + //reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetAlsBlocked ); + + // check if request was called + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + //check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + *iRetAlsBlockStatus = aBlockStatus; + } + // reset the internal variable + iRetAlsBlockStatus = NULL; + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetAlsBlockedCancel +// This method cancels getting of alternative line service block status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetAlsBlockedCancel() + { + // reset the pointer to client space + iRetAlsBlockStatus = NULL; + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetAlsBlocked ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::Get3GPBInfo +// This method gets 3G phonebook info. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::Get3GPBInfo( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::T3GPBInfo* aInfo ) + { + // Fill info struct + aInfo->iMaxLenAnr = ( TInt16 )iMmPhoneTsy->PhoneBookState()-> + iANRNumLengthMax; + aInfo->iMaxLenEmail = ( TInt16 )iMmPhoneTsy->PhoneBookState()-> + iEmailTextLengthMax; + aInfo->iMaxLenSne = ( TInt16 )iMmPhoneTsy->PhoneBookState()-> + iSNETextLengthMax; + aInfo->iMaxNumAnr = ( TInt8 )iMmPhoneTsy->PhoneBookState()-> + iANRNumOfEntriesPerEntry; + aInfo->iMaxNumEmail = ( TInt8 )iMmPhoneTsy->PhoneBookState()-> + iEmailNumOfEntriesPerEntry; + aInfo->iMaxNumGroupName = ( TInt8 )iMmPhoneTsy->PhoneBookState()-> + iGRPNumOfEntriesPerEntry; + aInfo->iMaxNumSne = ( TInt8 )iMmPhoneTsy->PhoneBookState()-> + iSNENumOfEntriesPerEntry; + aInfo->iMaxLenGroupName = -1; // Not known + + // complete with KErrNone + ReqCompleted( aTsyReqHandle, KErrNone ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::Get3GPBInfoCancel +// This method cancels getting of 3G phonebook info +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::Get3GPBInfoCancel() + { + // Get3GPBInfo is completed immediately after the request + // has been done. No cancelling possible. + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetAlsBlockedL +// This method sets the alternating line service (ALS) block status using the +// aBlockStatus variable. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SetAlsBlockedL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TSetAlsBlock* aBlockStatus ) + { +TFLOGSTRING3( "TSY: CMmCustomTsy::SetAlsBlockedL - Req handle: %d, Block status: %d", aTsyReqHandle, *aBlockStatus ); + // get the handle + TTsyReqHandle setAlsBlockedHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsySetAlsBlocked ); + + if ( setAlsBlockedHandle > 0 ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to aBlockStatus (used for notification) + iSetBlockStatus = aBlockStatus; + + // call DOS + // packed parameter: TSetAlsBlock (block status) + CMmDataPackage dataPackage; + dataPackage.PackData( aBlockStatus ); + TInt ret = iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomSetAlsBlockedIPC, &dataPackage ); + + // check success + if ( KErrNone != ret ) + { + ReqCompleted ( aTsyReqHandle, ret ); + } + else + { + // Store the request handle + iReqHandleType = ECustomTsySetAlsBlocked; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSetAlsBlocked +// Completes a SetAlsBlocked request. If value for completion is KErrNone and +// a NotifyAlsBlockedChanged has been requested this method calls +// CompleteNotifyAlsBlockedChanged. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSetAlsBlocked( + TInt aErrorCode ) + { +TFLOGSTRING2( "TSY: CMmCustomTsy::CompleteSetAlsBlocked - Error code: %d", aErrorCode ); + // get reaq handle for NotifyAlsBlockedChanged + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyNotifyAlsBlockedChanged ); + + // check if notification was requested and Set was ok + if( ECustomTsyReqHandleUnknown != reqHandle && KErrNone == aErrorCode ) + { + CompleteNotifyAlsBlockedChanged (); + } + + // reset saved pointer + iSetBlockStatus = NULL; + + // reset req handle. Returns the deleted req handle + reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsySetAlsBlocked ); + + // check if request was called + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyAlsBlockedChanged +// This method notifies a client of changed ALS blocked status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyAlsBlockedChanged( + RMmCustomAPI::TGetAlsBlockStatus* aBlockStatus ) + { + // save pointer to client data + iRetNotifyAlsBlockStatus = aBlockStatus; + + // save handle type + iReqHandleType = ECustomTsyNotifyAlsBlockedChanged; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyAlsBlockedChanged +// This method notifies a client of changed ALS blocked status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyAlsBlockedChanged() + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyAlsBlockedChanged ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle && iSetBlockStatus) + { + // set the information for the client +#ifndef USING_CTSY_DISPATCHER + if ( RMmCustomAPI::EActivateBlock == *iSetBlockStatus ) +#else //USING_CTSY_DISPATCHER + if ( iSetBlockStatus && RMmCustomAPI::EActivateBlock == *iSetBlockStatus ) +#endif //USING_CTSY_DISPATCHER + { + *iRetNotifyAlsBlockStatus = RMmCustomAPI::EBlockStatusActive; + } + else // EDeactivateBlock == *iSetBlockStatus + { + *iRetNotifyAlsBlockStatus = RMmCustomAPI::EBlockStatusInactive; + } +TFLOGSTRING2( "TSY: CMmCustomTsy::CompleteNotifyAlsBlockedChanged - Block status: %d", *iSetBlockStatus ); + + // reset the varible + iRetNotifyAlsBlockStatus = NULL; + + // complete + ReqCompleted( reqHandle, KErrNone ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyAlsBlockedChangedCancel +// Cancels an outstanding NotifyAlsBlockedChanged notification. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyAlsBlockedChangedCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset the pointer to client data + iRetNotifyAlsBlockStatus = NULL; + + // reset the reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyAlsBlockedChanged ); + + // complete + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetAlsPpSupportL +// Gets ALS support information from Product Profile. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetAlsPpSupportL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TAlsSupport* aSupport ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetAlsPpSupportL"); + // save pointer to client space + iAlsSupport = aSupport; + + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetAlsPpSupport ); + + if ( 0 < reqHandle ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetAlsPpSupportL - Already processing, save handle"); + //The request is already in processing because of previous request + //Complete request with status value informing the client about + TCheckAlsPpSupportRequest* req = + new (ELeave) TCheckAlsPpSupportRequest(); + req->iReqHandle = aTsyReqHandle; + req->iRetSupport = aSupport; + iCheckAlsPpSupportRequests.AppendL( req ); + } + else + { + // call DOS (no packed parameters) + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomCheckAlsPpSupportIPC ); + + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetAlsPpSupportL - Save handle"); + // Save the req handle type + iReqHandleType = ECustomTsyGetAlsPpSupport; + // save request in queue for completion + TCheckAlsPpSupportRequest* req = + new (ELeave) TCheckAlsPpSupportRequest(); + req->iReqHandle = aTsyReqHandle; + req->iRetSupport = aSupport; + iCheckAlsPpSupportRequests.AppendL( req ); + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetAlsPpSupportCancel +// Cancels an outstanding asynchronous request to get ALS support. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetAlsPpSupportCancel() + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetAlsPpSupportCancel"); + // reset the pointer to client data + iAlsSupport = NULL; + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetAlsPpSupport ); + + // complete + TInt checkAlsPpSupportRequestsCount = + iCheckAlsPpSupportRequests.Count(); +TFLOGSTRING2( "TSY: CMmCustomTsy::GetAlsPpSupportCancel - Cancel %d requests", checkAlsPpSupportRequestsCount ); + + for ( TInt i=0; i < checkAlsPpSupportRequestsCount ; i++ ) + { + TCheckAlsPpSupportRequest* req = + iCheckAlsPpSupportRequests[ i ]; + //reset the return pointer + ReqCompleted( req->iReqHandle, KErrCancel ); + } + // Complete the client request + // Destroy Array + iCheckAlsPpSupportRequests.ResetAndDestroy(); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetAlsPpSupport +// Completes a GetAlsPpSupport request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetAlsPpSupport( + RMmCustomAPI::TAlsSupport aAlsSupport, + TInt aErrorCode ) + { +TFLOGSTRING3( "TSY: CMmCustomTsy::CompleteGetAlsPpSupport - ALS support: %d, Error: %d", aAlsSupport, aErrorCode ); + TBool status = EFalse; + + // Check if the get was called internally during boot + if( iMmPhoneTsy->GetAlsQueryInBoot() ) + { + if( RMmCustomAPI::EAlsSupportOn == aAlsSupport ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::CompleteGetAlsPpSupport - ALS supported by SIM" ); + status = ETrue; + } + //Update ALS status from sim + iMmPhoneTsy->SetAlsState( status ); + iMmPhoneTsy->SetAlsQueryInBoot( EFalse ); + } + + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetAlsPpSupport ); + + // check if request was called + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + *iAlsSupport = aAlsSupport; + + if( RMmCustomAPI::EAlsSupportOn == aAlsSupport ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::CompleteGetAlsPpSupport - ALS supported by SIM" ); + status = ETrue; + } + //Update ALS status from sim + iMmPhoneTsy->SetAlsState( status ); + } + + // reset the internal variable + iAlsSupport = NULL; + // complete + TInt checkAlsPpSupportRequestsCount = + iCheckAlsPpSupportRequests.Count(); +TFLOGSTRING2( "TSY: CMmCustomTsy::CompleteGetAlsPpSupport - Complete %d requests", checkAlsPpSupportRequestsCount ); + + for ( TInt i=0; i < checkAlsPpSupportRequestsCount ; i++ ) + { + TCheckAlsPpSupportRequest* req = + iCheckAlsPpSupportRequests[ i ]; + + //set value in client side + *(req->iRetSupport) = aAlsSupport; + //reset the return pointer + ReqCompleted( req->iReqHandle, aErrorCode ); + } + // Complete the client request + //Destroy Array + iCheckAlsPpSupportRequests.ResetAndDestroy(); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCipheringInfoL +// Get Ciphering Info +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCipheringInfoL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TCipheringInfo* aInfo ) + { + // this is special case, only called when Ciphering indicator + // is forced off for some operators + if ( iMmPhoneTsy->GetNetTsy()->CipheringIndicatorForcedOff() ) + { + aInfo->iIndStatus = EFalse; + aInfo->iCiphStatus = EFalse; + + ReqCompleted( aTsyReqHandle, KErrNone ); + } + // normal case + else + { + TTsyReqHandle getCipheringInfoHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsyGetCipheringInfo ); + + if ( 0 < getCipheringInfoHandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to client space + iRetCipheringInfo = aInfo; + + // call DOS (no packed parameters) + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetCipheringInfoIPC ); + + // check the correct completion of the call to the extension + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyGetCipheringInfo; + } + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetCipheringInfo +// Completes a GetCipheringInfo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetCipheringInfo( + TBool aCipherIndStatus, + TInt aErrorCode ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCipheringInfo ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + iRetCipheringInfo->iIndStatus = aCipherIndStatus; + iRetCipheringInfo->iCiphStatus = iCipheringInfo.iCiphStatus; + } + + // reset the internal variable + iRetCipheringInfo = NULL; + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCipheringInfoCancel +// This function cancels an outstanding GetCipheringInfo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCipheringInfoCancel() + { + // reset the pointer to client space + iRetCipheringInfo = NULL; + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCipheringInfo ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyCipheringInfoChange +// Notifies a client of ciphering info change. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyCipheringInfoChange( + RMmCustomAPI::TCipheringInfo* aInfo ) + { + // save pointer to client data + iRetNotifyCipheringInfoChange = aInfo; + + // set the reqhandle type + iReqHandleType = ECustomTsyNotifyCipheringInfoChange; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyCipheringInfoChangeCancel +// Cancels an outstanding NotifyCipheringInfoChange request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyCipheringInfoChangeCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset the pointer to client data + iRetNotifyCipheringInfoChange = NULL; + + // reset the reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCipheringInfoChange ); + + // complete + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyCipheringInfoChange +// Completes the NotifyCipheringInfoChange method. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyCipheringInfoChange( + TBool aCipherIndStatus, + TBool aCipherStatus, + TInt aErrorCode ) + { +TFLOGSTRING("TSY:CMmCustomTsy::CompleteNotifyCipheringInfoChange entered"); + // this is special case, only called when Ciphering indicator + // is forced off for some operators + if ( iMmPhoneTsy->GetNetTsy()->CipheringIndicatorForcedOff() ) + { +TFLOGSTRING("TSY:CMmCustomTsy::CompleteNotifyCipheringInfoChange: Ciphering forced off"); + TTsyReqHandle handle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCipheringInfoChange ); + + if ( ECustomTsyReqHandleUnknown != handle ) + { +TFLOGSTRING("TSY:CMmCustomTsy::CompleteNotifyCipheringInfoChange: Ciphering forced off, request completed"); + iRetNotifyCipheringInfoChange->iIndStatus = EFalse; + iRetNotifyCipheringInfoChange->iCiphStatus = ETrue; + + iRetNotifyCipheringInfoChange = NULL; + + ReqCompleted( handle, KErrNone ); + } + } + + // check if information has changed, continue only in case is changed + else + { + if ( iCipheringInfo.iIndStatus != aCipherIndStatus || + iCipheringInfo.iCiphStatus != aCipherStatus ) + { + // save the information in the custom TSY + iCipheringInfo.iIndStatus = aCipherIndStatus; + iCipheringInfo.iCiphStatus = aCipherStatus; + + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCipheringInfoChange ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // set the information for the client + iRetNotifyCipheringInfoChange->iIndStatus = + iCipheringInfo.iIndStatus; + iRetNotifyCipheringInfoChange->iCiphStatus = + iCipheringInfo.iCiphStatus; + + // reset the varible + iRetNotifyCipheringInfoChange = NULL; + + // complete + ReqCompleted( reqHandle, aErrorCode ); + + } + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyNSPSStatus +// Notifies a client of a change in NSPS (No Service Power Save) status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyNSPSStatus( + RMmCustomAPI::TNspsStatus* aNspsStatus ) + { + // save pointer to client data + iRetNspsStatus = aNspsStatus; + + // set the reqhandle type + iReqHandleType = ECustomTsyNotifyNSPSStatus; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyNSPSStatus +// Completes the notification of a change in NSPS (No Service Power Save) +// status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyNSPSStatus( + TBool aNspsStatus ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyNSPSStatus ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // set the information for the client + if ( aNspsStatus ) // the NSPS mode is ON + { + *iRetNspsStatus = RMmCustomAPI::ENspsOn; + } + else + { + *iRetNspsStatus = RMmCustomAPI::ENspsOff; + } + + // reset the varible + iRetNspsStatus = NULL; + + // complete + ReqCompleted( reqHandle, KErrNone ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyNSPSStatusCancel +// Cancels an outstanding notification of a change in NSPS (No Service Power +// Save) status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyNSPSStatusCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset pointer to client data + iRetNspsStatus = NULL; + + // reset reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsyNotifyNSPSStatus ); + + // complete with KErrCancel + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NetWakeupL +// Send NetWakeUp request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NetWakeupL( + const TTsyReqHandle aTsyReqHandle ) + { + // intialize ret value + TInt ret ( KErrNone ); + + // call DOS (no packed parameters) + ret = Phone()->MessageManager()->HandleRequestL( ECustomNetWakeupIPC ); + + // check result + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyNetWakeup; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNetWakeup +// Completes a NetWakeup request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNetWakeup( + TInt aErrorCode ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNetWakeup ); + + // check the handle and complete + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( reqHandle, aErrorCode ); + } + } + +#ifdef REQHANDLE_TIMER +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetTypeOfResponse +// Sets the type of response for a given handle. +// Automatic mode includes an automatic response in case of no response from +// the DOS in a specified time. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::SetTypeOfResponse( + const TInt aReqHandleType, + const TTsyReqHandle aTsyReqHandle ) + { + TInt timeOut( 0 ); + TInt ipc( 0 ); + + switch ( aReqHandleType ) + { + case ECustomTsyCallGsmBlackListClear: + timeOut = KMmCustomCallGsmBlackListClearTimeOut; + ipc = ECustomClearCallBlackListIPC; + break; + case ECustomTsyTerminateCall: + timeOut = KMmCustomTerminateCallTimeOut; + ipc = ECustomTerminateCallIPC; + break; + case ECustomTsyGetAlsBlocked: + timeOut = KMmCustomGetAlsBlockedTimeOut; + ipc = ECustomGetAlsBlockedIPC; + break; + case ECustomTsySetAlsBlocked: + timeOut = KMmCustomSetAlsBlockedTimeOut; + ipc = ECustomSetAlsBlockedIPC; + break; + case ECustomTsyGetCipheringInfo: + timeOut = KMmCustomGetCipheringInfoTimeOut; + ipc = ECustomGetCipheringInfoIPC; + break; + case ECustomTsyCheckEmergencyNumber: + timeOut = KMmCustomCheckEmergencyNumberTimeout; + ipc = ECustomCheckEmergencyNumberIPC; + break; + case ECustomTsyGetNetworkOperatorName: + timeOut = KMmCustomGetNetworkOperatorNameTimeout; + ipc = ECustomGetNetworkProviderNameIPC; + break; + case ECustomTsyCheckTwoDigitDialSupport: + timeOut = KMmCustomCheckTwoDigitDialTimeout; + ipc = ECustomCheckTwoDigitDialSupportIPC; + break; + case ECustomTsyGetOperatorName: + timeOut = KMmCustomGetOperatorNameTimeout; + ipc = ECustomGetOperatorNameIPC; + break; + case ECustomTsyGetProgrammableOperatorLogo: + timeOut = KMmCustomGetProgrammableOperatorLogoTimeout; + ipc = ECustomGetProgrammableOperatorLogoIPC; + break; + case ECustomTsyResetNetServer: + timeOut = KMmCustomResetNetServer; + ipc = ECustomResetNetServerIPC; + break; + case ECustomTsyGetSimFileInfo: + timeOut = KMmCustomReadSimFile; + ipc = ECustomReadSimFileIPC; + break; + case ECustomTsyGetLifeTimerInfo: + timeOut = KMmCustomReadSimFile; + ipc = ECustomGetLifeTimeIPC; + break; + case ECustomTsyIMSAuthenticate: + timeOut = KMmCustomIMSAuthenticate; + ipc = EMobilePhoneIMSAuthenticate; + break; + case ECustomTsyGetSimAuthenticationData: + timeOut = KMmCustomGetSimAuthenticationData; + ipc = ECustomGetSimAuthenticationDataIPC; + break; + case ECustomTsySetDriveMode: + timeOut = KMmCustomSetDriveModeTimeOut; + ipc = ECustomSetDriveModeIPC; + break; + case ECustomTsyReadHSxPAStatus: + timeOut = KMmCustomTsyReadHSxPAStatusTimeOut; + ipc = ECustomReadHSxPAStatusIPC; + break; + case ECustomTsyWriteHSxPAStatus: + timeOut = KMmCustomTsyWriteHSxPAStatusTimeOut; + ipc = ECustomWriteHSxPAStatusIPC; + break; + case ECustomTsyGetIccCallForwardingStatus: + timeOut = KMmCustomTsyGetIccCallForwardingStatusTimeOut; + ipc = ECustomGetIccCallForwardingStatusIPC; + break; + case ECustomTsyGetCellInfo: + timeOut = KMmCustomTsyGetCellInfoTimeOut; + ipc = ECustomGetCellInfoIPC; + break; + case ECustomTsyGetUSIMServiceSupport: + timeOut = KMmCustomGetUSIMServiceSupportTimeOut; + ipc = ECustomGetServiceTableSupportbyApplicationIPC; + break; + case ECustomTsyGetSystemNetworkBand: + timeOut = KMmCustomTsyGetSystemNetworkBandTimeOut; + ipc = ECustomGetBandSelectionIPC; + break; + default: + // Does not use timer + iTsyReqHandleStore->SetTsyReqHandle( aReqHandleType, + aTsyReqHandle ); + break; + } + + if ( 0 < timeOut ) + { + // The timeout parameter is given in seconds. + iTsyReqHandleStore->SetTsyReqHandle( aReqHandleType, aTsyReqHandle, + timeOut, ipc ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::Complete +// Completes the request due the timer expiration. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::Complete( + TInt aReqHandleType, + TInt aError, + TInt aIPC ) + { +TFLOGSTRING3( "TSY: CMmCustomTsy::Complete - ReqHandleType: %d Error: %d", aReqHandleType, aError ); + TBool subTsyReqFound = EFalse; + TInt max = GetMaxNumberOfSubsystems(); + CMmSubTsyBase** subTsyPtr = GetSubsystemArrayPtr(); + + // Check Custom TSY's subsystems' req handles first + for ( TInt i = 0; max > i; i++ ) + { + // check which custom object handles this IPC + if ( ( NULL != subTsyPtr[i] ) && + ( EFalse != subTsyPtr[i]->SupportingIPC( aIPC ) ) ) + { + // call complete method of the right custom object + subTsyPtr[i]->Complete( aReqHandleType, aError ); + i = max; + subTsyReqFound = ETrue; + } + } + + // If the reg handle was not found on Custom TSY's subsystems check the + // Custom TSY's request handles + if ( !subTsyReqFound ) + { + TBuf<1> name(KNullDesC); + RMmCustomAPI::TOperatorNameInfo operatorNameInfo; + RMmCustomAPI::TLifeTimeData timeData; + + // All possible Custom TSY req handle types are listed in the + // switch case below. + switch ( aReqHandleType ) + { + case ECustomTsyCallGsmBlackListClear: + CompleteClearCallBlackList ( aError ); + break; + case ECustomTsyTerminateCall: + CompleteTerminateCall( aError ); + break; + case ECustomTsyGetAlsBlocked: + CompleteGetAlsBlocked( RMmCustomAPI::EBlockStatusUnknown, + aError ); + break; + case ECustomTsySetAlsBlocked: + CompleteSetAlsBlocked( aError ); + break; + case ECustomTsyGetCipheringInfo: + CompleteGetCipheringInfo( EFalse, aError ); + break; + case ECustomTsyCheckEmergencyNumber: + CompleteCheckEmergencyNumber( 0, aError ); + break; + case ECustomTsyGetNetworkOperatorName: + CompleteGetNetworkOperatorName( &name, aError ); + break; + case ECustomTsyCheckTwoDigitDialSupport: + CompleteCheckTwoDigitDialSupport( + RMmCustomAPI::ETwoDigitDialSupportOff, aError ); + break; + case ECustomTsyGetOperatorName: + // we don't initialize as this is response to error situation + CompleteGetOperatorName( operatorNameInfo , aError ); + break; + case ECustomTsyResetNetServer: + CompleteResetNetServer( aError ); + break; + case ECustomTsyGetSimFileInfo: + CompleteGetSimFileInfo( NULL, aError ); + break; + case ECustomTsyGetLifeTimerInfo: + CompleteGetLifeTime( timeData, aError ); + break; + case ECustomTsyGetProgrammableOperatorLogo: + CompleteGetProgrammableOperatorLogo( NULL, NULL, aError ); + break; + case ECustomTsyGetSimAuthenticationData: + CompleteSimAuthentication( NULL, aError ); + break; + case ECustomTsyIMSAuthenticate: + CompleteImsAuthentication( NULL, aError ); + break; + case ECustomTsySetDriveMode: + CompleteSetDriveMode( aError ); + break; + case ECustomTsyReadHSxPAStatus: + CompleteReadHSxPAStatus( NULL, aError ); + break; + case ECustomTsyWriteHSxPAStatus: + CompleteWriteHSxPAStatus( aError ); + break; + case ECustomTsyGetCellInfo: + CompleteGetCellInfo( NULL, aError ); + break; + case ECustomTsyGetUSIMServiceSupport: + CompleteGetUSIMServiceSupport( NULL, aError ); + break; + case ECustomTsyGetSystemNetworkBand: + CompleteGetSystemNetworkBand( + RMmCustomAPI::ENetworkBandAny, + RMmCustomAPI::KCapsNetworkModeDual, + aError ); + break; + case ECustomTsyGetIccCallForwardingStatus: + CompleteGetIccCallForwardingStatus( NULL, aError ); + break; + default: + break; + } + } + } +#endif // REQHANDLE_TIMER + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ClearCallBlackList +// Clears the Call Blacklist. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ClearCallBlackListL( + const TTsyReqHandle aTsyReqHandle ) + { + TInt retValue ( KErrNone ); + + TTsyReqHandle reqhandle = + iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyCallGsmBlackListClear ); + + if ( 0 < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // call DOS and initialize ret value + // no parameters for DOS call + retValue = Phone()->MessageManager()-> + HandleRequestL( ECustomClearCallBlackListIPC ); + + // check result + if ( KErrNone != retValue ) + { + ReqCompleted( aTsyReqHandle, retValue ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyCallGsmBlackListClear; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteClearCallBlackList +// Completes a ClearCallBlackList request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteClearCallBlackList( + TInt aErrorCode ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyCallGsmBlackListClear ); + + // check the handle and complete + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ClearCallBlackListCancel +// Cancels an outstanding ClearCallBlackList request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ClearCallBlackListCancel() + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyCallGsmBlackListClear ); + // complete with KErrCancel + // check the handle and complete + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetAirTimeDuration +// Gets the air time duration information from CMmPhoneTsy. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetAirTimeDuration( + const TTsyReqHandle aTsyReqHandle, + TTimeIntervalSeconds* aTime ) + { + // get the air time duration from phone + Phone()->GetAirTimeDuration( *aTime ); + + // complete with KErrNone + ReqCompleted( aTsyReqHandle, KErrNone ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CheckEmergencyNumberL +// Checks whether given number is emergency number or not. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CheckEmergencyNumberL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TEmerNumberCheckMode* aNumberMode, + TBool* aResult ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CheckEmergencyNumberL number=%S", &(aNumberMode->iNumber) ); + + TInt ret(KErrGeneral); + + TTsyReqHandle requestHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsyCheckEmergencyNumber ); + + // 3rd Dial check number + if( iISVDialNumberCheck && 0 == requestHandle ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CheckEmergencyNumberL - 3rd party client nbr check aResult = %d" , aResult ); + iEmergencyNumberCheckMode = aNumberMode; + iEmergencyNumberCheckResult = aResult; + + // parameter for DOS call: a TEmerNumberCheckMode + CMmDataPackage dataPackage; + dataPackage.PackData( aNumberMode ); + ret = Phone()->MessageManager()->HandleRequestL( + ECustomCheckEmergencyNumberIPC, &dataPackage ); + } + + //Normal case + else + { +TFLOGSTRING2("TSY: CMmCustomTsy::CheckEmergencyNumberL - aResult = %d" , aResult ); + + if ( ( 0 < requestHandle || iISVDialNumberCheck ) && 0 != aTsyReqHandle ) + { + // The request is already in processing because of previous request + ret = KErrServerBusy; + } + + else if( iISVDialNumberCheck && 0 == aTsyReqHandle ) + { + ret = KErrServerBusy; + } + + else + { + // save pointers + iEmergencyNumberCheckMode = aNumberMode; + iEmergencyNumberCheckResult = aResult; + + // parameter for DOS call: a TEmerNumberCheckMode + CMmDataPackage dataPackage; + dataPackage.PackData( aNumberMode ); + ret = Phone()->MessageManager()->HandleRequestL( + ECustomCheckEmergencyNumberIPC, &dataPackage ); + + // check the correct completion of the call + if ( KErrNone == ret ) + { + // Save the req handle type + iReqHandleType = ECustomTsyCheckEmergencyNumber; + } + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteCheckEmergencyNumber +// Completes checking of emergency number. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteCheckEmergencyNumber( + RMmCustomAPI::TMobileTelNumber* aTelNumber, + TInt aErrorValue ) + { + +TFLOGSTRING("TSY: CMmCustomTsy::CompleteCheckEmergencyNumber" ); + + // 3rd party number check completion0 + if( iISVDialNumberCheck ) + { + //Reset + TBool isEmergencyNbr = EFalse; + + if ( KErrNone == aErrorValue && NULL == aTelNumber ) + { + *iEmergencyNumberCheckResult = ETrue; + isEmergencyNbr = EFalse; + } + else + { + *iEmergencyNumberCheckResult = ETrue; + isEmergencyNbr = ETrue; + } + + // check is the Dial cancel NULL + if( iISVDialNumberCheckObject ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteCheckEmergencyNumber - Complete3rdPartyCallNbrCheck isEmergencyNbr = %d",isEmergencyNbr ); + iISVDialNumberCheckObject->Complete3rdPartyCallNbrCheck( + isEmergencyNbr ); + } + + //reset pointer + iISVDialNumberCheckObject = NULL; + iISVDialNumberCheck = EFalse; + } + + // Normal case + else + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyCheckEmergencyNumber ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorValue ) + { + //set the information for the client + if ( aTelNumber ) + { + *iEmergencyNumberCheckResult = ETrue; + iEmergencyNumberCheckMode->iNumber = *aTelNumber; + } + else + { + *iEmergencyNumberCheckResult = EFalse; + } + } +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteCheckEmergencyNumber number=%S", &(iEmergencyNumberCheckMode->iNumber) ); + + // reset the internal variable + iEmergencyNumberCheckResult = NULL; + iEmergencyNumberCheckMode = NULL; + // complete + ReqCompleted( reqHandle, aErrorValue ); + } + + } + + //Reset + iISVDialNumberCheck = EFalse; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CheckEmergencyNumberCancel +// Cancels checking of emergency number. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CheckEmergencyNumberCancel() + { + iEmergencyNumberCheckResult = NULL; + + // reset the req handle.Returns the deleted req handle. + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyCheckEmergencyNumber ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyPhoneBookCacheReady +// Notifies client when phonebookcache is ready. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyPhoneBookCacheReady( + const TTsyReqHandle, + TName* aPndName ) + { + iPndName = aPndName; + + iReqHandleType = ECustomTsyNotifyCacheReady; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyPhoneBookCacheReady +// Completes notify phonebook cache ready. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyPhoneBookCacheReady( + TName& aPndName, + TInt aResult ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCacheReady ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + *iPndName = aPndName; + + iPndName = NULL; + + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyPhoneBookCacheReadyCancel +// Cancels notify phonebook cache ready notification. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyPhoneBookCacheReadyCancel( + const TTsyReqHandle ) + { + // reset request handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCacheReady ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetPndCacheStatus +// This function gets current status of phonebook caching. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetPndCacheStatus( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TPndCacheStatus* aPndStatus, + const TName* aPndName ) + { + + TInt error = KErrNone; + // used phonebook is Adn + if ( 0 == aPndName->CompareF( KETelIccAdnPhoneBook ) ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::GetPndCacheStatus - ADN phonebook status: %d", iAdnCacheStatus); + *aPndStatus = iAdnCacheStatus; + } + // used phonebook is Fdn + else if ( 0 == aPndName->CompareF( KETelIccFdnPhoneBook ) ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::GetPndCacheStatus - FDN phonebook status: %d", iFdnCacheStatus); + *aPndStatus = iFdnCacheStatus; + } + // used phonebook doesn't have cache + else if ( ( 0 == aPndName->CompareF( KETelIccBdnPhoneBook ) ) || + ( 0 == aPndName->CompareF( KETelIccSdnPhoneBook ) ) || + ( 0 == aPndName->CompareF( KETelIccVoiceMailBox ) ) ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::GetPndCacheStatus - No cache for: %S ", aPndName); + *aPndStatus = RMmCustomAPI::ECacheNotUsed; + } + else + { +TFLOGSTRING2("TSY: CMmCustomTsy::GetPndCacheStatus - No cache found for: %S ", aPndName); + error = KErrArgument; + } + + ReqCompleted( aTsyReqHandle, error ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::UpdateCacheStatus +// This method updates phonebook caching status. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::UpdateCacheStatus( + RMmCustomAPI::TPndCacheStatus aPndStatus, + TName& aPndName ) + { +TFLOGSTRING3("TSY: CMmCustomTsy::UpdateCacheStatus - Phonebook: %S status: %d", &aPndName, aPndStatus); + // if used phonebook is Adn + if ( 0 == aPndName.CompareF( KETelIccAdnPhoneBook ) ) + { + iAdnCacheStatus = aPndStatus; + } + // else if used phonebook is Fdn + else if ( 0 == aPndName.CompareF( KETelIccFdnPhoneBook ) ) + { + iFdnCacheStatus = aPndStatus; + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetNetworkOperatorNameL +// Gets the network operator name from the SIM card. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetNetworkOperatorNameL( + TDes* aNetworkOperatorName ) + { + // call DOS (no packed parameters) + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetNetworkProviderNameIPC ); + + if ( KErrNone == ret ) + { + // save pointer to client space and req handle type + iNetworkOperatorName = aNetworkOperatorName; + iReqHandleType = ECustomTsyGetNetworkOperatorName; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetNetworkOperatorName +// Completes getting network operator name from SIM card. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetNetworkOperatorName( + TDes* aName, + TInt aError ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetNetworkOperatorName ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( ( KErrNone == aError ) && ( NULL != aName ) ) + { + if ( aName->Length() <= iNetworkOperatorName->MaxLength() ) + { + // set the information for the client + *iNetworkOperatorName = *aName; + } + else + { + // client delivered too small buffer + aError = KErrArgument; + } + } + + // reset the internal variable + iNetworkOperatorName = NULL; + // complete + ReqCompleted( reqHandle, aError ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetNetworkOperatorNameCancel +// Cancels getting network operator name from SIM card. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetNetworkOperatorNameCancel() + { + // reset the pointer to client space + iNetworkOperatorName = NULL; + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetNetworkOperatorName ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SsAdditionalInfoNotification +// Notification request for additional info message. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SsAdditionalInfoNotification( + RMmCustomAPI::TSsAdditionalInfo* aSsAdditionalInfo ) + { +TFLOGSTRING("TSY: CMmCustomTsy::SsAdditionalInfoNotification"); + iRetSsAdditionalInfo = aSsAdditionalInfo; + iReqHandleType = ECustomTsyNotifySsAdditionalInfo; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SsAdditionalInfoNotificationCancel +// Cancels notification request for additional info message. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SsAdditionalInfoNotificationCancel( + const TTsyReqHandle ) + { +TFLOGSTRING("TSY: CMmCustomTsy::SsAdditionalInfoNotificationCancel"); + iRetSsAdditionalInfo = NULL; + + // reset reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifySsAdditionalInfo ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSsAdditionalInfoNotification +// Completes SsAdditionalInfo notification. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSsAdditionalInfoNotification( + RMmCustomAPI::TSsAdditionalInfo* aSsAdditionalInfo, + TInt aError ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteSsAdditionalInfoNotification"); + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifySsAdditionalInfo ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // copy data to client + iRetSsAdditionalInfo->iOperationCode = + aSsAdditionalInfo->iOperationCode; + iRetSsAdditionalInfo->iAdditionalInfo.Copy( + aSsAdditionalInfo->iAdditionalInfo ); + + // reset pointer to client + iRetSsAdditionalInfo = NULL; + + // Complete the client request + ReqCompleted( reqHandle, aError ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CheckTwoDigitDialSupportL +// Checks two digit dialing support from Product Profile. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CheckTwoDigitDialSupportL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TTwoDigitDialSupport* aSupport ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CheckTwoDigitDialSupportL"); + // save pointer to client space + iTwoDigitDialSupport = aSupport; + + // call DOS + TInt error = Phone()->MessageManager()->HandleRequestL( + ECustomCheckTwoDigitDialSupportIPC ); + + if ( KErrNone != error ) + { + ReqCompleted( aTsyReqHandle, error ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyCheckTwoDigitDialSupport; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CheckTwoDigitDialSupport +// Completes a CheckTwoDigitDialSupport request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteCheckTwoDigitDialSupport( + RMmCustomAPI::TTwoDigitDialSupport aTwoDigitDialSupport, + TInt aErrorCode ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyCheckTwoDigitDialSupport ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + *iTwoDigitDialSupport = aTwoDigitDialSupport; + } + + // reset the internal variable + iTwoDigitDialSupport = NULL; + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CheckTwoDigitDialSupportCancel +// Cancels an outstanding CheckTwoDigitDialSupport request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::CheckTwoDigitDialSupportCancel() + { + // reset the pointer to client data + iTwoDigitDialSupport = NULL; + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyCheckTwoDigitDialSupport ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetOperatorNameL +// Get the programmable operator name of the current network. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetOperatorNameL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TOperatorNameInfo* aOperatorNameInfo ) + { + // save a pointer to client space + iRetOperatorNameInfo = aOperatorNameInfo; + + // call DOS (no packed parameters) + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetOperatorNameIPC ); + + // check result + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyGetOperatorName; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetOperatorNameCancel +// Cancels an outstanding GetOperatorName request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetOperatorNameCancel() + { + // reset the pointer to client space + iRetOperatorNameInfo = NULL; + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetOperatorName ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetOperatorName +// Completes an outstanding GetOperatorName request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetOperatorName( + RMmCustomAPI::TOperatorNameInfo& aOperatorNameInfo, + TInt aErrorValue ) + { + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetOperatorName ); + + // check the validity of the handler + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aErrorValue ) + { + // Copy the programmable operator name info in the client space + *iRetOperatorNameInfo = aOperatorNameInfo; + } + // reset the pointer to client space + iRetOperatorNameInfo = NULL; + + // complete operation + ReqCompleted ( reqHandle, aErrorValue ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifySsNetworkEvent +// Notifies the client about a network generated SS event. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifySsNetworkEvent( + RMmCustomAPI::TSsTypeAndMode* aSsTypeAndMode, + RMmCustomAPI::TSsInfo* aSsInfo ) + { + // save pointer to client data + iSsTypeAndMode = aSsTypeAndMode; + iSsInfo = aSsInfo; + + // set the reqhandle type + iReqHandleType = ECustomTsySsNotification; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifySsNetworkEventCancel +// Cancels an outstanding NotifySsNetworkEvent. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifySsNetworkEventCancel() + { + // erase pointers to client data + iSsTypeAndMode = NULL; + iSsInfo = NULL; + + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsySsNotification ); + + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + // complete with cancel + ReqCompleted( tsyReqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifySsNetworkEvent +// Completes NotifySsNetworkEvent. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifySsNetworkEvent( + RMmCustomAPI::TSsTypeAndMode& aSsTypeAndMode, + RMmCustomAPI::TSsInfo& aSsInfo, + TInt aErrorCode ) + { + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsySsNotification ); + + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + if ( KErrNone == aErrorCode ) + { + // save data in client space + *iSsTypeAndMode = aSsTypeAndMode; + *iSsInfo = aSsInfo; + } + // reset the pointers to client space + iSsTypeAndMode = NULL; + iSsInfo = NULL; + // complete + ReqCompleted( tsyReqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetProgrammableOperatorLogoL +// Gets the programmable operator logo. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetProgrammableOperatorLogoL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TOperatorId* aOperatorId, + RMmCustomAPI::TOperatorLogo* aLogo ) + { + TTsyReqHandle reqhandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetProgrammableOperatorLogo ); + + if ( 0 < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save a pointer to client space + iRetOperatorLogoInfo = aLogo; + iRetOperatorIdInfo = aOperatorId; + + // call DOS + // packed parameter: RMmCustomAPI::TOperatorId + CMmDataPackage dataPackage; + dataPackage.PackData( aOperatorId ); + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetProgrammableOperatorLogoIPC, &dataPackage ); + + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyGetProgrammableOperatorLogo; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetProgrammableOperatorLogoCancel +// Cancels an outstanding GetProgrammableOperatorLogo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetProgrammableOperatorLogoCancel() + { + // reset the pointers + iRetOperatorLogoInfo = NULL; + iRetOperatorIdInfo = NULL; + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetProgrammableOperatorLogo ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetProgrammableOperatorLogo +// Completes GetProgrammableOperatorLogo. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetProgrammableOperatorLogo( + RMmCustomAPI::TOperatorId* aOperatorIdInfo, + RMmCustomAPI::TOperatorLogo* aLogoData, + TInt aErrorValue ) + { + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetProgrammableOperatorLogo ); + + // check the validity of the handler + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aErrorValue) + { + // if client has allocated big enough space for logo data, logo data + // is appended into client space pointer + if ( ( aLogoData->iOperatorLogo ) && + ( aLogoData->iOperatorLogo->Size() <= + iRetOperatorLogoInfo->iOperatorLogo->MaxSize() ) ) + { + // Copy the logo info in the client space + iRetOperatorLogoInfo->iLogoInfo = aLogoData->iLogoInfo; + // Copy the logo in the client space + iRetOperatorLogoInfo->iOperatorLogo->Copy( *( + aLogoData->iOperatorLogo ) ); + // Copy the operator info in the client space + *iRetOperatorIdInfo = *aOperatorIdInfo; + } + else + { + // logo will not fit into client space + aErrorValue = KErrTooBig; + } + } + + // reset the pointers + iRetOperatorLogoInfo = NULL; + iRetOperatorIdInfo = NULL; + + // complete operation + ReqCompleted ( reqHandle, aErrorValue ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SatRefreshCompleteNotification +// Notifies the client of SAT refresh. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SatRefreshCompleteNotification() + { + iReqHandleType = ECustomTsySatRefreshCompleteNotification; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SatRefreshCompleteNotificationCancel +// Cancels an outstanding asynchronous SatRefreshCompleteNotification request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SatRefreshCompleteNotificationCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsySatRefreshCompleteNotification ); + + // complete with KErrCancel + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSatRefreshCompleteNotification +// Completes the notification of SAT refresh to the client. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSatRefreshCompleteNotification() + { + //Note iRefresh is never set to ETrue + + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsySatRefreshCompleteNotification ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete + ReqCompleted( reqHandle, KErrNone ); + // set sat refresh flag off + SetSatRefreshStatus ( EFalse ); + //Reset ME ALS info + Phone()->ResetMEAlsInfo(); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetSatRefreshStatus +// Sets aSatRefreshStatus into internal variable iIsRefresh. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +EXPORT_C void CMmCustomTsy::SetSatRefreshStatus( + TBool aSatRefreshStatus ) + { + iIsRefresh = aSatRefreshStatus; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ResetNetServerL +// Resets the net server to previous network selection when user doesn't select +// a network from the network list got in a search. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ResetNetServerL( + const TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ResetNetServerL"); + // call DOS (no packed parameters) + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomResetNetServerIPC ); + + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyResetNetServer; + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteResetNetServer +// Completes a ResetNetServer request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteResetNetServer( + TInt aErrorValue ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteResetNetServer - Error: %d", aErrorValue ); + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsyResetNetServer ); + + // Check the reqHandle + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + // Check that the error value is not KErrCancel, because this will + // cause panic on the ETEL side - error: EZGO-6WVD5N + if ( KErrCancel == aErrorValue ) + { + // Convert the error value from KErrCancel to KErrNotReady + aErrorValue = KErrNotReady; + } + +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteResetNetServer - complete with error value: %d", aErrorValue ); + ReqCompleted( tsyReqHandle, aErrorValue ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyNetworkConnectionFailure +// Notifies of a network connection failure. This failure is so severe that +// the only way to recover is to restart the phone. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyNetworkConnectionFailure() + { + iReqHandleType = ECustomTsyNotifyNetworkConnectionFailure; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyNetworkConnectionFailureCancel +// Cancels a NotifyNetworkConnectionFailure. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyNetworkConnectionFailureCancel() + { + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyNetworkConnectionFailure ); + + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + // complete with cancel + ReqCompleted( tsyReqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyNetworkConnectionFailure +// Completes NotifyNetworkConnectionFailure. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyNetworkConnectionFailure() + { + // If SIM is inserted complete network connection failure + if ( iMmPhoneTsy->NosBootState()->iSIMReady ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteNotifyNetworkConnectionFailure"); + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyNetworkConnectionFailure ); + + // Check the reqHandle + if( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + ReqCompleted ( tsyReqHandle, KErrNone ); + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SsRequestCompleteNotification +// Notification request for "SS request complete". +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SsRequestCompleteNotification( + TInt* aStatus ) + { + iRetSsRequestComplete = aStatus; + iReqHandleType = ECustomTsyNotifySsRequestComplete; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSsRequestCompleteNotification +// Completes notification request for "SS request complete". +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSsRequestCompleteNotification( + TInt aSsStatus, + TInt aError ) + { + // Reset the req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifySsRequestComplete ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( NULL == iRetSsRequestComplete ) + { + ReqCompleted( reqHandle, KErrCorrupt ); + } + else + { + *iRetSsRequestComplete = aSsStatus; + iRetSsRequestComplete = NULL; + ReqCompleted( reqHandle, aError ); + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SsRequestCompleteNotificationCancel +// Cancels notification request for "SS request complete". +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SsRequestCompleteNotificationCancel( + const TTsyReqHandle ) + { + iRetSsRequestComplete = NULL; + + // reset reqhandler + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifySsRequestComplete ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetSystemNetworkModesL +// This method gets the supported network modes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetSystemNetworkModesL( + const TTsyReqHandle aTsyReqHandle, + TUint32* aSystemNetworkModes ) + { + TTsyReqHandle reqhandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetSystemNetworkModes ); + + if ( 0 < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to the packaged life timer info + iSystemNetworkModes = aSystemNetworkModes; + TBool useCurrentRats = EFalse; + // call DOS + CMmDataPackage dataPackage; + dataPackage.PackData( &useCurrentRats ); + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetSystemNetworkModesIPC, &dataPackage ); + + // Check response of the extension + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyGetSystemNetworkModes; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetSystemOrCurrentNetworkModes +// Completes a GetSystemNetworkModes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetSystemOrCurrentNetworkModes( + TUint32 aSystemNetworkModes, + TInt aResult ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSystemNetworkModes ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // set the information for the client + *iSystemNetworkModes = aSystemNetworkModes; + + // complete + ReqCompleted( reqHandle, aResult ); + } + + // reset req handle. Returns the deleted req handle + reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCurrentSystemNetworkMode ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // set the information for the client + *iCurrentNetworkMode = aSystemNetworkModes; + + // complete + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetSystemNetworkModesCancel +// Cancels a GetSystemNetworkModes. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetSystemNetworkModesCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset the pointer to client data + iSystemNetworkModes = NULL; + + // reset the reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSystemNetworkModes ); + + // complete + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetSystemNetworkModeL +// This method sets the system network mode. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SetSystemNetworkModeL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TNetworkModeCaps* aSystemNetworkModeCaps ) + { + TTsyReqHandle reqhandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsySetSystemNetworkMode ); + + if ( 0 < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // call DOS + RMmCustomAPI::TNetworkModeCaps networkModeCaps = + *aSystemNetworkModeCaps; + CMmDataPackage dataPackage; + dataPackage.PackData( &networkModeCaps ); + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomSetSystemNetworkModeIPC, &dataPackage ); + + // Check response of the extension + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsySetSystemNetworkMode; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSetSystemNetworkMode +// Completes a SetSystemNetworkMode. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSetSystemNetworkMode( + TInt aResult ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsySetSystemNetworkMode ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCurrentSystemNetworkModeL +// This function gets the current network mode GSM/UMTS/Dual. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCurrentSystemNetworkModeL( + const TTsyReqHandle aTsyReqHandle, + TUint32* aNetworkMode ) + { +TFLOGSTRING("CMmCustomTsy::GetCurrentSystemNetworkModeL"); + TTsyReqHandle reqhandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetCurrentSystemNetworkMode ); + + if ( 0 < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + iCurrentNetworkMode = aNetworkMode; + // call DOS + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetCurrentSystemNetworkModesIPC ); + + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + iReqHandleType = ECustomTsyGetCurrentSystemNetworkMode; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCurrentSystemNetworkModeCancel +// Cancel outstanding request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCurrentSystemNetworkModeCancel( + const TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING("CMmCustomTsy::GetCurrentSystemNetworkModeCancel"); + + // reset pointer to client data + iCurrentNetworkMode = NULL; + + // reset reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCurrentSystemNetworkMode ); + + // complete with KErrCancel + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetSimFileInfoL +// Gets data from a given location of a given sim file determined by the +// aSimFileInfoPckg parameter. Saves the pointer to the client side store +// buffer for further completion. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetSimFileInfoL( + const TTsyReqHandle aTsyReqHandle, + TDes8* aSimFileInfoPckg, + TDes8* aSimResponseBuffer ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetSimFileInfoL" ); + TTsyReqHandle reqHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsyGetSimFileInfo ); + + // Unpack the TSimFileInfo data + RMmCustomAPI::TSimFileInfoPckg* simFileInfoPckg = + ( RMmCustomAPI::TSimFileInfoPckg* ) aSimFileInfoPckg; + + RMmCustomAPI::TSimFileInfo simFileInfo = ( *simFileInfoPckg )(); + + if ( 0 < reqHandle ) + { + //The request is already in processing because of previous request + //Check if the request is the same than before + + //Check the file path in SIM where file is read, the offset from + //beginning of the file and amount of data to read + if ( ( KErrNotFound != simFileInfo.iPath.Match( iGetSimFileInfoReq.iPath ) ) + && ( iGetSimFileInfoReq.iOffSet == simFileInfo.iOffSet ) + && ( iGetSimFileInfoReq.iSize == simFileInfo.iSize ) ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetSimFileInfoL - Same info already requested" ); + + TGetSimFileInfoRequest* req = new ( ELeave ) TGetSimFileInfoRequest(); + req->iReqHandle = aTsyReqHandle; + req->iSimFileInfo = aSimResponseBuffer; + iGetSimFileInfoRequests.AppendL( req ); + } + else + { + //Complete request with status value informing the client about + //the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + } + else + { + iGetSimFileInfoReq = simFileInfo; + // call DOS + CMmDataPackage dataPackage; + dataPackage.PackData( &simFileInfo ); + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomReadSimFileIPC, &dataPackage ); + + // check the return value of the call to DOS + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetSimFileInfoL - Save handle" ); + // Save the req handle type + iReqHandleType = ECustomTsyGetSimFileInfo; + // Save request in queue for completion + TGetSimFileInfoRequest* req = new ( ELeave ) TGetSimFileInfoRequest(); + req->iReqHandle = aTsyReqHandle; + req->iSimFileInfo = aSimResponseBuffer; + iGetSimFileInfoRequests.AppendL( req ); + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetSimFileInfoCancel +// Cancels an outstanding GetSimFileInfo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetSimFileInfoCancel( TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetSimFileInfoCancel" ); + + for ( TInt i = 0; i < iGetSimFileInfoRequests.Count(); i++ ) + { + TGetSimFileInfoRequest* req = iGetSimFileInfoRequests[ i ]; + if ( aTsyReqHandle == req->iReqHandle ) + { + //reset the return pointer + ReqCompleted( req->iReqHandle, KErrCancel ); + + iGetSimFileInfoRequests.Remove( i ); + iGetSimFileInfoRequests.Compress(); + + //Delete TGetSimFileInfoRequest object + delete req; + } + } + + if ( 0 == iGetSimFileInfoRequests.Count() ) + { + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSimFileInfo ); + + //Destroy Array + iGetSimFileInfoRequests.ResetAndDestroy(); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetSimFileInfo +// Completes an outstanding GetSimFileInfo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetSimFileInfo( + TDesC8* aData, + TInt aError ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::CompleteGetSimFileInfo" ); + + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsyGetSimFileInfo ); + + // Check the reqHandle + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + // complete + TInt getSimFileInfoRequestsCount = iGetSimFileInfoRequests.Count(); +TFLOGSTRING2( "TSY: CMmCustomTsy::CompleteGetSimFileInfo - Complete %d requests", getSimFileInfoRequestsCount ); + + for ( TInt i = 0; i < getSimFileInfoRequestsCount; i++ ) + { + TGetSimFileInfoRequest* req = iGetSimFileInfoRequests[ i ]; + + if ( ( KErrNone == aError ) && aData ) + { + // check the size.... + if ( req->iSimFileInfo->MaxLength() >= aData->Length() ) + { + req->iSimFileInfo->Copy( *aData ); + ReqCompleted( req->iReqHandle, aError ); + } + else // data is too big for client's buffer + { + req->iSimFileInfo->Zero(); + ReqCompleted( req->iReqHandle, KErrOverflow ); + } + } + else + { + req->iSimFileInfo->Zero(); + ReqCompleted( req->iReqHandle, aError ); + } + } + } + + //Destroy Array + iGetSimFileInfoRequests.ResetAndDestroy(); + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetLifeTimeL +// Gets the life timer's information and the manufacturing date of the phone. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetLifeTimeL( + const TTsyReqHandle aTsyReqHandle, + TDes8* aLifeTimerInfoPckg ) + { + + TInt ret( KErrNone ); + TFLOGSTRING ("TSY: CMmCustomTsy::GetLifeTimeL"); + if ( sizeof(RMmCustomAPI::TLifeTimeData) != aLifeTimerInfoPckg->MaxLength() ) + { + TFLOGSTRING ("TSY: CMmCustomTsy::GetLifeTimeL bad size argument"); + // Complete the request with appropiate error + return KErrArgument; + } + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetLifeTimerInfo ); + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { +TFLOGSTRING( "TSY: CMmCustomTsy::GetLifeTimeL - ECustomTsyReqHandleUnknown" ); + // The request is already in processing because of previous request. + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to the packaged life timer info + iLifeTimerInfoPckg = aLifeTimerInfoPckg; + TFLOGSTRING( "TSY: CMmCustomTsy::GetLifeTimeL - send request" ); + iTsyReqHandleStore->SetTsyReqHandle( + ECustomTsyGetLifeTimerInfo, aTsyReqHandle ); + ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetLifeTimeIPC); + // Check response of the extension + if ( KErrNone != ret ) + { + TFLOGSTRING( "TSY: CMmCustomTsy::GetLifeTimeL - DOS layer returned error " ); + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetLifeTimerInfo ); + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + TFLOGSTRING( "TSY: CMmCustomTsy::GetLifeTimeL - DOS error - unknown handle" ); + } + ReqCompleted( aTsyReqHandle, ret ); + } + } + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetLifeTimeCancel +// Cancels an ongoing GetLifeTime request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetLifeTimeCancel() + { + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetLifeTimerInfo ); + + // reset pointer to client data + iLifeTimerInfoPckg = NULL; + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetLifeTime +// Completes a GetLifeTime request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetLifeTime( + RMmCustomAPI::TLifeTimeData& aLifeTimerData, + TInt aErrorValue ) + { + // reset the reqhandle + TTsyReqHandle tsyReqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsyGetLifeTimerInfo ); + + // Check the reqHandle + if ( ECustomTsyReqHandleUnknown != tsyReqHandle ) + { + // Check if there is error + if ( KErrNone == aErrorValue ) + { + // pack the return information + RMmCustomAPI::TLifeTimeDataPckg aPackg ( aLifeTimerData); + // Copy the return info into the client side + (*iLifeTimerInfoPckg) = aPackg; + } + // reset the pointer to client space + iLifeTimerInfoPckg = NULL; + // complete + ReqCompleted( tsyReqHandle, aErrorValue ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::DeliverCode +// Deliveres code and unblock code. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::DeliverCodeL( + RMobilePhone::TCodeAndUnblockCode aCodes ) + { + iMmSecurityTsy->DeliverCodeL( aCodes ); + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetDriveModeL +// This method sets Drive Mode status using the aModeStatus variable. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SetDriveModeL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TSetDriveMode* aModeStatus ) + { +TFLOGSTRING3("TSY: CMmCustomTsy::SetDriveModeL - Req handle: %d, Mode status: %d", aTsyReqHandle, *aModeStatus ); + if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KDriveModeCanRestrictMtCalls) == KFeatureSupported) ) + { + // get the handle + TTsyReqHandle setDriveModeHandle = + iTsyReqHandleStore->GetTsyReqHandle( ECustomTsySetDriveMode ); + + if ( setDriveModeHandle > 0 ) + { + // The request is already in processing because of previous + // request. Complete request with status value informing the + // client about the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // call DOS + // packed parameter: TSetDriveMode (mode status) + CMmDataPackage dataPackage; + dataPackage.PackData( aModeStatus ); + TInt ret = iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomSetDriveModeIPC, &dataPackage ); + + // check success + if ( KErrNone != ret ) + { + ReqCompleted ( aTsyReqHandle, ret ); + } + else + { + // Store the request handle + iReqHandleType = ECustomTsySetDriveMode; + } + } + } + else + { + ReqCompleted ( aTsyReqHandle, KErrNotSupported ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSetDriveMode +// Completes a Set Drive Mode request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSetDriveMode( + TInt aErrorCode ) + { +TFLOGSTRING2( "TSY: CMmCustomTsy::CompleteSetDriveMode - Error code: %d", aErrorCode ); + if ( (iUsingFeatureManager) && (iFeatureControl.FeatureSupported(NFeature::KDriveModeCanRestrictMtCalls) == KFeatureSupported) ) + { + //Reset req handle, returns the deleted req handle + TTsyReqHandle reqHandle = + iTsyReqHandleStore->ResetTsyReqHandle( ECustomTsySetDriveMode ); + + //check if request was called + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + //complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::IsRequestPossibleInOffLine +// Checks wether a ETel request can be performed or not while offline mode is +// enabled +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CMmCustomTsy::IsRequestPossibleInOffline( + TInt aIpc ) + { + // we assume here that most of the requests are possible, thefore + // we switch for the not possible ones, optimizing a bit the checking. + TBool isRequestPossible ( ETrue ); + // yet another switching function, yeah! + switch ( aIpc ) + { + //case ECustomSsAdditionalInfoNotificationIPC: //ok (but shouldn't be + //triggered anyways) + //case ECustomNotifySsRequestCompleteIPC: //ok (but shouldn't be + //triggered anyways) + //case ECustomStartSimCbTopicBrowsingIPC: //ok + //case ECustomGetNextSimCbTopicIPC: //ok + //case ECustomDeleteSimCbTopicIPC: //ok + //case ECustomReadSimFileIPC: //ok + //case ECustomNotifyDtmfEventIPC: //ok (policy is to leave + //the notifications as ok) + //case ECustomGetDiagnosticOctetsIPC: //ok (NO?, this only applies to + //call so...should be no) + //case ECustomSetAlsBlockedIPC: //ok + //case ECustomGetAlsBlockedIPC: //ok + //case ECustomCheckAlsPpSupportIPC: //ok + //case ECustomGetRemoteAlertingToneStatusIPC: + //case ECustomCallOriginIPC: //ok (only for emergency) + //case ECustomNotifyAlsBlockedChangedIPC: //ok //Notify Als + //Blocked Change + //case ECustomTerminateCallIPC: //ok (or no?) //Terminate a Call + //case ECustomClearCallBlackListIPC: //ok //Clear call blacklist + //case ECustomSimLockActivateIPC: //ok + //case ECustomSimLockDeActivateIPC: //ok + //case EReadViagHomeZoneParamsIPC: //ok + //case EReadViagHomeZoneCacheIPC: //ok + //case EWriteViagHomeZoneCacheIPC: //ok + //case ECustomGetCipheringInfoIPC: //ok + //case ECustomNotifyCipheringInfoChangeIPC: //ok + //case ECustomNotifyNSPSStatusIPC: //ok + case ECustomNetWakeupIPC: //NO + //case ECustomGetNetworkProviderNameIPC: //ok //(info is got from sim) + case ECustomGetOperatorNameIPC: //NO //(there is no operator + //available in offline) + //case ECustomGetProgrammableOperatorLogoIPC: //ok + case ECustomResetNetServerIPC: //NO (or yes, but this one is sensible) + //case ECustomNotifyProgrammableOperatorLogoChangeIPC: //ok + //case ECustomNotifyNetworkConnectionFailureIPC: //ok + //case ECustomGetAirTimeDurationIPC: //ok (at least for emergency call) + //case ECustomNotifyPndCacheReadyIPC: //ok + //case ECustomGetPndCacheStatusIPC: //ok + //case ECustomNotifySsNetworkEventIPC: //ok //(shouldn't be possible + //to get any ) + //case ECustomCheckTwoDigitDialSupportIPC: //ok + //case ECustomSendAPDUReqIPC: //ok + //case ECustomGetLifeTimeIPC: //ok + //case ECustomIsBlockedIPC: //ok + //case ECustomCheckSecurityCodeIPC: //ok + //case ECustomCheckEmergencyNumberIPC: //ok + //case ECustomSatRefreshCompleteNotificationIPC: //ok + //case ECustomDisablePhoneLockIPC: //ok + //case ECustomGetActivePinIPC: //ok + //case ECustomReleaseFileIPC: //ok + //case ECustomRestartFileIPC: //ok + //case ECustomNotifyEGprsInfoChange: //ok + //case ECustomGetEGprsInfo: //ok + //case EGet3GPBInfoIPC: //ok + //case ECustomSetDriveModeIPC: //ok + //case ECustomReadHSxPAStatusIPC: //ok + //case ECustomWriteHSxPAStatusIPC: //ok + //case ECustomNotifyHSxPAStatusIPC: //ok + //case ECustomNotifyCellInfoChangeIPC: //ok + //case ECustomGetCellInfoIPC: //ok + + //case ECustomGetBandSelectionIPC: //ok + //case ECustomNotifyRemoteAlertingToneStatusChangeIPC: //ok + + case ECustomSetSystemNetworkModeIPC: + case ECustomSetBandSelectionIPC: + isRequestPossible = EFalse; + break; + default: + break; + } + + return isRequestPossible; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetCurrentSystemNetworkMode +// Completes Get Current System Network Mode +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetCurrentSystemNetworkMode( + TUint32 aCurrentNetwork, + TInt aResult ) + { + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCurrentSystemNetworkMode ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // set the information for the client + *iCurrentNetworkMode = aCurrentNetwork; + + // reset the varible + iCurrentNetworkMode = NULL; + + // complete + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetSimMessageStatusReadL +// Sets SIM SMS storage status to "read". Implements +// CustomAPI method SetSimMessageStatusRead. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SetSimMessageStatusReadL( + const TTsyReqHandle aTsyReqHandle, + TTime& aTime, + TInt& aTimezoneDiff ) + { + // NOTE: This method asynchronously calls DOS, and then immediately + // completes with KErrNone. Any problems or errors are silently ignored. + + //call DOS + CMmDataPackage dataPackage; + dataPackage.PackData( &aTime, &aTimezoneDiff ); + iMmPhoneTsy->MessageManager()->HandleRequestL( + ECustomSetSimMessageStatusReadIPC, &dataPackage ); + + // immediately complete, ignore the result. + ReqCompleted( aTsyReqHandle, KErrNone ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ISVDialNumberCheck +// Saves call object for completion +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::SetObjectForISVDialNumberCheck( + CMmVoiceCallTsy* aCallObject ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::SetObjectForISVDialNumberCheck aCallObject=%x", aCallObject ); + //Save pointer for completion of check emergency number + iISVDialNumberCheckObject = aCallObject; + //ISV dial has been requested + iISVDialNumberCheck = ETrue; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyRauEvent +// Sets RAU event notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyRauEvent( + RMmCustomAPI::TRauEventStatus* aEventStatus ) + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyRauEvent"); + + // save pointer to client data + iRauEventStatus = aEventStatus; + + // save handle type + iReqHandleType = ECustomTsyNotifyRauEvent; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyRauEvent +// Completes a NotifyRauEvent request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyRauEvent( + RMmCustomAPI::TRauEventStatus aEventStatus, + TInt aErrorCode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteNotifyRauEvent"); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyRauEvent ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + *iRauEventStatus = aEventStatus; + } + + // reset the internal variable + iRauEventStatus = NULL; + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyRauEventCancel +// This method cancels an outstanding notification of RAU event, placed with +// the NotifyRauEvent function. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyRauEventCancel() + { + // reset reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyRauEvent ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset pointer to client data + iRauEventStatus = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ReadHSxPAStatusL +// Read high speed channel status +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ReadHSxPAStatusL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::THSxPAStatus* aHSxPAStatus ) + { +TFLOGSTRING("TSY: CMmCustomTsy::ReadHSxPAStatusL"); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyReadHSxPAStatus ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to client data + iRetHSxPAStatus = aHSxPAStatus; + + // call DOS (no packed parameters) + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomReadHSxPAStatusIPC ); + + // check the result of the call + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Store the request handle + iReqHandleType = ECustomTsyReadHSxPAStatus; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteReadHSxPAStatus +// Completes a ReadHSxPAStatus request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteReadHSxPAStatus( + CMmDataPackage* aDataPackage, + TInt aErrorCode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteReadHSxPAStatus"); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyReadHSxPAStatus ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aErrorCode ) + { + RMmCustomAPI::THSxPAStatus status; + aDataPackage->UnPackData( status ); + +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteReadHSxPAStatus, status = %d", status); + + // Save the status. + iHSxPAStatus = status; + + // set the information for the client + *iRetHSxPAStatus = status; + + // reset the internal variable + iRetHSxPAStatus = NULL; + //Complete request to success + ReqCompleted( reqHandle, KErrNone ); + } + else + { + // Complete with error + ReqCompleted( reqHandle, aErrorCode ); + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ReadHSxPAStatusCancel +// Cancels a ReadHSxPAStatus request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::ReadHSxPAStatusCancel() + { +TFLOGSTRING("TSY: CMmCustomTsy::ReadHSxPAStatusCancel"); + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyReadHSxPAStatus ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset the pointer to client data + iRetHSxPAStatus = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::WriteHSxPAStatusL +// Write HSxPAStatus +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::WriteHSxPAStatusL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::THSxPAStatus* aHSxPAStatus ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::WriteHSxPAStatusL. New status: %d", *aHSxPAStatus); + + iSetHSxPAStatus = aHSxPAStatus; + + // get the handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyWriteHSxPAStatus ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + CMmDataPackage dataPackage; + dataPackage.PackData( iSetHSxPAStatus ); + + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomWriteHSxPAStatusIPC, &dataPackage ); + + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyWriteHSxPAStatus; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteWriteHSxPAStatus +// Complete WriteHSxPAStatus request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteWriteHSxPAStatus( + TInt aErrorCode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteWriteHSxPAStatus"); + + //reset req handle. + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyWriteHSxPAStatus ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aErrorCode ) + { + // Save the current status + iHSxPAStatus = *iSetHSxPAStatus; + } + + // erase pointer to client data + iSetHSxPAStatus = NULL; + + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::WriteHSxPAStatusCancel +// Cancel WriteHSxPAStatus request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::WriteHSxPAStatusCancel() + { +TFLOGSTRING("TSY: CMmCustomTsy::WriteHSxPAStatusCancel"); + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyWriteHSxPAStatus ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // erase pointer to client data + iSetHSxPAStatus = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyHSxPAStatus +// Set HSxPA notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyHSxPAStatus( + RMmCustomAPI::THSxPAStatus* aHSxPAStatus ) + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyHSxPAStatus"); + + // save pointer to client data + iRetNotifyHSxPAStatus = aHSxPAStatus; + + // set the reqhandle type + iReqHandleType = ECustomTsyNotifyHSxPAStatus; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyHSxPAStatus +// Complete HSxPA notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyHSxPAStatus( + CMmDataPackage* aDataPackage, + TInt aErrorCode ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteNotifyHSxPAStatus, Error: %d", aErrorCode); + + RMmCustomAPI::THSxPAStatus status; + aDataPackage->UnPackData( status ); + +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteNotifyHSxPAStatus, old status: %d", iHSxPAStatus); +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteNotifyHSxPAStatus, new status: %d", status); + + // check if status was changed + if ( iHSxPAStatus != status ) + { + // Check if notification was requested + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyHSxPAStatus ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // Save the status + iHSxPAStatus = status; + + // set the information for the client + *iRetNotifyHSxPAStatus = status; + + //Complete request to success + ReqCompleted( reqHandle, KErrNone ); + } + else + { + // Complete error value + ReqCompleted( reqHandle, aErrorCode ); + } + + // reset the internal variable + iRetNotifyHSxPAStatus = NULL; + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyHSxPAStatusCancel +// Cancel HSxPA notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyHSxPAStatusCancel() + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyHSxPAStatusCancel"); + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyHSxPAStatus ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset the pointer to client data + iRetNotifyHSxPAStatus = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCallForwardingStatusL +// Gets call forwarding status +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetIccCallForwardingStatusL( + TTsyReqHandle /*aTsyReqHandle*/, + TDes8* aCFIndicators ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetIccCallForwardingStatusL"); + + TInt ret( KErrGeneral ); + + //Get reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetIccCallForwardingStatus ); + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + ret = KErrServerBusy; + } + else + { + if( sizeof(RMmCustomAPI::TCFIndicators) > aCFIndicators->Size()) + { + ret = KErrArgument; + } + else + { + //Store client side pointer + iRetCFIndicators = aCFIndicators; + + ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetIccCallForwardingStatusIPC ); + + if ( KErrNone == ret ) + { + // Save the req handle type + iReqHandleType = ECustomTsyGetIccCallForwardingStatus; + } + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetCallForwardingStatus +// completes gets call forwarding status request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetIccCallForwardingStatus( + CMmDataPackage* aDataPackage, + TInt aErrorCode ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteGetIccCallForwardingStatus, aErrorCode=%d", aErrorCode ); + + //reset req handle. + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetIccCallForwardingStatus ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + if( KErrNone == aErrorCode ) + { + RMmCustomAPI::TCFIndicatorsPckg* tcfIndicatorPckg = REINTERPRET_CAST( + RMmCustomAPI::TCFIndicatorsPckg*, iRetCFIndicators ); + RMmCustomAPI::TCFIndicators& tcfIndicator = ( *tcfIndicatorPckg )(); + + aDataPackage->UnPackData( iCurrentTCFIndicator ); +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteGetIccCallForwardingStatus, indicator=%u", iCurrentTCFIndicator.iIndicator ); + + tcfIndicator.iIndicator = iCurrentTCFIndicator.iIndicator; + tcfIndicator.iCFNumber.iTypeOfNumber = + iCurrentTCFIndicator.iCFNumber.iTypeOfNumber; + tcfIndicator.iCFNumber.iNumberPlan = + iCurrentTCFIndicator.iCFNumber.iNumberPlan; + tcfIndicator.iCFNumber.iTelNumber.Copy( + iCurrentTCFIndicator.iCFNumber.iTelNumber ); + + // Update CenRep with latest valid data + if( &iCurrentTCFIndicator ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteGetIccCallForwardingStatus : Update Central Repository"); + TPckg tempPckg( iCurrentTCFIndicator.iIndicator ); + iCFISCentRep->Set( KCtsyCallForwardingIndicator, tempPckg ); + + iCFISPrivateCentRep->Set( KCtsyCallForwardingNumberPlan, + iCurrentTCFIndicator.iCFNumber.iNumberPlan ); + iCFISCentRep->Set( KCtsyCallForwardingNumber, + iCurrentTCFIndicator.iCFNumber.iTelNumber ); + iCFISPrivateCentRep->Set( KCtsyCallForwardingMspId, + iCurrentTCFIndicator.iMultipleSubscriberProfileID ); + } + } + //Erase client side pointer + iRetCFIndicators = NULL; + //Complete + ReqCompleted( reqHandle, aErrorCode ); + } + + //Request is made during boot-up done only once + else if( iGetIccCfStatusBootUp ) + { + if( KErrNone == aErrorCode ) + { + iGetIccCfStatusBootUp = EFalse; + aDataPackage->UnPackData( iCurrentTCFIndicator ); +TFLOGSTRING("TSY: CMmCustomTsy::CompleteGetIccCallForwardingStatus CenRep key UnconditionalCFStatus not RESETED."); + +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteGetIccCallForwardingStatus : Bootup case, KCtsyCallForwardingIndicator indicator=%u", iCurrentTCFIndicator.iIndicator ); + + TPckg tempPckg( iCurrentTCFIndicator.iIndicator ); + iCFISCentRep->Set( KCtsyCallForwardingIndicator, tempPckg ); + iCFISPrivateCentRep->Set( KCtsyCallForwardingNumberPlan, + iCurrentTCFIndicator.iCFNumber.iNumberPlan ); + iCFISCentRep->Set( KCtsyCallForwardingNumber, + iCurrentTCFIndicator.iCFNumber.iTelNumber ); + iCFISPrivateCentRep->Set( KCtsyCallForwardingMspId, + iCurrentTCFIndicator.iMultipleSubscriberProfileID ); +TFLOGSTRING("TSY: CMmCustomTsy::CompleteGetIccCallForwardingStatus CenRep updated."); + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetIccCallForwardingStatusCancel +// Cancels Get icc call forwarding status +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetIccCallForwardingStatusCancel( + const TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING("CMmCustomTsy::GetIccCallForwardingStatusCancel"); + // reset reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetIccCallForwardingStatus ); + + // complete with KErrCancel + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetIccCallForwardingStatusCancel +// Cancels an ongoing GetIccCallForwardingStatus request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetIccCallForwardingStatusCancel() + { + //Reset req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetIccCallForwardingStatus ); + + //Erase client side pointer + iRetCFIndicators = NULL; + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + //Complete request with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyCallForwardingStatusChange +// Set notification on +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyIccCallForwardingStatusChange( + TDes8* aCFIndicators ) + { + + iNotifyCFIndicator = aCFIndicators; + // save handle type + iReqHandleType = ECustomTsyNotifyIccCallForwardingStatusChange; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyCallForwardingStatusChange +// Notifies client +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyIccCallForwardingStatusChange( + CMmDataPackage* aDataPackage, + TInt aErrorCode ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteNotifyIccCallForwardingStatusChange, Error: %d", aErrorCode); + + RMmCustomAPI::TCFIndicators tempNotifyCFIndicator; + aDataPackage->UnPackData( tempNotifyCFIndicator ); + + TBool isChanged = IsIccCallForwardingStatusChanged( + tempNotifyCFIndicator ); + + // check if information was changed + if ( isChanged ) + { + //Update CTSY internal buffer + iCurrentTCFIndicator = tempNotifyCFIndicator; + + if ( KErrNone == aErrorCode ) + { + //Update CenRep + + TPckg tempPckg( iCurrentTCFIndicator.iIndicator ); + iCFISCentRep->Set( KCtsyCallForwardingIndicator, tempPckg ); +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteNotifyIccCallForwardingStatusChange : Update CenRep, KCtsyCallForwardingIndicator indicator=%u", iCurrentTCFIndicator.iIndicator ); + + iCFISPrivateCentRep->Set( KCtsyCallForwardingNumberPlan, + iCurrentTCFIndicator.iCFNumber.iNumberPlan ); + + iCFISCentRep->Set( KCtsyCallForwardingNumber, + iCurrentTCFIndicator.iCFNumber.iTelNumber ); + + iCFISPrivateCentRep->Set( KCtsyCallForwardingMspId, + iCurrentTCFIndicator.iMultipleSubscriberProfileID ); + //CenRep updated +TFLOGSTRING("TSY: CMmCustomTsy::CompleteNotifyIccCallForwardingStatusChange CenRep updated."); + } + + // Check if notification was requested + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyIccCallForwardingStatusChange ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + RMmCustomAPI::TCFIndicatorsPckg* tcfIndicatorPckg = + REINTERPRET_CAST( + RMmCustomAPI::TCFIndicatorsPckg*, iNotifyCFIndicator ); + RMmCustomAPI::TCFIndicators& tcfIndicator = + ( *tcfIndicatorPckg )(); + + if( sizeof(RMmCustomAPI::TCFIndicators) > tcfIndicatorPckg->Size()) + { + ReqCompleted( reqHandle, KErrArgument); + } + else + { + // Save the new info + tcfIndicator = tempNotifyCFIndicator; + //Complete request + ReqCompleted( reqHandle, KErrNone ); + } + } + else + { + // Complete with error value + ReqCompleted( reqHandle, aErrorCode ); + } + + // reset the internal variable + //iNotifyCFIndicator = NULL; + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyCallForwardingStatusChangeCancel +// Cancels notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyIccCallForwardingStatusChangeCancel( + const TTsyReqHandle aTsyReqHandle ) + { + // reset pointer to client data + iNotifyCFIndicator = NULL; + + // reset reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyIccCallForwardingStatusChange ); + + // complete with KErrCancel + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::IsCallForwardingStatusChanged +// Decides if CTSY internal indicator buffer differs from received buffer +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TBool CMmCustomTsy::IsIccCallForwardingStatusChanged( + RMmCustomAPI::TCFIndicators& aNotifyCFIndicator ) + { + TBool changed( EFalse ); + + if( ( aNotifyCFIndicator.iIndicator != + iCurrentTCFIndicator.iIndicator ) || + ( aNotifyCFIndicator.iCFNumber.iTypeOfNumber != + iCurrentTCFIndicator.iCFNumber.iTypeOfNumber ) || + ( aNotifyCFIndicator.iCFNumber.iNumberPlan != + iCurrentTCFIndicator.iCFNumber.iNumberPlan ) || + KErrNotFound == ( aNotifyCFIndicator.iCFNumber.iTelNumber.Match( + iCurrentTCFIndicator.iCFNumber.iTelNumber ) ) ) + { + changed = ETrue; + } + + return changed; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCellInfoL +// Gets GSM/WCDMA cell(s) info. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCellInfoL( + TDes8* aCellInfoPckg ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetCellInfo"); + + TInt ret = KErrServerBusy; + + // Try to get request handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetCellInfo ); + + if ( ECustomTsyReqHandleUnknown == reqHandle ) + { + ret = KErrArgument; + + if ( sizeof( RMmCustomAPI::TMmCellInfo ) <= + aCellInfoPckg->MaxLength() ) + { + iCellInfoPckg = REINTERPRET_CAST( + RMmCustomAPI::TMmCellInfoPckg*, aCellInfoPckg ); + + ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetCellInfoIPC ); + + if ( KErrNone == ret ) + { + // Save request handle in DoExtFuncL() + iReqHandleType = ECustomTsyGetCellInfo; + } + } + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetCellInfoCancel +// Cancels an outstanding GetCellInfo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetCellInfoCancel() + { +TFLOGSTRING("TSY: CMmCustomTsy::GetCellInfoCancel"); + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCellInfo ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset pointer to client data + iCellInfoPckg = NULL; + + // complete with cancel + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetCellInfo +// Completes an outstanding GetCellInfo request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetCellInfo( + RMmCustomAPI::TMmCellInfo* aCellInfo, + TInt aErrorValue ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteGetCellInfo - aErrorValue %d", aErrorValue); + + // reset the req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetCellInfo ); + + // check the validity of the handler + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aErrorValue ) + { + RMmCustomAPI::TMmCellInfo& tempCellInfo = ( *iCellInfoPckg )(); + tempCellInfo = *aCellInfo; + } + // reset the pointer to client space + iCellInfoPckg = NULL; + + // complete operation + ReqCompleted ( reqHandle, aErrorValue ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyCellInfoChange +// Notification cell(s) info changes +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyCellInfoChange( + TDes8* aCellInfoPckg ) + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyCellInfoChange"); + + RMmCustomAPI::TMmCellInfo temp; + RMmCustomAPI::TMmCellInfoPckg tempPckg(temp); + + TInt paramLength = aCellInfoPckg->MaxLength(); + TInt expectedLength = tempPckg.MaxLength(); + + TInt ret = KErrArgument; + if (paramLength == expectedLength) + { + iRetNotifyCellInfoPckg = REINTERPRET_CAST( RMmCustomAPI::TMmCellInfoPckg*, aCellInfoPckg ); + // set the reqhandle type + iReqHandleType = ECustomTsyNotifyCellInfoChange; + + ret = KErrNone; + } + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyCellInfoChange +// Complete cell info change notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyCellInfoChange( + RMmCustomAPI::TMmCellInfo* aCellInfo, + TInt aErrorCode ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteNotifyCellInfoChange Error: %d", aErrorCode); + + // Check if notification was requested + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCellInfoChange ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + RMmCustomAPI::TMmCellInfo& tempCellInfo = ( *iRetNotifyCellInfoPckg )(); + tempCellInfo = *aCellInfo; + } + // reset the internal variable + iRetNotifyCellInfoPckg = NULL; + + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyCellInfoChangeCancel +// Cancel cell info change notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyCellInfoChangeCancel() + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyCellInfoChangeCancel"); + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyCellInfoChange ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset the pointer to client data + iRetNotifyCellInfoPckg = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetPhonebookCacheStatus +// Get Phonebook cache status +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +RMmCustomAPI::TPndCacheStatus CMmCustomTsy::GetPhonebookCacheStatus( + TUint8 aPhoneBookType ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetPhonebookCacheStatus"); + RMmCustomAPI::TPndCacheStatus ret( RMmCustomAPI::ECacheNotUsed ); + + switch ( aPhoneBookType ) + { + case KADNPhoneBook: + ret = iAdnCacheStatus; + break; + case KFDNPhoneBook: + ret = iFdnCacheStatus; + break; + case KSDNPhoneBook: + case KVMBXPhoneBook: + case KMBDNPhoneBook: + ret = RMmCustomAPI::ECacheNotUsed; + break; + } + + return ret; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::ReqCompleted +// Completes a request back to the client. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::ReqCompleted( const TTsyReqHandle aTsyReqHandle, + const TInt aError ) + { +TFLOGSTRING3("TSY: CMmCustomTsy::ReqCompleted, aTsyReqHandle=%d, aError=%d", aTsyReqHandle, aError ); + + CTelObject::ReqCompleted ( aTsyReqHandle, aError ); + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetSystemNetworkBandL +// This method gets the supported network band. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetSystemNetworkBandL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TBandSelection* aSystemNetworkBand, + RMmCustomAPI::TNetworkModeCaps* aSystemNetworkMode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetSystemNetworkBandL"); + TTsyReqHandle reqhandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetSystemNetworkBand ); + + if ( ECustomTsyReqHandleUnknown < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to the packaged life timer info + iAvailableSystemNetworkBand = aSystemNetworkBand; + iSystemNetworkModeCaps = aSystemNetworkMode; + // call DOS + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetBandSelectionIPC ); + + // Check response of the extension + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsyGetSystemNetworkBand; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetSystemNetworkBand +// Completes a GetSystemNetworkBand. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetSystemNetworkBand( + RMmCustomAPI::TBandSelection aSystemNetworkBand, + RMmCustomAPI::TNetworkModeCaps aSystemNetworkMode, + TInt aResult ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::CompleteGetSystemNetworkBand. Result: %d", aResult); + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSystemNetworkBand ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + + if ( KErrNone == aResult ) + { + // set the information for the client + *iAvailableSystemNetworkBand = aSystemNetworkBand; + if ( *iSystemNetworkModeCaps != aSystemNetworkMode ) + { + *iSystemNetworkModeCaps = aSystemNetworkMode; + } + } + + // complete + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetSystemNetworkBandCancel +// Cancels a GetSystemNetworkBand. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetSystemNetworkBandCancel( + const TTsyReqHandle aTsyReqHandle ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetSystemNetworkBandCancel"); + // reset the pointer to client data + iAvailableSystemNetworkBand = NULL; + iSystemNetworkModeCaps = NULL; + + // reset the reqhandle + iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetSystemNetworkBand ); + + // complete + ReqCompleted( aTsyReqHandle, KErrCancel ); + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetSystemNetworkBandL +// This method sets the system network band. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::SetSystemNetworkBandL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TBandSelection* aSystemNetworkBand, + RMmCustomAPI::TNetworkModeCaps* aSystemNetworkModeCaps ) + { +TFLOGSTRING("TSY: CMmCustomTsy::SetSystemNetworkBandL"); + TTsyReqHandle reqhandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsySetSystemNetworkBand ); + + if ( ECustomTsyReqHandleUnknown < reqhandle ) + { + // The request is already in processing because of previous request + // Complete request with status value informing the client about + // the situation. + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // call DOS + // The networkband to be set + RMmCustomAPI::TBandSelection networkBand = + *aSystemNetworkBand; + // Used network mode + RMmCustomAPI::TNetworkModeCaps networkMode = + *aSystemNetworkModeCaps; + CMmDataPackage dataPackage; + // Pack network mode and band + dataPackage.PackData( &networkBand, &networkMode ); + TInt ret = Phone()->MessageManager()->HandleRequestL( + ECustomSetBandSelectionIPC, &dataPackage ); + + // Check response of the extension + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Save the req handle type + iReqHandleType = ECustomTsySetSystemNetworkBand; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteSetSystemNetworkBand +// Completes a SetSystemNetworkBand. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteSetSystemNetworkBand( + TInt aResult ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteSetSystemNetworkBand"); + // reset req handle. Returns the deleted req handle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsySetSystemNetworkBand ); + + // check if handle exists + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // complete + ReqCompleted( reqHandle, aResult ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::SetIccCfBootUpFlag +// Set new value for ICC CF bootup. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::SetIccCfBootUpFlag( TBool aBootUp ) + { +TFLOGSTRING2("TSY: CMmCustomTsy::SetIccCfBootUpFlag, aBootUp=%d", aBootUp ); + + iGetIccCfStatusBootUp = aBootUp; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetUSIMServiceSupportL +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetUSIMServiceSupportL( + const TTsyReqHandle aTsyReqHandle, + RMmCustomAPI::TAppSupport* aAppSupport ) + { +TFLOGSTRING("TSY: CMmCustomTsy::GetUSIMServiceSupportL"); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->GetTsyReqHandle( + ECustomTsyGetUSIMServiceSupport ); + + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + ReqCompleted( aTsyReqHandle, KErrServerBusy ); + } + else + { + // save pointer to client data + iAppSupport = aAppSupport; + + CMmDataPackage appSupportPackage; + appSupportPackage.PackData( iAppSupport ); + + // call DOS (no packed parameters) + TInt ret = KErrNone; + ret = Phone()->MessageManager()->HandleRequestL( + ECustomGetServiceTableSupportbyApplicationIPC, &appSupportPackage); + + // check the result of the call + if ( KErrNone != ret ) + { + ReqCompleted( aTsyReqHandle, ret ); + } + else + { + // Store the request handle + iReqHandleType = ECustomTsyGetUSIMServiceSupport; + } + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteGetUSIMServiceSupport +// Completes a GetUSIMServiceSupport request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteGetUSIMServiceSupport( + CMmDataPackage* aDataPackage, + TInt aErrorCode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteGetUSIMServiceSupport"); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetUSIMServiceSupport ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + if ( KErrNone == aErrorCode ) + { + RMmCustomAPI::TAppSupport *appSupport; + aDataPackage->UnPackData( &appSupport ); + + // set the information for the client + *iAppSupport = *appSupport; + + // reset the internal variable + iAppSupport = NULL; + + //Complete request to success + ReqCompleted( reqHandle, KErrNone ); + } + else + { + // Complete with error + ReqCompleted( reqHandle, aErrorCode ); + } + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::GetUSIMServiceSupportCancel +// Cancels a GetUSIMServiceSupport request +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::GetUSIMServiceSupportCancel() + { +TFLOGSTRING("TSY: CMmCustomTsy::GetUSIMServiceSupportCancel"); + + // reset the reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyGetUSIMServiceSupport ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset the pointer to client data + iAppSupport = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyRemoteAlertingToneStatusChange +// Sets Remote Alerting Tone Status Change notification +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyRemoteAlertingToneStatusChange( + RMmCustomAPI::TRemoteAlertingToneStatus* aToneStatus ) + { +TFLOGSTRING("TSY: CMmCustomTsy::NotifyRemoteAlertingToneStatusChange"); + + // save pointer to client data + iToneStatus = aToneStatus; + + // save handle type + iReqHandleType = ECustomTsyNotifyRemoteAlertingToneStatusChange; + + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::CompleteNotifyRemoteAlertingToneStatusChange +// Completes a NotifyRemoteToneAlertingStatusChange request. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +void CMmCustomTsy::CompleteNotifyRemoteAlertingToneStatusChange( + RMmCustomAPI::TRemoteAlertingToneStatus aToneStatus, + TInt aErrorCode ) + { +TFLOGSTRING("TSY: CMmCustomTsy::CompleteNotifyRemoteAlertingToneStatusChange"); + + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyRemoteAlertingToneStatusChange ); + + // check if request was called + if ( ECustomTsyReqHandleUnknown != reqHandle ) + { + // check if response was ok + if ( KErrNone == aErrorCode ) + { + // set the information for the client + *iToneStatus = aToneStatus; + } + + // reset the internal variable + iToneStatus = NULL; + // complete + ReqCompleted( reqHandle, aErrorCode ); + } + } + +// --------------------------------------------------------------------------- +// CMmCustomTsy::NotifyRemoteAlertingToneStatusChangeCancel +// This method cancels an outstanding notification of +// RemoteAlertingToneStatusChange. +// (other items were commented in a header). +// --------------------------------------------------------------------------- +// +TInt CMmCustomTsy::NotifyRemoteAlertingToneStatusChangeCancel() + { + // reset reqhandle + TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( + ECustomTsyNotifyRemoteAlertingToneStatusChange ); + + if( ECustomTsyReqHandleUnknown != reqHandle ) + { + // reset pointer to client data + iToneStatus = NULL; + + ReqCompleted( reqHandle, KErrCancel ); + } + + return KErrNone; + } + +// End of File