--- /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 <ctsy/tflogger.h>
+#include "cmmpblist.h"
+#include "cmmphonebookstoretsy.h"
+#include "CMmPacketTsy.h"
+#include "CMmSIMTsy.h"
+#include "CMmCustomSecurityTsy.h"
+#include <ctsy/serviceapi/gsmerror.h>
+#include <ctsy/serviceapi/cmmcustomvendorext.h>
+#include "cmmnettsy.h" // for CMmNetTsy::CipheringIndicatorForcedOff()
+#include <ctsy/serviceapi/ctsydomaincrkeys.h>
+#include "ctsyprivatecrpkeys.h"
+#include <featureuids.h>
+
+// ======== 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<TUint32> 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<TUint32> 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<TUint32> 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