/*
* 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:  Network operations for chat access handling.
 *
*/


// INCLUDE FILES
#include "ChatDebugPrint.h"

#include "CCAAccessManager.h"
#include "MCAImpsAccessClient.h"
#include "CCAAdapterDll.h"
#include "MCAImpsFactory.h"
#include "CCARequest.h"
#include "CCARequestMapper.h"


// ================= MEMBER FUNCTIONS =======================
// Symbian OS default constructor can leave.
void CCAAccessManager::ConstructL()
    {
    CHAT_DP_TXT( "CCAAccessManager::ConstructL, CreateAccessClientL" );
    iImpsAccessClient = CreateImpsFactoryL()->CreateAccessClientL();

    iImpsAccessClient->RegisterL( this, CActive::EPriorityIdle );
    iImpsAccessClient->RegisterErrorObserverL( *this );
    }

// Two-phased constructor.
CCAAccessManager* CCAAccessManager::NewL( CCARequestMapper& aRequestMapper )
    {
    CCAAccessManager* self = new ( ELeave ) CCAAccessManager( aRequestMapper );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// Destructor
CCAAccessManager::~CCAAccessManager()
    {
    if ( iImpsAccessClient )
        {
        iImpsAccessClient->Unregister();
        }
    }

// C++ default constructor can NOT contain any code, that
// might leave.
//
CCAAccessManager::CCAAccessManager( CCARequestMapper& aRequestMapper )
        : iRequestMapper( aRequestMapper )
    {
    }

void CCAAccessManager::LoginL(   TImpsCspIdentifier& aCspId,
                                 const TDesC& aPsw,
                                 const TDesC& aClientId,
                                 TUint32 aAP,
                                 const TDesC* aKey1/* = NULL*/,
                                 const TDesC* aKey2/* = NULL*/ )
    {
    CHAT_DP_FUNC_ENTER( "CCAAccessManager::LoginL" );
    TInt opId = iImpsAccessClient->LoginL( aCspId, aPsw, aClientId,
                                           aAP, aKey1, aKey2 );
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::LoginL - opid=%d" ), opId );
    TInt error = ExecuteRequestL( opId, ELoginRequest );
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::LoginL - opid=%d, status=%d" ),
             opId, error );
    CHAT_DP_FUNC_DONE( "CCAAccessManager::LoginL" );
    }

void CCAAccessManager::LogoutL()
    {
    CHAT_DP_FUNC_ENTER( "CCAAccessManager::LogoutL" );
    TInt opId = iImpsAccessClient->LogoutL();
    TInt error = ExecuteRequestL( opId, ELogoutRequest );
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::LogoutL - opid=%d, status=%d" ),
             opId, error );
    CHAT_DP_FUNC_DONE( "CCAAccessManager::LogoutL" );
    }

// --------------------------------------------------------
// CCAGroupManager::HandleErrorL
// ---------------------------------------------------------
//
void CCAAccessManager::HandleErrorL(
    TInt aStatus,
    TInt aOpId,
    const TDesC* /* aDescription */,
    const CImpsDetailed* /* aDetailedRes */,
    TImpsCspIdentifier& /*aCspId*/ )
    {
    CHAT_DP_FUNC_ENTER( "HandleErrorL" );
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::HandleErrorL - opid=%d, status=%d" ),
             aOpId, aStatus );
    iRequestMapper.HandleRequest( aOpId, aStatus );
    CHAT_DP_FUNC_DONE( "HandleErrorL" );
    }

void CCAAccessManager::HandleLoginL( TInt aId,
                                     TImpsCspIdentifier& /* aCspId */ )
    {
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::HandleLoginL - opid=%d" ), aId );
    iRequestMapper.HandleRequest( aId, KErrNone );
    }

void CCAAccessManager::HandleLogoutL( TInt aId,
                                      TImpsCspIdentifier& /* aCspId */ )
    {
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::HandleLogoutL - opid=%d" ), aId );
    iRequestMapper.HandleRequest( aId, KErrNone );
    }

void CCAAccessManager::HandleLoginCancelL( TInt aCancelledOpId,
                                           TImpsCspIdentifier& /* aCspId */ )
    {
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::HandleLoginCancelL - opid=%d" ),
             aCancelledOpId );
    iRequestMapper.HandleRequest( aCancelledOpId, KErrCancel );
    }

void CCAAccessManager::HandleNbrSessionsL( TInt aId,
                                           TInt /* aNbr */,
                                           TImpsCspIdentifier& /* aCspId */ )
    {
    CHAT_DP( D_CHAT_LIT( "CCAAccessManager::HandleNbrSessionsL - opid=%d" ),
             aId );
    iRequestMapper.HandleRequest( aId, KErrNone );
    }

// ---------------------------------------------------------
// CCAGroupWrapper::ExecuteRequest
// ---------------------------------------------------------
//
TInt CCAAccessManager::ExecuteRequestL( TInt aOperationId,
                                        TOperationRequests aRequestType,
                                        MDesCArray* aAdditionalData )
    {
    // creating request
    CCARequest* request = iRequestMapper.CreateRequestL( aOperationId, EFalse );
    CCARequestMapper& requestMapper = iRequestMapper;

    // setting type
    request->SetRequestType( aRequestType );

    // setting additional data if exists
    if ( aAdditionalData )
        {
        request->SetAdditionalData( *aAdditionalData );
        }

    // Now when the request type and additional data is set we can
    // activate the synchronous wait
    if ( aRequestType != ELogoutRequest )
        {
        request->StartWait();
        }

    TInt retVal( request->ErrorCode() );
    requestMapper.RemoveRequest( request );

    return retVal;
    }

//  End of File