// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

//  INCLUDE FILES

#include "CMmCustomTsy.h"

#include "CMmCustomGsmExt.h"

#include "cmmcalllist.h"

#include "cmmphoneextinterface.h"

#include "CMmWimTsy.h"

#include "cmmcalltsy.h"

#include "CMmCommonStaticUtility.h"

#include "CMmSimLockTsy.h"

#include "MmTsy_conf.h"

#include <ctsy/tflogger.h>

#include "cmmpblist.h"

#include "cmmphonebookstoretsy.h"

#include "CMmPacketTsy.h"

#include "CMmSIMTsy.h"

#include "CMmCustomSecurityTsy.h"

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/serviceapi/cmmcustomvendorext.h>

#include "cmmnettsy.h"  // for CMmNetTsy::CipheringIndicatorForcedOff()

#include <ctsy/serviceapi/ctsydomaincrkeys.h>

#include "ctsyprivatecrpkeys.h"

#include <featureuids.h>

// ======== MEMBER FUNCTIONS ========

CMmCustomTsy::CMmCustomTsy()

    {

    iMmPhoneTsy = NULL;

    iMmCustomExtInterface = NULL;

    Mem::FillZ( iMmSubTsy, sizeof( iMmSubTsy ) );

    // initialize internal data

    iCipheringInfo.iIndStatus = EFalse;

    iCipheringInfo.iCiphStatus = EFalse;

    }

void CMmCustomTsy::ConstructL(

    CMmPhoneTsy* aMmPhoneTsy )

    {

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL");

    iMmPhoneTsy = aMmPhoneTsy;

    iMmCustomExtInterface = CMmCustomGsmExt::NewL( aMmPhoneTsy, this );

    iMmSubTsy[ESubTsyIdxWIM] = CMmWimTsy::NewL( this );

    iMmSubTsy[ESubTsyIdxSimLock] = CMmSimLockTsy::NewL( this );

    iMmSubTsy[ESubTsyIdxPacket] = CMmPacketTsy::NewL( this, aMmPhoneTsy );

    iMmSubTsy[ESubTsyIdxSIM]  = CMmSIMTsy::NewL( this );

    iMmSecurityTsy = CMmCustomSecurityTsy::NewL( this, aMmPhoneTsy );

    // Create custom vendor extension

    // Send request to the Domestic OS layer.

    iMmCustomVendorExt = (CMmCustomVendorExt*) NULL;

    CMmDataPackage package;

    package.PackData( &iMmCustomVendorExt ); // ptr to ptr

    Phone()->MessageManager()->HandleRequestL(

            EMmTsyGetCustomVendorExtPtrIPC, &package );

TFLOGSTRING2("TSY: CMmCustomTsy::ConstructL -- iMmCustomVendorExt=0x%x", TUint(iMmCustomVendorExt));

    // The request above is 'completed' immediatedly (there is no need for

    // actual complete)

    // iMmCustomVendorExt should now hold ptr to custom vendor extension.

    // But if not, no problem, we just use the base class.

    if ( NULL == iMmCustomVendorExt )

        {

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL -- no vendor IPC extensions");

        iMmCustomVendorExt = new(ELeave)CMmCustomVendorExt();

        }

    // initialize custom vendor extension 

    iMmCustomVendorExt->InitializeL( *this );

#ifdef REQHANDLE_TIMER

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhoneTsy,

        ECustomTsyMaxNumOfRequests, iCustomReqHandles );

#else

    // Create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(

        ECustomTsyMaxNumOfRequests, iCustomReqHandles );

#endif

    // register custom tsy in the message manager

    Phone()->MessageManager()->RegisterTsyObject(

        CMmMessageManagerBase::ECustomTsy, this );

    iAdnCacheStatus = RMmCustomAPI::ECacheNotReady;

    iFdnCacheStatus = RMmCustomAPI::ECacheNotReady;

    iISVDialNumberCheckObject = NULL;

    iISVDialNumberCheck = EFalse;

    iGetIccCfStatusBootUp = ETrue;

    //Get pointer to public CenRep

    iCFISCentRep = iMmPhoneTsy->GetCfisCenRep();

    iCFISPrivateCentRep = iMmPhoneTsy->GetCfisPRCenRep();

	TInt err = iFeatureControl.Open();

	iUsingFeatureManager = (err == KErrNone);

    // update/receive Icc Call forward information

    if( iMmPhoneTsy->NosBootState()->iSIMReady )

        {

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL -- GET ICC call forward indicators");       

        // Get Icc cfis values from LTSY

        Phone()->MessageManager()->HandleRequestL( 

            ECustomGetIccCallForwardingStatusIPC );

        }

    // check if HomeZoneParams has been already read in NotifySimStatusReady

 	// if not, query again

    if ( !iMmPhoneTsy->GetHomeZoneParamsChecked() )

    	{

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - GetHomeZoneParamsChecked()");    	

        CMmSIMTsy* simCustomTsy = NULL;

        simCustomTsy = ( CMmSIMTsy* )GetSIMTsyPtr();

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - pointer created");

        if ( simCustomTsy )

            {

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - CheckViagHomeZoneParamsL()");

            simCustomTsy->CheckViagHomezoneParamsL();

            iMmPhoneTsy->SetHomeZoneParamsChecked( ETrue );

            }

        else

        	{

TFLOGSTRING("TSY: CMmCustomTsy::ConstructL - CheckViagHomeZoneParamsL() False");        		

			iMmPhoneTsy->SetHomeZoneParamsChecked( EFalse );

        	}

    	}     

    }

CMmCustomTsy* CMmCustomTsy::NewL(

    CMmPhoneTsy* aMmPhoneTsy )

    {

TFLOGSTRING("TSY: CMmCustomTsy::NewL");

    CMmCustomTsy* mmCustomTsy = new ( ELeave ) CMmCustomTsy();

    CleanupClosePushL( *mmCustomTsy );

    mmCustomTsy->ConstructL( aMmPhoneTsy );

    CleanupStack::Pop( mmCustomTsy );

    return mmCustomTsy;

    }

CMmCustomTsy::~CMmCustomTsy()

    {

TFLOGSTRING("TSY: CMmCustomTsy::~CMmCustomTsy");

	iFeatureControl.Close();

    // Delete subsystems

    for ( TInt i = 0; ESubTsyIdxMaxNum > i; i++ )

        {

        delete iMmSubTsy[i];

        }

    if ( iMmCustomVendorExt )

        {

        // delete vendor extension

        delete iMmCustomVendorExt;

        }

    if ( iMmSecurityTsy )

        {

        // Delete SecurityTsy

        delete iMmSecurityTsy;

        }

    if ( iMmCustomExtInterface )

        {

        // Delete GSM extensions

        delete iMmCustomExtInterface;

        }

    if ( iTsyReqHandleStore )

        {

        // delete req handle store

        delete iTsyReqHandleStore;

        }

    iMmCustomVendorExt = NULL;

    iMmSecurityTsy = NULL;

    iMmCustomExtInterface = NULL;

    iTsyReqHandleStore = NULL;

    iISVDialNumberCheckObject = NULL;

    iCFISCentRep = NULL;

    if ( iMmPhoneTsy )

        {

        iMmPhoneTsy->SetCustomTsy( NULL );

        // unregister custom tsy in the message manager

        iMmPhoneTsy->MessageManager()->DeregisterTsyObject(this);

        }

    }

// ---------------------------------------------------------------------------

// CMmCustomTsy::Phone

// Returns pointer to PhoneTsy object

// (other items were commented in a header).

// ---------------------------------------------------------------------------

//

CMmPhoneTsy* CMmCustomTsy::Phone()

    {

    return iMmPhoneTsy;

    }

// ---------------------------------------------------------------------------

// CMmCustomTsy::ExtFunc

// Dispatches extension function requests. All functions that are not part

// of the core function set, are routed via the ExtFunc method.

// At the beginning of this method, packaged pointers are unpacked. Then

// the correct function is selected using the IPC number.

// (other items were commented in a header).

// ---------------------------------------------------------------------------

//

TInt CMmCustomTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret = KErrNone;

    TInt trapError = KErrNone;

    iReqHandleType = ECustomTsyReqHandleUnknown;

    // before processing further the request, check if offline mode status

    // is enabled and if the given request can be perfomed in that case.

    if ( ERfsStateInfoInactive == iMmPhoneTsy->GetRfStateInfo() &&

        !IsRequestPossibleInOffline( aIpc ) )

        {

TFLOGSTRING2 ("TSY: Offline mode ON, request is not allowed: %d", aIpc );

        ret = CMmCommonStaticUtility::EpocErrorCode( KErrGeneral,

                KErrGsmOfflineOpNotAllowed );

        // Complete the request with appropiate error

        ReqCompleted ( aTsyReqHandle, ret );

        }

    else

        {

        TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

        if ( KErrNone != trapError )

            {

            // error handling. Object cannot be created.

            ret = trapError;

            }

        if ( KErrNone != ret )

            {

            ReqCompleted( aTsyReqHandle, ret );

            }

        }

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CMmCustomTsy::DoExtFuncL

// This DoExtFuncL is called by Etel server when it has Custom API

// request for the TSY. To process a request handle, request type and request

// data are passed to the Custom TSY.

// (other items were commented in a header).

// ---------------------------------------------------------------------------

//

TInt CMmCustomTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNotSupported );

    // first check if request is supported in CMmSecurityTsy

    // (due layering that class is no longer a part of extension modules)

    ret = iMmSecurityTsy->DoExtFuncL( aTsyReqHandle, aIpc, aPackage );

    if ( KErrNotSupported == ret )

        {

        // then check if this is vendor extension IPC

        // these IPCs are handled by VendorExt class in licensee tsy.

       if ( iMmCustomVendorExt->SupportingIPC(aIpc) )

          {

          ret = iMmCustomVendorExt->DoExtFuncL( aTsyReqHandle, aIpc,

                    aPackage );

          }

       else

          {

          // then check all the Custom extension modules

          ret = CMmTsyBase::DoBaseExtFuncL( aTsyReqHandle, aIpc, aPackage );

	      }

        // if extension modules did not serve this request

        if ( KErrNotSupported == ret )

            {

            // reset last tsy request type

            iReqHandleType = ECustomTsyReqHandleUnknown;

            switch ( aIpc )

                {

                // Perform IMS Authentication

                case EMobilePhoneIMSAuthenticate:

                    ret = ImsAuthenticationL( aTsyReqHandle,

                        REINTERPRET_CAST(

                        RMobilePhone::TImsAuthenticateDataV5*,

                        aPackage.Ptr1() ) );

                    break;

                // Get sim authentication data

                case ECustomGetSimAuthenticationDataIPC:

                    ret = SimAuthenticationL( aTsyReqHandle, aPackage );

                    break;

                // Notify Dtmf event

                case ECustomNotifyDtmfEventIPC:

                    ret = NotifyDtmfEvent(

                        REINTERPRET_CAST( RMmCustomAPI::TDtmfInfo*,

                        aPackage.Ptr1() ) );

                    break;

                // Get Diagnostic Octets - info 

                case ECustomGetDiagnosticOctetsIPC:

                   ret = GetDiagnosticInfo ( aTsyReqHandle,

                       REINTERPRET_CAST( TName*, aPackage.Ptr1() ) );

                   break;

                // Get Remote Alerting Tone Status

                case ECustomGetRemoteAlertingToneStatusIPC:

                    ret = GetRemoteAlertingToneStatus ( aTsyReqHandle,

                        REINTERPRET_CAST(

                        RMmCustomAPI::TRemoteAlertingToneStatus*,

                        aPackage.Ptr1() ) );

                    break;

                // Call Origin

                case ECustomCallOriginIPC:

                    ret = GetCallOrigin( aTsyReqHandle,

                        REINTERPRET_CAST( TName*, aPackage.Ptr1() ),

                        REINTERPRET_CAST( RMmCustomAPI::TCallOrigin*,

                        aPackage.Ptr2() ) );

                    break;

                // Terminate a Call/all calls

                case ECustomTerminateCallIPC:

                    ret = TerminateCallL( aTsyReqHandle,

                        REINTERPRET_CAST( TName*, aPackage.Ptr1() ) );

                    break;

                // Get Als Blocked

                case ECustomGetAlsBlockedIPC:

                    ret = GetAlsBlockedL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TGetAlsBlockStatus*,

                        aPackage.Ptr1() ) );

                    break;

                // Set Alternative Line Service Blocked

                case ECustomSetAlsBlockedIPC:

                    ret = SetAlsBlockedL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TSetAlsBlock*,

                        aPackage.Ptr1() ) );

                    break;

                // Notify Als Blocked Change

                case ECustomNotifyAlsBlockedChangedIPC:

                    ret = NotifyAlsBlockedChanged (

                        REINTERPRET_CAST( RMmCustomAPI::TGetAlsBlockStatus*,

                        aPackage.Ptr1() ) );

                    break;

                // Get ALS pp support

                case ECustomCheckAlsPpSupportIPC:

                    ret = GetAlsPpSupportL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TAlsSupport*,

                                          aPackage.Ptr1() ) );

                    break;

                // Get ciphering information

                case ECustomGetCipheringInfoIPC:

                    ret = GetCipheringInfoL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TCipheringInfo*,

                        aPackage.Ptr1() ) );

                    break;

                // Notify ciphering information change

                case ECustomNotifyCipheringInfoChangeIPC:

                    ret = NotifyCipheringInfoChange(

                        REINTERPRET_CAST(RMmCustomAPI::TCipheringInfo*,

                        aPackage.Ptr1() ) );

                    break;

                // Notify NSPS status

                case ECustomNotifyNSPSStatusIPC:

                    ret = NotifyNSPSStatus (

                         REINTERPRET_CAST(RMmCustomAPI::TNspsStatus*,

                         aPackage.Ptr1() ) );

                    break;

                // Wake up network from NSPS status

                case ECustomNetWakeupIPC:

                    ret = NetWakeupL( aTsyReqHandle );

                    break;

                case ECustomClearCallBlackListIPC:

                    ret = ClearCallBlackListL ( aTsyReqHandle );

                    break;

                // SS additional info notification

                case ECustomSsAdditionalInfoNotificationIPC:

                     ret = SsAdditionalInfoNotification(

                        REINTERPRET_CAST( RMmCustomAPI::TSsAdditionalInfo*,

                        aPackage.Ptr1() ) );

                     break;

                // Get the air time duration

                case ECustomGetAirTimeDurationIPC:

                    ret = GetAirTimeDuration ( aTsyReqHandle,

                        REINTERPRET_CAST( TTimeIntervalSeconds*,

                        aPackage.Ptr1() ) );

                    break;

                // Check emergency number

                case ECustomCheckEmergencyNumberIPC:

                    ret = CheckEmergencyNumberL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TEmerNumberCheckMode*,

                            aPackage.Ptr1() ),

                        REINTERPRET_CAST( TBool*, aPackage.Ptr2() ) );

                    break;

                // Get Network Operator Name

                case ECustomGetNetworkProviderNameIPC:

                    ret = GetNetworkOperatorNameL( aPackage.Des1u() );

                    break;

                // Get two digit dial support

                case ECustomCheckTwoDigitDialSupportIPC:

                    ret = CheckTwoDigitDialSupportL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TTwoDigitDialSupport*,

                        aPackage.Ptr1() ) );

                    break;

                // Notify when phonebook cache is ready

                case ECustomNotifyPndCacheReadyIPC:

                    ret = NotifyPhoneBookCacheReady( aTsyReqHandle,

                        REINTERPRET_CAST( TName*, aPackage.Ptr1() ) );

                    break;

                // Get phonebook cache status

                case ECustomGetPndCacheStatusIPC:

                    ret = GetPndCacheStatus( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TPndCacheStatus*,

                            aPackage.Ptr1() ),

                        REINTERPRET_CAST( const TName*, aPackage.Des2u() ) );

                    break;

                // Get the programmable operator name

                case ECustomGetOperatorNameIPC:

                    ret = GetOperatorNameL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TOperatorNameInfo*,

                        aPackage.Ptr1() ) );

                    break;

                // Notify SS Network event

                case ECustomNotifySsNetworkEventIPC:

                    ret = NotifySsNetworkEvent(

                        REINTERPRET_CAST( RMmCustomAPI::TSsTypeAndMode*,

                        aPackage.Ptr1() ),

                        REINTERPRET_CAST( RMmCustomAPI::TSsInfo*,

                        aPackage.Ptr2() ) );

                    break;

                // Get the programmable operator logo

                case ECustomGetProgrammableOperatorLogoIPC:

                    ret = GetProgrammableOperatorLogoL( aTsyReqHandle,

                        REINTERPRET_CAST( RMmCustomAPI::TOperatorId*,

                        aPackage.Ptr1() ),

                        REINTERPRET_CAST( RMmCustomAPI::TOperatorLogo*,

                        aPackage.Ptr2() ) );

                    break;

                // Sat refresh complete notification

                case ECustomSatRefreshCompleteNotificationIPC:

                    ret = SatRefreshCompleteNotification();

                    break;

                // Reset the net server

                case ECustomResetNetServerIPC:

                    ret = ResetNetServerL( aTsyReqHandle );

                    break;

                // Notify Network Connection Failure

                case ECustomNotifyNetworkConnectionFailureIPC:

                    ret = NotifyNetworkConnectionFailure( );

                    break;

                // Get supported network modes

                case ECustomGetSystemNetworkModesIPC:

                    ret = GetSystemNetworkModesL( aTsyReqHandle,

                        REINTERPRET_CAST(TUint32*, aPackage.Ptr1()) );

                    break;

                // Set system network mode

                case ECustomSetSystemNetworkModeIPC:

                    ret = SetSystemNetworkModeL( aTsyReqHandle,

                        REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*,

                        aPackage.Ptr1()) );

                    break;

                // Get current system network mode

                case ECustomGetCurrentSystemNetworkModesIPC:

                    ret = GetCurrentSystemNetworkModeL( aTsyReqHandle,

                        REINTERPRET_CAST(TUint32*, aPackage.Ptr1()) );

                    break;

                // Get supported network bands

                case ECustomGetBandSelectionIPC:

                    ret = GetSystemNetworkBandL( aTsyReqHandle,

                        REINTERPRET_CAST(RMmCustomAPI::TBandSelection*,

                        aPackage.Ptr1()),

                        REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*,

                        aPackage.Ptr2()) );

                    break;

                // Set system network band

                case ECustomSetBandSelectionIPC:

                    ret = SetSystemNetworkBandL( aTsyReqHandle,

                        REINTERPRET_CAST(RMmCustomAPI::TBandSelection*,

                        aPackage.Ptr1() ),

                        REINTERPRET_CAST(RMmCustomAPI::TNetworkModeCaps*,

                        aPackage.Ptr2() ) );

                    break;

                // Notify SS request complete

                case ECustomNotifySsRequestCompleteIPC:

                    ret = SsRequestCompleteNotification(

                         REINTERPRET_CAST( TInt*, aPackage.Ptr1() ) );

                    break;

                case ECustomGetLifeTimeIPC:

                    ret = GetLifeTimeL( aTsyReqHandle, aPackage.Des1n() );

                    break;

                case ECustomReadSimFileIPC:

                    ret = GetSimFileInfoL(aTsyReqHandle, aPackage.Des1n(),

                        aPackage.Des2n());

                    break;

                // Get 3G phonebook info

                case EGet3GPBInfoIPC:

                    ret = Get3GPBInfo ( aTsyReqHandle,