// 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 );
#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];
}
// Delete SecurityTsy
delete iMmSecurityTsy;
// Delete GSM extensions
delete iMmCustomExtInterface;
// delete req handle store
delete iTsyReqHandleStore;
if ( iMmPhoneTsy )
{
iMmPhoneTsy->SetHomeZoneParamsChecked( EFalse );
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 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:
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:
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:
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:
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 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
{
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 );
// allow for ECustomSetDriveModeIPC immediate completion
#ifdef REQHANDLE_TIMER
// set timer for the request
SetTypeOfResponse ( ECustomTsySetDriveMode, aTsyReqHandle );
#else
iTsyReqHandleStore->SetTsyReqHandle( ECustomTsySetDriveMode,
aTsyReqHandle );
#endif // REQHANDLE_TIMER
TInt ret = iMmPhoneTsy->MessageManager()->HandleRequestL(
ECustomSetDriveModeIPC, &dataPackage );
// check success
if ( (KErrNone != ret) && (iTsyReqHandleStore->ResetTsyReqHandle(ECustomTsySetDriveMode)) )
{
ReqCompleted ( aTsyReqHandle, ret );
}
}
}
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