/*

* Copyright (c) 2002-2007 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:  Opens ETel RTelServer and RMobilePhone

*

*/

// INCLUDE FILES

#include "CPhone.h"

// From Virtual Phonebook

#include "CServiceTableCmd.h"

#include "CUsimAdnStore.h"

#include "CAdnStore.h"

#include "CFdnStore.h"

#include "CSdnStore.h"

#include "COwnNumberStore.h"

#include "CSatRefreshNotifier.h"

#include "CBtSapNotification.h"

#include "TStoreParams.h"

#include "VPbkSimStoreImplError.h"

#include "CSimStatusNotification.h"

#include <MVPbkSimCommand.h>

#include <CVPbkAsyncOperation.h>

#include <CVPbkSimStateInformation.h>

#include <VPbkSimStoreTemplateFunctions.h>

#include <VPbkSimStateDefinitions.h>

#include <CVPbkAsyncCallback.h>

// System includes

#include <mmtsy_names.h>

// DEBUG

#include <VPbkDebug.h>

namespace VPbkSimStoreImpl {

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

// CSimPdUtilities::ConvertStatus

// Converts ETel status to SIMPD status

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

//

MVPbkSimPhone::TFDNStatus ConvertStatus(TInt aETelFDNStatus)

    {

    FUNC_ENTRY();

    MVPbkSimPhone::TFDNStatus status = MVPbkSimPhone::EFdnStatusUnknown;

    switch ( aETelFDNStatus )

        {

        case RMobilePhone::EFdnNotActive:

            {

            status = MVPbkSimPhone::EFdnIsNotActive;

            break;

            }

        case RMobilePhone::EFdnActive:

            {

            status = MVPbkSimPhone::EFdnIsActive;

            break;

            }

        case RMobilePhone::EFdnPermanentlyActive:

            {

            status = MVPbkSimPhone::EFdnIsPermanentlyActive;

            break;

            }

        case RMobilePhone::EFdnNotSupported:

            {

            status = MVPbkSimPhone::EFdnIsNotSupported;

            break;

            }

        case RMobilePhone::EFdnUnknown: // FALLTHROUGH

        default:

            {

            // Do nothing

            break;

            }

        }

    FUNC_EXIT();

    return status;

    }

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

// CPhone::CPhone

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPhone::CPhone( CSatRefreshNotifier& aSatNotifier, 

        CVPbkSimStateInformation& aSimStateInfo, 

        CBtSapNotification& aBtSapNotifier )

        :   CActive( EPriorityStandard ),

            iSatNotifier( aSatNotifier ),

            iSimStateInfo( aSimStateInfo ),

            iBtSapNotifier( aBtSapNotifier )

    {

    FUNC_ENTRY();

    CActiveScheduler::Add(this);

    FUNC_EXIT();

    }

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

// CPhone::~CPhone

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

//

CPhone::~CPhone()

    {

    FUNC_ENTRY();

    Cancel();

    delete iSimStatus;

    iSatNotifier.DeActivate( *this );

    iBtSapNotifier.RemoveObserver( *this );

    delete iAsyncOp;

    delete iSTCommand;

    iObservers.Close();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: RMobilePhone Close handle %d"),

        iPhone.SubSessionHandle());

    iPhone.Close();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl: RTelServer Close handle %d"),iTelServer.Handle());

    iTelServer.Close();

    FUNC_EXIT();

    }

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

// CPhone::ETelPhone

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

//

RMobilePhone& CPhone::ETelPhone()

    {

    FUNC_ENTRY();

    return iPhone;

    }

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

// CPhone::CreateStoreLC

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

//

MVPbkSimCntStore* CPhone::CreateStoreLC( TStoreParams& aParams )

    {

    FUNC_ENTRY();

    OpenETelPhoneL();

    VPbkSimStoreImpl::CStoreBase* store = NULL;

    switch ( aParams.iId )

        {

        case EVPbkSimAdnGlobalStore:

            {

            if ( USimAccessSupported() )

                {

                store = VPbkSimStoreImpl::CUsimAdnStore::NewL( aParams );

                }

            else

                {

                store = VPbkSimStoreImpl::CAdnStore::NewL( aParams );

                }

            break;

            }

        case EVPbkSimFdnGlobalStore:

            {

            store = 

                VPbkSimStoreImpl::CFdnStore::NewL( aParams );

            break;

            }

        case EVPbkSimSdnGlobalStore:

            {

            store = 

                VPbkSimStoreImpl::CSdnStore::NewL( aParams );

            break;

            }

        case EVPbkSimONStore:

            {

            store = VPbkSimStoreImpl::COwnNumberStore::NewL( aParams );

            break;

            }

        default:

            {

            __ASSERT_DEBUG( EFalse, VPbkSimStoreImpl::Panic( 

                VPbkSimStoreImpl::ESimStoreNotSupportedYet ) );

            break;

            }

        }

    if ( store )

        {

        CleanupStack::PushL( store );

        }

    FUNC_EXIT();

    return store;

    }

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

// CPhone::AddObserverL

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

//    

void CPhone::AddObserverL( MVPbkSimPhoneObserver& aObserver )

    {

    FUNC_ENTRY();

    if ( iObservers.Find( &aObserver ) == KErrNotFound )

        {

        iObservers.AppendL( &aObserver );

        }

    FUNC_EXIT();

    }

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

// CPhone::RemoveObserver

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

//    

void CPhone::RemoveObserver( MVPbkSimPhoneObserver& aObserver )

    {

    FUNC_ENTRY();

    TInt pos = iObservers.Find( &aObserver );

    if ( pos != KErrNotFound )

        {

        iObservers.Remove( pos );

        }

    FUNC_EXIT();

    }

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

// CPhone::RunL

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

//    

void CPhone::RunL()

    {

    FUNC_ENTRY();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CPhone::RunL: res: % d, ETel FDN status: %d"), 

        iStatus.Int(), iFdnStatus );

    if ( iStatus == KErrNone )

        {

        TInt conversion = ConvertStatus( iFdnStatus );

        SendObserverMessageR( iObservers, 

            &MVPbkSimPhoneObserver::FixedDiallingStatusChanged, 

            conversion );

        }

    ActivateFDNNotification();

    FUNC_EXIT();

    }

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

// CPhone::BtSapDeactivated

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

//    

void CPhone::BtSapActivated()

    {

    FUNC_ENTRY();    

    SendObserverMessageRVV( iObservers, 

        &MVPbkSimPhoneObserver::PhoneError, *this,

        MVPbkSimPhoneObserver::EBtSapActive, KErrGeneral );

    FUNC_EXIT();

    }

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

// CPhone::BtSapDeactivated

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

//    

void CPhone::BtSapDeactivated()

    {

    FUNC_ENTRY();    

    TRAPD( res, HandleBtSapDeactivationL() );

    if ( res != KErrNone )

        {

        SendObserverMessageRVV( iObservers, 

            &MVPbkSimPhoneObserver::PhoneError, *this,

            MVPbkSimPhoneObserver::ESystem, res );    

        }

    FUNC_EXIT();

    }

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

// CPhone::BtSapNotificationError

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

//    

void CPhone::BtSapNotificationError( TInt aError )

    {

    FUNC_ENTRY();

    SendObserverMessageRVV( iObservers, 

        &MVPbkSimPhoneObserver::PhoneError, *this,

        MVPbkSimPhoneObserver::ESystem, aError );

    FUNC_EXIT();

    }

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

// CPhone::DoCancel

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

//    

void CPhone::DoCancel()

    {

    FUNC_ENTRY();

    iPhone.CancelAsyncRequest( EMobilePhoneNotifyFdnStatusChange );

    FUNC_EXIT();

    }

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

// CPhone::OpenL

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

//

void CPhone::OpenL( MVPbkSimPhoneObserver& aObserver )

    {

    FUNC_ENTRY();

    MVPbkSimPhoneObserver::TErrorIdentifier errorId;

    if ( SimUsableL( errorId ) )

        {

        OpenETelPhoneL();

        if ( !StartInitL() && iIsOpen )

            {

            // store is open

            CVPbkAsyncObjectCallback<MVPbkSimPhoneObserver>* callback =

                VPbkEngUtils::CreateAsyncObjectCallbackLC(

                    *this, 

                    &CPhone::DoOpenL, 

                    &CPhone::DoOpenError, 

                    aObserver );

            AsyncOpL()->CallbackL( callback );

            CleanupStack::Pop( callback );

            }    

        }

    else

        {

        CVPbkAsyncObjectCallback<MVPbkSimPhoneObserver>* callback =

                VPbkEngUtils::CreateAsyncObjectCallbackLC(

                    *this, 

                    &CPhone::DoOpenWithErrorL,

                    errorId,

                    &CPhone::DoOpenError,

                    aObserver );

            AsyncOpL()->CallbackL( callback );

            CleanupStack::Pop( callback );

        }

    if ( iObservers.Find( &aObserver ) == KErrNotFound )

        {

        iObservers.AppendL( &aObserver );

        }

    FUNC_EXIT();

    }

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

// CPhone::Close

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

//

void CPhone::Close( MVPbkSimPhoneObserver& aObserver )

    {

    FUNC_ENTRY();

    if ( iAsyncOp )

        {

        iAsyncOp->CancelCallback( &aObserver );

        }

    TInt index = iObservers.Find( &aObserver );

    if ( index != KErrNotFound )

        {

        iObservers.Remove( index );

        }

    if ( iObservers.Count() == 0 )

        {

        if ( iAsyncOp )

            {

            iAsyncOp->Purge();

            }

        }

    FUNC_EXIT();

    }

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

// CPhone::USimAccessSupported

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

//

TBool CPhone::USimAccessSupported() const

    {

    FUNC_ENTRY();

    TBool supported = EFalse;

    TUint32 iccCaps;

    TInt result = iPhone.GetIccAccessCaps( iccCaps );

    if ( result == KErrNone && 

         iccCaps & RMobilePhone::KCapsUSimAccessSupported )

        {

        supported = ETrue;

        }

    FUNC_EXIT();

    return supported;

    }

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

// CPhone::ServiceTable

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

//

TUint32 CPhone::ServiceTable() const

    {

    FUNC_ENTRY();

    return iServiceTable;

    }

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

// CPhone::FixedDialingStatus

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

//

MVPbkSimPhone::TFDNStatus CPhone::FixedDialingStatus() const

    {

    FUNC_ENTRY();

    RMobilePhone::TMobilePhoneFdnStatus etelStatus = RMobilePhone::EFdnUnknown;

    TFDNStatus ownStatus = EFdnStatusUnknown;

    TInt result = iPhone.GetFdnStatus( etelStatus );

    if ( result == KErrNone )

        {

        ownStatus = ConvertStatus( etelStatus );

        }

    FUNC_EXIT();

    return ownStatus;

    }

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

// CPhone::CommandDone

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

//

void CPhone::CommandDone( MVPbkSimCommand& aCommand )

    {

    FUNC_ENTRY();

    if ( iSTCommand == &aCommand )

        {   

        // Delete the service table command

        delete iSTCommand;

        iSTCommand = NULL;

        // Activate observing BT SAP and SAT refresh.        

        TRAPD( res, ActivateBtSapAndSatRefreshL() );

        if ( res != KErrNone )

            {

            CommandError( aCommand, res );

            }

        else if ( !iIsOpen )

            {

            // The phone is open after service table have been read

            iIsOpen = ETrue;

            SendObserverMessageR( iObservers, 

                &MVPbkSimPhoneObserver::PhoneOpened, *this );

            }

        else

            {

            // It was already open so inform observers about updated table

            SendObserverMessageR( iObservers, 

                &MVPbkSimPhoneObserver::ServiceTableUpdated, iServiceTable );

            }

        // Service table is reloaded when SIM is refreshed and we

        // have to tell SAT server that we have updated ourselves.

        CompleteSatRefresh();

        }

    FUNC_EXIT();

    }

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

// CPhone::CommandError

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

//

void CPhone::CommandError( MVPbkSimCommand& aCommand, TInt aError )

    {

    FUNC_ENTRY();

    if ( iSTCommand == &aCommand )

        {

        delete iSTCommand;

        iSTCommand = NULL;

        SendObserverMessageRVV( iObservers, 

            &MVPbkSimPhoneObserver::PhoneError, *this,

            MVPbkSimPhoneObserver::ESystem, aError );

        // Service table is reloaded when SIM is refreshed. If this fails

        // SAT server is still waiting client notifying.

        CompleteSatRefresh();

        }

    FUNC_EXIT();

    }

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

// CPhone::SimRefreshed

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

//

void CPhone::SimRefreshed( TUint32 aSimRefreshFlags,

        MSimRefreshCompletion& aSimRefreshCompletion )

    {

    FUNC_ENTRY();

    // SAT notifier tells that SIM has been refreshed

    VPBK_DEBUG_PRINT(

        VPBK_DEBUG_STRING("CPbkSimStoreImpl:CPhone::SimRefreshed [%x]"), aSimRefreshFlags );

    // Check if there are elementary files that this class is interested in.

    // In practise service table file.

    TBool completeNow = ETrue;

    if ( aSimRefreshFlags & ElementaryFiles() )

        {

        // Service table has been updated -> load service table asynchronously.

        TRAPD( res, LoadServiceTableL() );

        VPBK_DEBUG_PRINT(

            VPBK_DEBUG_STRING("CPbkSimStoreImpl:CPhone LoadServiceTableL [%i]"), res );

        if ( res != KErrNone )

            {

            SendObserverMessageRVV( iObservers, 

                &MVPbkSimPhoneObserver::PhoneError, *this,

                MVPbkSimPhoneObserver::ESystem, res );

            }

        else

            {

            // Save completion to complete refresh later

            iSimRefreshCompletion = &aSimRefreshCompletion;

            completeNow = EFalse;

            }

        }

    // If we didn't start asyncrhonous update then complete refresh because