/*

* Copyright (c) 2004 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:  Access handler of the network session

*

*/

// INCLUDE FILES

#include    "CPEngAccessHandler.h"

#include    <CIMPSSAPSettings.h>

#include    <ImpsServices.h>

#include    "PEngLoginDataCodec.h"

#include    "MPEngSessionStatusObserver.h"

#include    "MPEngSessionManager.h"

#include    "PEngTransAdapterPanics.h"

#include    "PEngWVPresenceErrors2.h"

#include    "PresenceDebugPrint.h"

//DATA TYPES

/**

 * Function map structure.

 */

struct SCspFunctionMap

    {

    TInt           iPeFunc;

    TImpsFunctions iImpsEngFunc;

#ifdef PENG_ENABLE_DEBUG_PRINT

    const TText*   iPeFuncName;

#endif

    };

/**

 * Sub-Function map structure.

 */

struct SCspSubFunctionMap

    {

    TInt           iPeSubFunc;

    TInt           iImpsEngSubFunc;

#ifdef PENG_ENABLE_DEBUG_PRINT

    const TText*   iPeSubFuncName;

#endif

    };

//CONTANTS

const TInt KPEngNullFunction = 0;

//MACROS

#ifdef PENG_ENABLE_DEBUG_PRINT

#define MAPPING( a1, a2 ) { a1, a2, _S( #a1 ) }

#define MAPPING_TERMINATION { KPEngNullFunction }

#else

#define MAPPING( a1, a2 ) { a1, a2 }

#define MAPPING_TERMINATION { KPEngNullFunction }

#endif

/**

 * Fundamental functions & sub-functions.

 */

const SCspFunctionMap KFuncMapFundamental[] =

    {

    MAPPING( KPEngFFServiceFunction, EServiceFunc ),

    MAPPING( KPEngFFSearchFunction,  ESearchFunc  ),

    MAPPING( KPEngFFInviteFunction,  EInviteFunc  ),

    MAPPING_TERMINATION

    };

const SCspSubFunctionMap KSubFuncMapFundamental[] =

    {

    MAPPING( KPEngFFSubFuncGETSPI,   KImpsServiceGETSPI ),

    MAPPING( KPEngFFSubFuncSRCH,     KImpsServiceSRCH   ),

    MAPPING( KPEngFFSubFuncSTSRC,    KImpsServiceSTSRC  ),

    MAPPING( KPEngFFSubFuncINVIT,    KImpsServiceINVIT  ),

    MAPPING( KPEngFFSubFuncCAINV,    KImpsServiceCAINV  ),

    MAPPING_TERMINATION

    };

/**

 * Presence functions & sub-functions.

 */

const SCspFunctionMap KFuncMapPresence[] =

    {

    MAPPING( KPEngWVContListFunction,  EContListFunc        ),

    MAPPING( KPEngWVPresAuthFunction,  EPresenceAuthFunc    ),

    MAPPING( KPEngWVPresDelivFunction, EPresenceDeliverFunc ),

    MAPPING( KPEngWVAttrListFunction,  EAttrListFunc        ),

    MAPPING_TERMINATION

    };

const SCspSubFunctionMap KSubFuncMapPresence[] =

    {

    MAPPING( KPEngWVSubFuncGCLI,   KImpsServiceGCLI  ),

    MAPPING( KPEngWVSubFuncCCLI,   KImpsServiceCCLI  ),

    MAPPING( KPEngWVSubFuncDCLI,   KImpsServiceDCLI  ),

    MAPPING( KPEngWVSubFuncMCLS,   KImpsServiceMCLS  ),

    MAPPING( KPEngWVSubFuncGETWL,  KImpsServiceGETWL ),

    MAPPING( KPEngWVSubFuncREACT,  KImpsServiceREACT ),

    MAPPING( KPEngWVSubFuncCAAUT,  KImpsServiceCAAUT ),

    //{ KPEngWVSubFuncGETAUT, Not yet in WV Engine },

    MAPPING( KPEngWVSubFuncGETPR,  KImpsServiceGETPR ),

    MAPPING( KPEngWVSubFuncUPDPR,  KImpsServiceUPDPR ),

    MAPPING( KPEngWVSubFuncCALI,   KImpsServiceCALI  ),

    MAPPING( KPEngWVSubFuncDALI,   KImpsServiceDALI  ),

    MAPPING( KPEngWVSubFuncGALS,   KImpsServiceGALS  ),

    MAPPING_TERMINATION

    };

/**

 * IM Functions & sub-functions.

 */

const SCspFunctionMap KFuncMapIm[] =

    {

    MAPPING( KPEngIMSendFunctions,     EIMSendFunc    ),

    MAPPING( KPEngIMReceiveFunctions,  EIMReceiveFunc ),

    MAPPING( KPEngIMAuthorFunctions,   EIMAuthFunc    ),

    MAPPING_TERMINATION

    };

const SCspSubFunctionMap KSubFuncMapIm[] =

    {

    // Send Functions

    MAPPING( KPEngIMSubFuncMDELIV, KImpsServiceMDELIV ),

    MAPPING( KPEngIMSubFuncFWMSG,  KImpsServiceFWMSG  ),

    // Receive functions

    MAPPING( KPEngIMSubFuncSETD,   KImpsServiceSETD   ),

    MAPPING( KPEngIMSubFuncGETLM,  KImpsServiceGETLM  ),

    MAPPING( KPEngIMSubFuncGETM,   KImpsServiceGETM   ),

    MAPPING( KPEngIMSubFuncREJCM,  KImpsServiceREJCM  ),

    MAPPING( KPEngIMSubFuncNOTIF,  KImpsServiceNOTIF  ),

    MAPPING( KPEngIMSubFuncNEWM,   KImpsServiceNEWM   ),

    // Authorize functions

    MAPPING( KPEngIMSubFuncGLBLU,  KImpsServiceGLBLU  ),

    MAPPING( KPEngIMSubFuncBLENT,  KImpsServiceBLENT  ),

    MAPPING_TERMINATION

    };

/**

 * Group Functions & sub-functions.

 */

/**

* IM Functions & sub-functions.

*/

const SCspFunctionMap KFuncMapGroup[] =

    {

    MAPPING( KPEngGRManageFunctions, EGroupMgmtFunc ),

    MAPPING( KPEngGRUseFunctions,    EGroupUseFunc  ),

    MAPPING( KPEngGRAuthorFunctions, EGroupAuthFunc ),

    MAPPING_TERMINATION

    };

const SCspSubFunctionMap KSubFuncMapGroup[] =

    {

    // Manager functions

    MAPPING( KPEngGRSubFuncCREAG,  KImpsServiceCREAG  ),

    MAPPING( KPEngGRSubFuncDELGR,  KImpsServiceDELGR  ),

    MAPPING( KPEngGRSubFuncGETGP,  KImpsServiceGETGP  ),

    MAPPING( KPEngGRSubFuncSETGP,  KImpsServiceSETGP  ),

    // Use functions

    MAPPING( KPEngGRSubFuncSUBGCN, KImpsServiceSUBGCN ),

    MAPPING( KPEngGRSubFuncGRCHN,  KImpsServiceGRCHN  ),

    // Authorization functions

    MAPPING( KPEngGRSubFuncGETGM,  KImpsServiceGETGM  ),

    MAPPING( KPEngGRSubFuncADDGM,  KImpsServiceADDGM  ),

    MAPPING( KPEngGRSubFuncRMVGM,  KImpsServiceRMVGM  ),

    MAPPING( KPEngGRSubFuncMBRAC,  KImpsServiceMBRAC  ),

    MAPPING( KPEngGRSubFuncREJEC,  KImpsServiceREJEC  ),

    MAPPING_TERMINATION

    };

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

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

// DebugDumpFeatureSubtree()

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

//

#ifdef PENG_ENABLE_DEBUG_PRINT

void DebugDumpFeatureSubtree( const TDesC& aFeatureName,

                              TPEngWVCspFeature2& aPEFeature,

                              const SCspFunctionMap aFunctionMap[],

                              const SCspSubFunctionMap aSubFunctionMap[] )

    {

    //Whole feature

    PENG_DP( D_PENG_LIT( "%S, support status: %d" ),

             &aFeatureName,  aPEFeature.FeatureSupported() );

    //Functions

    PENG_DP( D_PENG_LIT( "%S, supported functions:" ), &aFeatureName );

    for ( TInt i( 0 ); aFunctionMap[ i ].iPeFunc != KPEngNullFunction; ++i )

        {

        const SCspFunctionMap functionMap = aFunctionMap[ i ];

        if ( aPEFeature.FunctionSupported( functionMap.iPeFunc ) )

            {

            TPtrC peFuncName( functionMap.iPeFuncName );

            PENG_DP( D_PENG_LIT( "   %S" ), &peFuncName );

            }

        }

    //Sub-functions

    PENG_DP( D_PENG_LIT( "%S, supported sub-functions:" ), &aFeatureName );

    for ( TInt ii( 0 ); aSubFunctionMap[ ii ].iPeSubFunc != KPEngNullFunction; ++ii )

        {

        const SCspSubFunctionMap subFuncMap = aSubFunctionMap[ ii ];

        if ( aPEFeature.SubFunctionSupported( subFuncMap.iPeSubFunc ) )

            {

            TPtrC peSubFuncName( subFuncMap.iPeSubFuncName );

            PENG_DP( D_PENG_LIT( "   %S" ), &peSubFuncName );

            }

        }

    }

#endif

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

// CopyFeatureSubtree()

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

//

void CopyFeatureSubtree( TPEngWVCspFeature2& aPEFeature,

                         TImpsFeature& aWVFeature,

                         const SCspFunctionMap aFunctionMap[],

                         const SCspSubFunctionMap aSubFunctionMap[] )

    {

    // Is feature supported at all

    aPEFeature.iSupported = aWVFeature.IsSupported();

    TInt holder;

    //Functions

    holder = KPEngNullFunction;

    for ( TInt i( 0 ); aFunctionMap[ i ].iPeFunc != KPEngNullFunction; ++i )

        {

        const SCspFunctionMap functionMap = aFunctionMap[ i ];

        if ( aWVFeature.Function( functionMap.iImpsEngFunc ) )

            {

            holder |=  functionMap.iPeFunc;

            }

        }

    aPEFeature.iFunctions = holder;

    //Sub-functions

    holder = KPEngNullFunction;

    for ( TInt ii( 0 ); aSubFunctionMap[ ii ].iPeSubFunc != KPEngNullFunction; ++ii )

        {

        const SCspSubFunctionMap subFunctionMap = aSubFunctionMap[ ii ];

        if ( aWVFeature.Capability( subFunctionMap.iImpsEngSubFunc ) )

            {

            holder = holder + subFunctionMap.iPeSubFunc;

            }

        }

    aPEFeature.iSubFunctions = holder;

    }

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

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

// CPEngAccessHandler::CPEngAccessHandler

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

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

//

CPEngAccessHandler::CPEngAccessHandler(

    MPEngSessionManager& aSessManager,

    const CPEngSessionSlotId& aSessionId )

        : iCount( 1 ), // init count to 1

        iSessionManager( aSessManager ),

        iSessionId( aSessionId ),

        iSessStatus( EPEngNWPresenceSessionClosed ),

        iOperation( EIdle )

    {

    PENG_DP( D_PENG_LIT( "CPEngAccessHandler::CPEngAccessHandler" ) );

    iSessionManager.OpenRef();

    }

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

// CPEngAccessHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPEngAccessHandler::ConstructL(

    RImpsEng& aSessClient )

    {

    iAccessClient.RegisterL( aSessClient, this );

    iAccessClient.RegisterErrorObserverL( *this );

    iAccessClient.RegisterStatusObserverL( this );

    }

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

// CPEngAccessHandler::NewLC()

// Two-phased constructor.

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

//

CPEngAccessHandler* CPEngAccessHandler::NewL(

    RImpsEng& aSessClient,

    MPEngSessionManager& aSessManager,

    const CPEngSessionSlotId& aSessionId )

    {

    CPEngAccessHandler* self = new ( ELeave ) CPEngAccessHandler(

        aSessManager,

        aSessionId );

    CleanupClosePushL( *self );

    self->ConstructL( aSessClient );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CPEngAccessHandler::~CPEngAccessHandler()

    {

    PENG_DP( D_PENG_LIT( "CPEngAccessHandler::~CPEngAccessHandler" ) );

    __ASSERT_DEBUG( ( iObservers.Count() == 0 ), User::Panic(

                        KPEngTransferAdapterPanic, EOpIdConsistencyLost ) );

    delete iLogInData;

    iAccessClient.Unregister();

    iSessionManager.CloseAccessHandler();

    iObservers.Reset();

    }

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

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

// =============================================================================

// =============== New Functions of the MPEngAccessHandler =====================

// =============================================================================

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

// CPEngAccessHandler::Close()

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

//

void CPEngAccessHandler::Close()

    {

    iCount--;

    if ( iCount == 0 )

        {

        delete this;

        }

    }

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

// CPEngAccessHandler::Open()

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

//

void CPEngAccessHandler::Open()

    {

    iCount++;

    }

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

// CPEngAccessHandler::LogInL(

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

//

void CPEngAccessHandler::LogInL(

    TRequestStatus& aStatus,

    HBufC8* aLoginBuffer )

    {

    PENG_DP( D_PENG_LIT( "CPEngAccessHandler::LogInL" ) );

    if ( iOperation != EIdle )

        {

        // client is busy, leave

        delete aLoginBuffer;

        User::Leave( KErrNotReady );

        }

    // Are we logged?

    if ( iSessStatus == EPEngNWPresenceSessionOpen )

        {

        // we are already logged, this should not happened

        delete aLoginBuffer;

        User::Leave( KErrAlreadyExists );

        }

    delete iLogInData;

    iLogInData = aLoginBuffer;

    PENG_DP( D_PENG_LIT( "CPEngAccessHandler::LogInL() - doing reactive login" ) );

    CIMPSSAPSettings* sapSetting = CIMPSSAPSettings::NewLC();

    PEngLoginDataCodec::UnPackLoginDataL( *iLogInData, *sapSetting );

    TImpsCspIdentifier sessIndentifier;

    sessIndentifier.SetUserIdL( sapSetting->SAPUserId() );

    sessIndentifier.SetSapL( sapSetting->SAPAddress() );

    // panic if we get other session log in data, user's gone wacko

    CheckConsistency( iSessionId, sessIndentifier );

    iOpId = iAccessClient.ReactiveLoginL(

                sessIndentifier,                    // Identifier

                sapSetting->SAPUserPassword(),      // User Password

                sapSetting->ClientId(),             // Client Id

                sapSetting->AccessPoint(),          // Access Point

                &( sapSetting->ServerAuthenticationName() ),    // Operator key 1

                &( sapSetting->ServerAuthenticationPassword() ) ); // Operator key 2

    CleanupStack::PopAndDestroy( sapSetting );

    // log in issued, set operation to the Log In

    aStatus = KRequestPending;

    iStatus = &aStatus;

    iOperation = EDoingLogIn;

    }

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

// CPEngAccessHandler::LogOutL()

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

//

void CPEngAccessHandler::LogOutL( TRequestStatus& aStatus )

    {

    PENG_DP( D_PENG_LIT( "CPEngAccessHandler::LogOutL" ) );

    if ( iOperation != EIdle )

        {

        // client is busy, leave

        User::Leave( KErrNotReady );

        }

    // Are we even logged

    if ( iSessStatus != EPEngNWPresenceSessionOpen )

        {

        // we are already logged out

        return;

        }

    iOpId = iAccessClient.LogoutL();

    aStatus = KRequestPending;

    iStatus = &aStatus;

    iOperation = EDoingLogOut;

    }

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

// CPEngAccessHandler::LogInData( )

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

//

const TDesC8& CPEngAccessHandler::LogInData( ) const

    {

    return *iLogInData;

    }

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

// CPEngAccessHandler::CancelL()

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

//

void CPEngAccessHandler::Cancel()

    {

    PENG_DP( D_PENG_LIT( "CPEngAccessHandler::Cancel, Status:%d operation:%d" ),

             iSessStatus,

             iOperation  );

    if ( iStatus )

        {

        switch ( iOperation )

            {

            case EDoingLogIn:

                {

                // cancel login

                TRAP_IGNORE( iAccessClient.CancelLoginL( iOpId ) );

                User::RequestComplete( iStatus, KErrCancel );

                iStatus = NULL;

                iOperation = ECanceling;

                break;

                }

            case EDoingLogOut:

                {

                // cancel logout

                // no cancel, complete and let it delete

                User::RequestComplete( iStatus, KErrCancel );

                iStatus = NULL;

                iOperation = ECanceling;

                break;

                }

            default:

                {

                // this should not happen, active, status, and idle operation

                // completed status

                User::RequestComplete( iStatus, KErrCancel );

                iStatus = NULL;

                }

            }

        }

    }

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

// CPEngAccessHandler::RegisterSessionObserver(

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

//

void CPEngAccessHandler::RegisterSessionObserverL( MPEngSessionStatusObserver& aObserver )

    {

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

        {

        User::Leave( KErrAlreadyExists );

        }

    iObservers.AppendL( &aObserver );

    }

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

// CPEngAccessHandler::UnregisterSessionObserver(

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

//

void CPEngAccessHandler::UnregisterSessionObserver( MPEngSessionStatusObserver& aObserver )

    {