/*
* Copyright (c) 2005 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:   CXcapEarlyIms
*
*/




// INCLUDE FILES
#ifdef _DEBUG
    #include <f32file.h>  
    #include <flogger.h>
    #include <e32debug.h>
#endif
#include <cdblen.h>
#include <commsdat.h>
#include <metadatabase.h>
#include <commsdattypesv1_1.h>
#include <mmretrieve.h>
#include "XcapEarlyIms.h"
#include "XcapUtilsInterface.h"

// ----------------------------------------------------------
// CXcapEarlyIms::CXcapEarlyIms
// 
// ----------------------------------------------------------
//
CXcapEarlyIms::CXcapEarlyIms() : CActive( EPriorityNormal ),
                                 iRequestComplete( EFalse ),
                                 iSimType( ESimTypeUnknown )
                                 
    { 
    }

// ----------------------------------------------------------
// CXcapEarlyIms::NewL
// 
// ----------------------------------------------------------
//
EXPORT_C CXcapEarlyIms* CXcapEarlyIms::NewL()
    {
    CXcapEarlyIms* self = new ( ELeave ) CXcapEarlyIms();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();  //self
    return self;
    }

// ----------------------------------------------------
// CXcapEarlyIms::~CXcapEarlyIms
// 
// ----------------------------------------------------
//
CXcapEarlyIms::~CXcapEarlyIms()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::~CXcapEarlyIms()" ) );
    #endif
    delete iImpu;
    delete iImpi;
    delete iAuthData;
    delete iRetriever;
    iPhone.Close();
    iServer.Close();
    }

// ----------------------------------------------------------
// CXcapEarlyIms::ConstructL
// 
// ----------------------------------------------------------
//
void CXcapEarlyIms::ConstructL()
    {
    #ifdef _DEBUG
        DeleteLogFileL();
        WriteToLog( _L8( "CXcapEarlyIms::ConstructL()" ) );
    #endif
    #ifndef __FAKE_IMPU__
        TName tsyName;
        TInt numPhone = 0;
        TBool found = EFalse;
        RTelServer::TPhoneInfo phoneInfo;
        User::LeaveIfError( iServer.Connect() );
        TBuf<KCommsDbSvrMaxFieldLength> tsyModuleName;
	    ModuleNameL( tsyModuleName );
        User::LeaveIfError( iServer.LoadPhoneModule( tsyModuleName ) );
        User::LeaveIfError( iServer.EnumeratePhones( numPhone ) );
        for( TInt i = 0;!found && i < numPhone;i++ )
            {
            User::LeaveIfError( iServer.GetTsyName( i, tsyName ) );
            User::LeaveIfError( iServer.GetPhoneInfo( i, phoneInfo ) );
            if( tsyName.CompareF( tsyModuleName ) == 0 )
                found = ETrue;
            }
        __ASSERT_ALWAYS( found, User::Leave( KErrNotFound ) );
        User::LeaveIfError( iPhone.Open( iServer, phoneInfo.iName ) ); 
        SelectSimTypeL();
    #endif
    CActiveScheduler::Add( this );    
    } 

// ----------------------------------------------------------
// CXcapEarlyIms::RequestSimDataL
// 
// ----------------------------------------------------------
//
EXPORT_C void CXcapEarlyIms::RequestSimDataL( MXcapEarlyImsObs* aObserver )
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::RequestSimDataL()" ) );
    #endif
    #ifdef __FAKE_IMPU__
        iStatus = KRequestPending;
        TRequestStatus* status = &iStatus;
        User::RequestComplete( status, KErrNone );
        SetActive();
    #else
        if( !IsActive() )
		    {
		    TUint32 caps( 0 );    
            User::LeaveIfError( iPhone.GetIdentityCaps( caps ) );
            if( !( caps & RMobilePhone::KCapsGetSubscriberId ) )
	  	        User::Leave( KErrNotSupported );
            iPhone.GetSubscriberId( iStatus, iImsi );
            iRequestPhase = TRequestAuth;
            iRequestComplete = EFalse;
		    SetActive(); 
    	    }
    #endif 
    iObserver = aObserver;   
    }

// ----------------------------------------------------------
// CXcapEarlyIms::PublicIDL
// 
// ----------------------------------------------------------
//
EXPORT_C TPtrC8 CXcapEarlyIms::PublicIDL()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::PublicIDL()" ) );
    #endif
    #ifdef __FAKE_IMPU__
        return KXcapFakeImpu();
    #else
        if( iRequestComplete && iRequestPhase == TRequestIdle )
            {
            switch( iSimType )
                {
                case ESimTypeWcdma:
                    return iAuthData->iIMPUArray[0]; 
                case ESimTypeGsm:
                    return DeriveL();
                default:
                    return TPtrC8();
                }
            }
        else return TPtrC8(); 
    #endif
    }

// ----------------------------------------------------------
// CXcapEarlyIms::DeriveL
// 
// ----------------------------------------------------------
//
TPtrC8 CXcapEarlyIms::DeriveL()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::DeriveL()" ) );
    #endif
    _LIT8( KImsMnc,       "ims.mnc" );
    _LIT8( KMcc,          ".mcc" );
    _LIT8( K3gppnetwork,  ".3gppnetwork.org");
    _LIT8( KAt,           "@");
    _LIT8( KSip,          "sip:");
    _LIT8( KZero,         "0");
    TPtrC networkDesc( iNetworkInfoPckg().iNetworkId );
    TPtrC countryDesc( iNetworkInfoPckg().iCountryCode );
    TInt nwlength = networkDesc.Length() + countryDesc.Length();
    if( networkDesc.Length() == 2 )
        nwlength = nwlength + 1;
    //private user identity
    TInt impiLength = iImsi.Length() + KAt().Length() + KImsMnc().Length() +
                      nwlength + KMcc().Length() + K3gppnetwork().Length();   
    iImpi = HBufC8::NewL( impiLength );
	TPtr8 impiDesc( iImpi->Des() );
	impiDesc.Append( iImsi );
	impiDesc.Append( KAt );
	impiDesc.Append( KImsMnc );
	if( networkDesc.Length() == 2 )
    	impiDesc.Append( KZero );
	impiDesc.Append( networkDesc );	
	impiDesc.Append( KMcc );	
	impiDesc.Append( countryDesc );
	impiDesc.Append( K3gppnetwork );
    //public user identity
    TInt impuLength = KSip().Length() + impiDesc.Length();
    iImpu = HBufC8::NewL( impuLength );
    TPtr8 impuDesc( iImpu->Des() );
    impuDesc.Append( KSip );
	impuDesc.Append( impiDesc );
	#ifdef _DEBUG
        WriteToLog( _L8( "  IMPI: %S" ), &impiDesc );
        WriteToLog( _L8( "  IMPU: %S" ), &impuDesc );
    #endif
    return impuDesc;  
    }

// ----------------------------------------------------------
// CXcapEarlyIms::SelectSimTypeL
// 
// ----------------------------------------------------------
//
void CXcapEarlyIms::SelectSimTypeL()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::SelectSimTypeL()" ) );
    #endif
	TUint32 caps;
	User::LeaveIfError( iPhone.GetIccAccessCaps( caps ) );
	if( caps & RMobilePhone::KCapsSimAccessSupported )
		{
		if( caps & RMobilePhone::KCapsUSimAccessSupported )
		    {			
		    #ifdef _DEBUG
                WriteToLog( _L8( "  USIM Card" ) );
            #endif
		    iSimType = ESimTypeWcdma;
		    }
		else
		    {
		    #ifdef _DEBUG
                WriteToLog( _L8( "  2G SIM Card" ) );
            #endif
		    iSimType = ESimTypeGsm;
		    }
		}
    else
        {
        #ifdef _DEBUG
            WriteToLog( _L8( "  No SIM Card" ) );
        #endif
        iSimType = ESimTypeUnknown;
        }
    }
		    
// ----------------------------------------------------------
// CXcapEarlyIms::RunL
// 
// ----------------------------------------------------------
//
void CXcapEarlyIms::RunL()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::RunL()" ) );
        WriteToLog( _L8( "  Status:        %d" ), iStatus.Int() );
        WriteToLog( _L8( "  Request phase: %d" ), iRequestPhase );
    #endif
    #ifdef __FAKE_IMPU__
        iObserver->RequestComplete( KErrNone );
    #else
        if( iStatus.Int() == KErrNone )
            {
            switch( iRequestPhase )
                {
                case TRequestIdle:
                    break; 
                case TRequestAuth:
                    {
                    #ifdef _DEBUG
                        HBufC8* buf = HBufC8::NewLC( iImsi.Length() );
                        TPtr8 desc( buf->Des() );
                        desc.Copy( iImsi );
                        WriteToLog( _L8( "  IMSI retrieved: %S" ), &desc );
                        CleanupStack::PopAndDestroy();  //buf
                    #endif
                    iPhone.GetHomeNetwork( iStatus, iNetworkInfoPckg );
                    iRequestPhase = TRequestNetwork;
                    SetActive(); 
                    }
                    break;
                case TRequestNetwork:
                    {
                    #ifdef _DEBUG
                        HBufC8* nwid = HBufC8::NewLC( iNetworkInfoPckg().iNetworkId.Length() );
                        HBufC8* country = HBufC8::NewLC( iNetworkInfoPckg().iCountryCode.Length() );
                        TPtr8 desc1( nwid->Des() );
                        TPtr8 desc2( country->Des() );
                        desc1.Copy( iNetworkInfoPckg().iNetworkId );
                        desc2.Copy( iNetworkInfoPckg().iCountryCode );
                        WriteToLog( _L8( "  Home network info retrieved" ) );
                        WriteToLog( _L8( "    Network ID:   %S" ), &desc1 );
                        WriteToLog( _L8( "    Country code: %S" ), &desc2  );
                        CleanupStack::PopAndDestroy( 2 );  //country, nwid
                    #endif
                    if( iSimType == ESimTypeWcdma )
                        {
    	                iAuthData = RMobilePhone::CImsAuthorizationInfoV5::NewL();
            	        iRetriever = CAsyncRetrieveAuthorizationInfo::NewL( iPhone, *iAuthData );
                        iRequestPhase = TRequestUsimAuth;
	    	            iRetriever->Start( iStatus );
	        	        SetActive();
                        }
                    else
                        {
                        #ifdef _DEBUG
                            WriteToLog( _L8( "  Request complete" ) );
                        #endif
                        iObserver->RequestComplete( KErrNone );
                        iRequestPhase = TRequestIdle;
                        iRequestComplete = ETrue;
                        }
                    }
                    break;
                case TRequestUsimAuth:
                    {
                    #ifdef _DEBUG
                        RMobilePhone::TAuthorizationDataSource source(
                            iAuthData->iAuthenticationDataSource );
                        TBuf8<4> sourceDesc( source == RMobilePhone::EFromUSIM
                            ? _L8( "USIM" ) : _L8( "ISIM" ) );  
                        WriteToLog( _L8( "  USIM auth retrieved" ) );
                        WriteToLog( _L8( "    IMPI:           %S" ), &iAuthData->iIMPI );
                        WriteToLog( _L8( "    IMPU:           %S" ), &iAuthData->iIMPUArray[0] );
                        WriteToLog( _L8( "    Domain:         %S" ), &iAuthData->iHomeNetworkDomainName );
                        WriteToLog( _L8( "    AuthDataSource: %S" ), &sourceDesc );
                    #endif
                    iObserver->RequestComplete( KErrNone );
                    iRequestPhase = TRequestIdle;
                    iRequestComplete = ETrue;
                    }
                    break;
                default:
                    break;
                }
            }
        else iObserver->RequestComplete( iStatus.Int() );
    #endif
    }
    
// ----------------------------------------------------------
// CXcapEarlyIms::DoCancel
// 
// ----------------------------------------------------------
//
void CXcapEarlyIms::DoCancel()
    {
    #ifdef _DEBUG
        WriteToLog( _L8( "CXcapEarlyIms::DoCancel() - State: %d" ), iRequestPhase );
    #endif
    switch( iRequestPhase )
        {
        case TRequestIdle:
            break; 
        case TRequestAuth:
            iPhone.CancelAsyncRequest( EMobilePhoneGetSubscriberId );
            break;
        case TRequestNetwork:
            iPhone.CancelAsyncRequest( EMobilePhoneGetHomeNetwork );
            break;
        case TRequestUsimAuth:
            delete iRetriever;
            iRetriever = NULL;
            break;
        default:
            break;
        }
    }

// ----------------------------------------------------------
// CXcapEarlyIms::ModuleNameL
// 
// ----------------------------------------------------------
//
void CXcapEarlyIms::ModuleNameL( TDes& aModuleName ) const
    {
    __ASSERT_ALWAYS( aModuleName.MaxSize() >= KCommsDbSvrMaxFieldLength, User::Leave( KErrArgument ) );
    using namespace CommsDat;
    CMDBSession* db = CMDBSession::NewLC( KCDLatestVersion );
    CMDBField<TUint32>* field = new ( ELeave ) CMDBField<TUint32>( KCDTIdModemPhoneServicesSMS );
    CleanupStack::PushL( field );
    field->SetRecordId( 1 );
    field->LoadL( *db );
    TUint32 modemId = *field;
    CMDBField<TDesC>* tsyField = new ( ELeave ) CMDBField<TDesC>( KCDTIdTsyName );
    CleanupStack::PushL( tsyField );
    tsyField->SetRecordId( modemId );
    tsyField->LoadL( *db );
    aModuleName = *tsyField;
    CleanupStack::PopAndDestroy( 3 ); //tsyField, field, db
    }
 
#ifdef _DEBUG              
// ----------------------------------------------------
// CXcapEarlyIms::WriteToLog
//
// ----------------------------------------------------
//
void CXcapEarlyIms::WriteToLog( TRefByValue<const TDesC8> aFmt,... )
    {
    VA_LIST list;
    VA_START( list, aFmt );
    TBuf8<KUtilsLogBufMaxSize> buf;
    buf.FormatList( aFmt, list );
    RFileLogger::Write( KUtilsLogDir, KUtilsLogFile, EFileLoggingModeAppend, buf );
    }

// ----------------------------------------------------------
// CXcapEarlyIms::DeleteLogFileL
// 
// ----------------------------------------------------------
//
void CXcapEarlyIms::DeleteLogFileL()
    {
    RFs session;
    TBuf<32> log( _L( "C:\\logs\\XDM\\" ) );
    User::LeaveIfError( session.Connect() );
    CFileMan* manager = CFileMan::NewL( session );
    log.Append( KUtilsLogFile );
    manager->Delete( log );
    session.Close();
    delete manager;
    manager = NULL;
    }
#endif  //_DEBUG
      




// End of File