/*

* 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:  A notifier that gets refresh events from the SAT server

*

*/

// INCLUDE FILES

#include "CSatRefreshNotifier.h"

#include <VPbkDebug.h>

#include "MSimRefreshObject.h"

namespace VPbkSimStoreImpl {

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

namespace {

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

// ConvertFromSatFormat() Converts from SAT server format to own format

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

//

TUint32 ConvertFromSatFormat(

    const TSatRefreshFiles& aFiles )  // List of files which has been refreshed

    {

    FUNC_ENTRY();

    TUint32 result = 0;

    // KAdnEf -> KADNRefresh

    TChar ef( KAdnEf );

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 1"));    

        result |= KADNRefresh;

        }

    // KExt1Ef -> KADNExtRefresh

    ef = KExt1Ef;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 2"));    

        result |= KADNExtRefresh;

        }

    // KFdnEf -> KFDNRefresh

    ef = KFdnEf;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 3"));    

        result |= KFDNRefresh;

        }

    // KExt2Ef -> KFDNExtRefresh

    ef = KExt2Ef;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 4"));    

        result |= KFDNExtRefresh;

        }

    // KSdnEf -> KSDNRefresh

    ef = KSdnEf;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 5"));    

        result |= KSDNRefresh;

        }

    // KExt3Ef -> KSDNExtRefresh

    ef = KExt3Ef;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 6"));    

        result |= KSDNExtRefresh;

        }

    // KSstEf -> KSTRefresh

    ef = KSstEf;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 7"));    

        result |= KSTRefresh;

        }

    // KMsisdnEf -> KONRefresh

    ef = KMsisdnEf;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 8"));    

        result |= KONRefresh;

        }

    // KExt5Ef -> KONExtRefresh

    ef = KExt5Ef;

    if ( aFiles.Locate( ef ) != KErrNotFound )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 9"));    

        result |= KONExtRefresh;

        }

    // Check all 0x4FXX files     

    const TInt count( aFiles.Length() );

    for( TInt i(0); i < count; ++i )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat 10"));    

        if ( !(0x4F ^ aFiles[i] >> 8 ) )

            {

            VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

                "VPbkSimStoreImpl: ConvertFromSatFormat 11"));    

            // USIM ADN file updated

            result |= KADNRefresh;

            result |= KADNExtRefresh;

            }

        }        

    FUNC_EXIT();

    return result;    

    }

TUint32 ConvertFromSatFormat(

    const TSatRefreshType& aType )  // List of files which has been refreshed

    {

    FUNC_ENTRY();

    TUint result(0);

    if( aType == ESimReset )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat ESimReset"));

        result |= KSimReset;

        }

    if( aType == ESimInitFullFileChangeNotification )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat ESimInitFullFileChangeNotification"));

        result |= KSimInitFullFileChangeNotification;

        }

    if( aType == EUsimApplicationReset )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat EUsimApplicationReset"));

        result |= KUsimApplicationReset;

        }

    if( aType == E3GSessionReset )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat E3GSessionReset"));

        result |= K3GSessionReset;

        }

    if( aType == ESimInit )

        {

        VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

            "VPbkSimStoreImpl: ConvertFromSatFormat ESimInit"));

        result |= KSimInit;

        }

    FUNC_EXIT();

    return result;

    }

} // unnamed namespace

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

NONSHARABLE_CLASS(CSatRefreshNotifier::CSatSession) :    public CBase

    {

    public:  // Constructors and destructor

        CSatSession( MSatRefreshObserver& aSatObserver );

        ~CSatSession();

    public: // New functions

        /**

        * Opens SAT session

        */

        void OpenL();

        /**

        * Returns ETrue if session has been opened

        */

        TBool IsOpen();

        /**

        * @return the refresh subsession

        */

        RSatRefresh& Refresh();

    private:    // Data

        /// The main session to SAT server

        RSatSession iSatSession;

        /// The subsession that implements SAT refresh notifying

        RSatRefresh iSatRefresh;

        TBool iIsOpen;

    };

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

// CSatRefreshNotifier::CSatSession::CSatSession

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

// might leave.

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

//

CSatRefreshNotifier::CSatSession::CSatSession( MSatRefreshObserver& aSatObserver )

:   iSatRefresh( aSatObserver )

    {

    }

// Destructor

CSatRefreshNotifier::CSatSession::~CSatSession()

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::CSatSession::~CSatSession,\

        Cancel refresh h%d"),

        iSatRefresh.SubSessionHandle() );

    iSatRefresh.Cancel();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::CSatSession::~CSatSession,\

        Close refresh h%d"), 

        iSatRefresh.SubSessionHandle() );

    iSatRefresh.Close();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::CSatSession::~CSatSession,\

        Close session h%d"), 

        iSatSession.Handle() );

    iSatSession.Close();

    }

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

// CSatRefreshNotifier::CSatSession::OpenL

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

//

void CSatRefreshNotifier::CSatSession::OpenL()

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::CSatSession::OpenL"));

    iSatSession.ConnectL();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::CSatSession::OpenL, Session Connected h%d"), 

        iSatSession.Handle() );

    iSatRefresh.OpenL( iSatSession );

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::CSatSession::OpenL, Refresh Opened h%d"), 

        iSatRefresh.SubSessionHandle() );

    iIsOpen = ETrue;

    }

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

// CSatRefreshNotifier::CSatSession::IsOpen

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

//

TBool CSatRefreshNotifier::CSatSession::IsOpen()

    {

    return iIsOpen;

    }

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

// CSatRefreshNotifier::CSatSession::Refresh

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

//

RSatRefresh& CSatRefreshNotifier::CSatSession::Refresh()

    {

    return iSatRefresh;

    }

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

// CSatRefreshNotifier::CSatRefreshNotifier

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

// might leave.

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

//

CSatRefreshNotifier::CSatRefreshNotifier()

    {

    }

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

// CSatRefreshNotifier::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSatRefreshNotifier::ConstructL()

    {

    iSatSession = new( ELeave ) CSatSession( *this );

    }

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

// CSatRefreshNotifier::NewL

// Two-phased constructor.

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

//

CSatRefreshNotifier* CSatRefreshNotifier::NewL()

    {

    CSatRefreshNotifier* self = new( ELeave ) CSatRefreshNotifier;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSatRefreshNotifier::~CSatRefreshNotifier

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

//

CSatRefreshNotifier::~CSatRefreshNotifier()

    {

    delete iSatSession;

    iObjects.Close();

    }

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

// CSatRefreshNotifier::IsActive

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

//

TBool CSatRefreshNotifier::IsActive()

    {

    return iSatSession->IsOpen();

    }

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

// CSatRefreshNotifier::ActivateL

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

//

void CSatRefreshNotifier::ActivateL( MSimRefreshObject& aSimRefreshObject )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::ActivateL"));

    // Open the session to SAT server if not opened

    if ( !iSatSession->IsOpen() )

        {

        iSatSession->OpenL();

        }

    // Listen to all changes

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::ActivateL: NotifyFileChangeL ALL"));

    iSatSession->Refresh().NotifyFileChangeL();

    if ( iObjects.Find( &aSimRefreshObject ) == KErrNotFound )

        {

        iObjects.AppendL( &aSimRefreshObject );

        }

    }

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

// CSatRefreshNotifier::DeActivate

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

//

void CSatRefreshNotifier::DeActivate( MSimRefreshObject& aSimRefreshObject )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::DeActivate"));

    TInt index = iObjects.Find( &aSimRefreshObject );

    if ( index != KErrNotFound )

        {

        iObjects.Remove( index );

        }

    // Cancel the request if session is open and this was the last object

    if ( iSatSession->IsOpen() && iObjects.Count() == 0 )

        {

        iSatSession->Refresh().Cancel();        

        }

    }

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

// CSatRefreshNotifier::AllowRefresh

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

//

TBool CSatRefreshNotifier::AllowRefresh( TSatRefreshType aType, 

    const TSatRefreshFiles& aFiles )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::AllowRefresh:type=%d, aFiles=%S"), 

        aType,&aFiles);

    // First check files...

    TUint32 flags = ConvertFromSatFormat( aFiles );

    // ...and then refresh types

    flags |= ConvertFromSatFormat( aType );

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::AllowRefresh:Converted flags=%x"), 

        flags);

    TBool result = ETrue;

    const TInt count = iObjects.Count();

    for( TInt i = count - 1; i >= 0 && result; --i )

        {

        if ( !iObjects[i]->AllowRefresh( flags ) )

            {

            result = EFalse;

            }

        }

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::AllowRefresh:return %d"), 

            result);

    // The refresh doesn't necessary start

    // because other clients or TSY can deny the refresh.

    return result;

    }

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

// CSatRefreshNotifier::Refresh

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

//

void CSatRefreshNotifier::Refresh( TSatRefreshType aType,

    const TSatRefreshFiles& aFiles )

    {

    FUNC_ENTRY();

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::Refresh:type=%d, aFiles=%S"), 

        aType,&aFiles);

    // Refresh has happened. Clients must update their content

    iRefreshedObjects = 0;

    iAdditionalEFsRead = EFalse;

    // First check files... 

    TUint32 flags = ConvertFromSatFormat( aFiles );

    // ...and then refresh types

    flags |= ConvertFromSatFormat( aType );

    const TInt count = iObjects.Count();

    for( TInt i = count - 1; i >= 0; --i )

        {

        iObjects[i]->SimRefreshed( flags, *this );

        }

    FUNC_EXIT();

    }

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

// CSatRefreshNotifier::SatRefreshCompleted

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

//

void CSatRefreshNotifier::SatRefreshCompleted( 

        MSimRefreshObject& /*aSimRefreshObject*/,

        TBool aReadAdditionalFiles )

    {

    VPBK_DEBUG_PRINT(VPBK_DEBUG_STRING(

        "VPbkSimStoreImpl:CSatRefreshNotifier::SatRefreshCompleted:total=%d,cur=%d"), 

        iObjects.Count(), iRefreshedObjects + 1);

    ++iRefreshedObjects;

    if ( aReadAdditionalFiles )

        {

        iAdditionalEFsRead = ETrue;

        }

    // Complete refresh to SAT server when all the objects have completed

    if ( iRefreshedObjects == iObjects.Count() )

        {

        iSatSession->Refresh().RefreshEFRead( iAdditionalEFsRead );

        }

    }

} // namespace VPbkSimStoreImpl

//  End of File