/*
* Copyright (c) 2003-2006 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:  Contains the implementation of the CCMRegistrationMonitor class
*                the class is used to monitor the registeration status between 
*                the network and phone.
*
*/



// INCLUDE FILES
#include    <basched.h>
#include    "OnlineSupportLogger.h"
#include    "CCMRegistrationMonitor.h"
#include    "MCMRegisterationStatusNotifier.h"

// EXTERNAL DATA STRUCTURES
// None

// EXTERNAL FUNCTION PROTOTYPES  
// None

// CONSTANTS
// PhoneModule name
_LIT( KPhoneModuleName, "Phonetsy.tsy");

_LIT( KPhoneName, "DefaultPhone");

// Time out for the registeration status check
// 15 seconds time-out if the phone was first time unable to receive the network
// status the application will wait 5 seconds for the change of the status
const TInt KMaxInterval = 5; 

// MACROS
// None

// LOCAL CONSTANTS AND MACROS
// None

// MODULE DATA STRUCTURES
// None

// LOCAL FUNCTION PROTOTYPES
// None

// FORWARD DECLARATIONS
// None

// ============================= LOCAL FUNCTIONS ===============================
// None

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

// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::CCMRegistrationMonitor
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//

CCMRegistrationMonitor::CCMRegistrationMonitor( MCMRegisterationStatusNotifier& aNotifier ) :
    CActive( CActive::EPriorityStandard ),
    iMonitoringStatus( EInactive ),
    iNotifier( aNotifier ),
    iRegisterationStatus( RMobilePhone::ERegistrationUnknown ),
    iCurrentNetworkInfoPckg( iCurrentNetworkInfo ),
    iHomeNetworkInfoPckg( iHomeNetworkInfo ),
    iOwnNumberInfoPckg( iOwnNumberInfo ),
    iServiceProviderNamePckg( iServiceProviderName )
    {
    }


// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCMRegistrationMonitor::ConstructL()
    {
    User::LeaveIfError( iServer.Connect() );
    User::LeaveIfError( iServer.LoadPhoneModule( KPhoneModuleName ) );
    iServer.SetExtendedErrorGranularity( RTelServer::EErrorExtended );
    User::LeaveIfError( iPhone.Open( iServer, KPhoneName ) );
    CActiveScheduler::Add(this); 
    }

// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCMRegistrationMonitor* CCMRegistrationMonitor::NewL( MCMRegisterationStatusNotifier& aNotifier )
    {
    CCMRegistrationMonitor* self = new( ELeave ) CCMRegistrationMonitor( aNotifier );    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }
    
// Destructor
CCMRegistrationMonitor::~CCMRegistrationMonitor()
    {
    if( IsActive() )
        {
        Cancel();
        }
    iPhone.Close();
    iServer.Close();
    }


// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::StartMonitoring()
// Starts monitoring of the network registeration status
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCMRegistrationMonitor::StartMonitoring()
    {
    if( IsActive() )
        {
        Cancel();
        }
    iStartTime.HomeTime();
#ifdef __WINS__ // do not try to connect on the emulator
    iRegisterationStatus = RMobilePhone::ERegisteredOnHomeNetwork;
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, KErrNone );
#else
    iPhone.GetNetworkRegistrationStatus( iStatus, iRegisterationStatus );
#endif
    iMonitoringStatus = ERequestingNetworkStatus;
    SetActive();
    }

// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::StopMonitoring()
// Stops the registeration monitor
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCMRegistrationMonitor::StopMonitoring()
    {
    LOGSTRING( "Enter to CCMRegistrationMonitor::StopMonitoring " );
    if( IsActive() )
        {
        Cancel();
        }
    LOGSTRING( "Exit from CCMRegistrationMonitor::StopMonitoring " );
    }

// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::DoCancel()
// Cancels the monitoring
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCMRegistrationMonitor::DoCancel()
    {
    LOGSTRING("CCMRegistrationMonitor::DoCancel");
    switch( iMonitoringStatus )
        {
        case EInactive:
            User::Leave( KErrUnderflow );
            break;
        case ERequestingNetworkStatus:
            iPhone.CancelAsyncRequest( EMobilePhoneGetNetworkRegistrationStatus );
            iMonitoringStatus = EInactive;
            break;
        case EWaitingForChangesInNetworkStatus:
            iPhone.CancelAsyncRequest( EMobilePhoneNotifyNetworkRegistrationStatusChange );
            iMonitoringStatus = EInactive;
            break;
        case ERequestingServiceProviderName:
            iPhone.CancelAsyncRequest( EMobilePhoneGetServiceProviderName );
            iMonitoringStatus = EInactive;
            break;
        case ERequestingHomeNetworkInfo:
            iPhone.CancelAsyncRequest( EMobilePhoneGetHomeNetwork );
            iMonitoringStatus = EInactive;
            break;
        case ERequestingCurrentNetworkInfo:
            iPhone.CancelAsyncRequest( EMobilePhoneGetCurrentNetworkNoLocation );
            iMonitoringStatus = EInactive;
            break;
        case ERequestingOwnNumberInfo:
            iMonitoringStatus = EInactive;
            break;
        case ERequestingPhoneIdentity:
            iPhone.CancelAsyncRequest( EMobilePhoneGetPhoneId );
            iMonitoringStatus = EInactive;
            break;
        case ERequestingIMSI:
            iPhone.CancelAsyncRequest( EMobilePhoneGetSubscriberId );
            iMonitoringStatus = EInactive;
            break;
        default:
            User::Leave( KErrOverflow );
            break;
        }

    TInt err( KErrNone );
    TRAP( err, iNotifier.RegistrationReportErrorL( iMonitoringStatus, KErrCancel ) );
    LOGSTRING("Monitoring Cancelled");
    }

TInt CCMRegistrationMonitor::RunError( TInt aError )
    {
    LOGSTRING2( "CCMRegistrationMonitor::RunError %i", aError );
    TInt err( KErrNone );
    TRAP( err, iNotifier.RegistrationReportErrorL( iMonitoringStatus, aError ) );
    if( err == KLeaveExit )
        {
        User::Leave( KLeaveExit );
        }
    if( aError == KLeaveExit )
        {
        User::Leave( KLeaveExit );
        }
    LOGSTRING( "CCMRegistrationMonitor::RunError - done" );
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CCMRegistrationMonitor::RunL()
// Handles object’s request completion event
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCMRegistrationMonitor::RunL()
    {
    LOGSTRING("Enter to CCMRegistrationMonitor::RunL() ");
    LOGSTRING2( "CCMRegistrationMonitor status %i" , iStatus.Int() );
    TTime currentTime;
    TTimeIntervalSeconds interval;
    TInt seconds;

    switch( iMonitoringStatus )
        {
        case EInactive:
            User::Leave( KErrUnderflow );
            break;
        case ERequestingNetworkStatus:
        case EWaitingForChangesInNetworkStatus:
            {
            LOGSTRING( "ERequestingNetworkStatus | EWaitingForChangesInNetworkStatus" );
            switch( iRegisterationStatus )
                {
                // Not Ok cases
                case RMobilePhone::ERegistrationUnknown:
                case RMobilePhone::ENotRegisteredNoService:
                case RMobilePhone::ENotRegisteredEmergencyOnly:
                case RMobilePhone::ENotRegisteredSearching:
                case RMobilePhone::ERegisteredBusy:
                case RMobilePhone::ERegistrationDenied:
                    currentTime.HomeTime();
                    currentTime.SecondsFrom( iStartTime, interval );
                    seconds = interval.Int();
                    if ( seconds > KMaxInterval )
                        {
                        iMonitoringStatus = EInactive;
                        // Report error
                        iNotifier.RegistrationMonitoringDoneL( EStatusUnknown );
                        }
                    else
                        {
                        iMonitoringStatus = EWaitingForChangesInNetworkStatus;
                        iPhone.NotifyNetworkRegistrationStatusChange( iStatus, iRegisterationStatus );
                        LOGSTRING( "Network registration status change notification started " );
                        SetActive();
                        }
                    break;
                // These are Ok
                case RMobilePhone::ERegisteredOnHomeNetwork:
                case RMobilePhone::ERegisteredRoaming:
                    iMonitoringStatus = ERequestingServiceProviderName;
                    iPhone.GetServiceProviderName( iStatus, iServiceProviderNamePckg );
                    SetActive();
                    break;
                // Some mysterious error
                default:
                    LOGSTRING2( "Unknown network status code! %i", iRegisterationStatus );
                    LOGSTRING2( "ERegisteredOnHomeNetwork: %i", RMobilePhone::ERegisteredOnHomeNetwork );
                    User::Leave( KErrOverflow );
                    break;
                }
            break;
            }
        case ERequestingServiceProviderName:
            LOGSTRING( "ERequestingServiceProviderName" );
            iMonitoringStatus = ERequestingHomeNetworkInfo;
            iPhone.GetHomeNetwork( iStatus, iHomeNetworkInfoPckg );
            SetActive();
            break;
        case ERequestingHomeNetworkInfo:
            LOGSTRING( "ERequestingHomeNetworkInfo" );
            iMonitoringStatus = ERequestingCurrentNetworkInfo;

            // Use the override that does not need Location capability
            iPhone.GetCurrentNetwork(
                iStatus,
                iCurrentNetworkInfoPckg );
                
            SetActive();
            break;
        case ERequestingCurrentNetworkInfo:
            {
            LOGSTRING( "ERequestingCurrentNetworkInfo" );
            iMonitoringStatus = ERequestingOwnNumberInfo;

#ifdef __WINS__
            TRequestStatus* status = &iStatus;
            User::RequestComplete( status, KErrNone );
#else
            TInt err;
            err = iONStore.Open( iPhone );
            if (err != KErrNone) // error occured
                {
                LOGSTRING2( "iONStore.Open err: %i", err );
                User::Leave( err );
                }
            iOwnNumberInfo.iIndex = 0;
            iONStore.Read( iStatus, iOwnNumberInfoPckg );
#endif
            SetActive();
            }
            break;
        case ERequestingOwnNumberInfo:
            {
            LOGSTRING( "ERequestingOwnNumberInfo" );
            iMonitoringStatus = ERequestingPhoneIdentity;
#ifdef __WINS__
            TRequestStatus* status = &iStatus;
            User::RequestComplete( status, KErrNone );
#else
            iPhone.GetPhoneId( iStatus, iPhoneIdentity );
#endif
            SetActive();
            }
            break;
        case ERequestingPhoneIdentity:
            LOGSTRING( "ERequestingPhoneIdentity" );
            iMonitoringStatus = ERequestingIMSI;
            iPhone.GetSubscriberId( iStatus, iIMSI );
            SetActive();
            break;
        case ERequestingIMSI:
            LOGSTRING( "ERequestingIMSI" );
            iMonitoringStatus = EDone;
            switch( iRegisterationStatus )
                {
                case RMobilePhone::ERegisteredOnHomeNetwork:
                    iNotifier.RegistrationMonitoringDoneL( EHomenetwork );
                    break;
                case RMobilePhone::ERegisteredRoaming:
                    iNotifier.RegistrationMonitoringDoneL( ERoaming );
                    break;
                default:
                    iNotifier.RegistrationMonitoringDoneL( EStatusUnknown );
                    break;
                }
            break;
        default:
            LOGSTRING( "default" );
            User::Leave( KErrOverflow );
            break;
        }
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// None

//  End of File