/*
* Copyright (c) 2006-2009 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:  USB Watcher session class implementation.
*
*/


#include "cusbwatchersession.h"
#include "usbwatchershared.h"
#include "cusbwatcher.h"
#include "cusbwatcherserver.h"
#include "debug.h"

// ----------------------------------------------------------------------------
// Symbian two-phase constructor
// ----------------------------------------------------------------------------
//
CUsbWatcherSession* CUsbWatcherSession::NewL( CUsbWatcherServer* aServer )
    {
    LOG_FUNC

    CUsbWatcherSession* r = new ( ELeave ) CUsbWatcherSession( aServer );
    CleanupStack::PushL( r );
    r->ConstructL();
    CleanupStack::Pop();
    return r;
    }

// ----------------------------------------------------------------------------
// C++ constructor
// ----------------------------------------------------------------------------
//
CUsbWatcherSession::CUsbWatcherSession( CUsbWatcherServer* aServer )
    : iUsbWatcherServer( aServer )
    {
    LOG_FUNC

    }

// ----------------------------------------------------------------------------
// Second-phase constructor
// ----------------------------------------------------------------------------
//
void CUsbWatcherSession::ConstructL()
    {
    LOG_FUNC

    iUsbWatcherServer->Watcher().RegisterObserverL( this );
    }

// ----------------------------------------------------------------------------
// Desstructor
// ----------------------------------------------------------------------------
//
CUsbWatcherSession::~CUsbWatcherSession()
    {
    LOG_FUNC

    // if server isn't exist then session can not be exist
    if ( iUsbWatcherServer )
        {
        iUsbWatcherServer->Watcher().DeRegisterObserver( this );
        }
    }

// ----------------------------------------------------------------------------
// Request handle entry point
// ----------------------------------------------------------------------------
//
void CUsbWatcherSession::ServiceL( const RMessage2& aMessage )
    {
    LOG_FUNC

    DispatchMessageL( aMessage );
    }

// ----------------------------------------------------------------------------
// Request dispatch function
// ----------------------------------------------------------------------------
//
void CUsbWatcherSession::DispatchMessageL( const RMessage2& aMessage )
    {
    LOG_FUNC

    LOG1( "Message = %d", aMessage.Function() );

    TBool complete( ETrue );
    TInt ret( KErrNone );


    switch ( aMessage.Function() )
        {
        case EUsbWatcherSetPersonality:
            ret = SetPersonality( aMessage, complete );
            break;

        case EUsbWatcherCancelSetPersonality:
            ret = CancelSetPersonality( aMessage, complete );
            break;

        case EUsbWatcherSetPreviousPersonality:
            ret = SetPreviousPersonality( aMessage, complete );
            break;

        case EUsbWatcherSetPreviousPersonalitySync:
            ret = SetPreviousPersonalitySync( aMessage, complete );
            break;

        case EUsbWatcherCancelSetPreviousPersonality:
            ret = CancelSetPreviousPersonality( aMessage, complete );
            break;

        case EUsbWatcherSetPreviousPersonalityOnDisconnect:
            ret = SetPreviousPersonalityOnDisconnect( aMessage, complete );
            break;

        default:
            aMessage.Panic( KUsbWatcherCliPncCat, EUsbWatcherPanicIllegalIPC );
            break;
        }

    if ( complete )
        {
        aMessage.Complete( ret );
        }
    }

// ----------------------------------------------------------------------------
// Set certain personality
// ----------------------------------------------------------------------------
//
TInt CUsbWatcherSession::SetPersonality( const RMessage2& aMessage,
        TBool& aComplete )
    {
    LOG_FUNC

    if( iSetPersonalityOutstanding )
        {
        LOG( "Completing outstanding" );
        iSetPersonalityMessage.Complete( KErrNone );
        iSetPersonalityOutstanding = EFalse;
        }

    // Cancel all other pending requests
    iUsbWatcherServer->Watcher().Notify( KErrCancel );

    iSetPersonalityMessage = aMessage;
    aComplete = EFalse;
    iSetPersonalityOutstanding = ETrue;

    //Set force parameter to this session.
    SetAskOnConnectionSuppression( aMessage.Int1() );

    iUsbWatcherServer->Watcher().SetPersonality( aMessage.Int0(),
        static_cast<TBool>( aMessage.Int2() ) );

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Cancel pending set personality request
// ----------------------------------------------------------------------------
//
TInt CUsbWatcherSession::CancelSetPersonality( const RMessage2& aMessage,
        TBool& aComplete )
    {
    LOG_FUNC

    if ( !iSetPersonalityOutstanding )
        {
        LOG( "No outstanding SetPersonality request" );
        return KErrNone;
        }

    SetAskOnConnectionSuppression( EFalse );
    aComplete = EFalse;
    iCancelSetPersonalityMessage = aMessage;
    iCancelSetPersonalityOutstanding = ETrue;

    iUsbWatcherServer->Watcher().CancelSetPersonality();

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Change to previous personality, asynchronous version
// ----------------------------------------------------------------------------
//
TInt CUsbWatcherSession::SetPreviousPersonality( const RMessage2& aMessage,
        TBool& aComplete )
    {
    LOG_FUNC

    if( iSetPreviousPersonalityOutstanding )
        {
        iSetPreviousPersonalityMessage.Complete( KErrNone );
        iSetPreviousPersonalityOutstanding = EFalse;
        }

    // Cancel all other pending requests
    iUsbWatcherServer->Watcher().Notify( KErrCancel );

    SetAskOnConnectionSuppression( EFalse );
    iSetPreviousPersonalityOutstanding = ETrue;
    iSetPreviousPersonalityMessage = aMessage;
    aComplete = EFalse;

    iUsbWatcherServer->Watcher().SetPreviousPersonality();

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Change to previous personality, synchronous version
// ----------------------------------------------------------------------------
//
TInt CUsbWatcherSession::SetPreviousPersonalitySync( const RMessage2& /*aMsg*/,
        TBool& /*aComplete*/ )
    {
    LOG_FUNC

    if( iSetPreviousPersonalityOutstanding )
        {
        iSetPreviousPersonalityMessage.Complete( KErrNone );
        iSetPreviousPersonalityOutstanding = EFalse;
        }

    // Cancel all other pending requests
    iUsbWatcherServer->Watcher().Notify( KErrCancel );

    SetAskOnConnectionSuppression( EFalse );
    iUsbWatcherServer->Watcher().SetPreviousPersonality();

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Cancel pending request to set previous personality
// ----------------------------------------------------------------------------
//
TInt CUsbWatcherSession::CancelSetPreviousPersonality( const RMessage2& aMsg,
        TBool& aComplete )
    {
    LOG_FUNC

    if( !iSetPreviousPersonalityOutstanding )
        {
        return KErrNone;
        }

    aComplete = EFalse;
    iCancelSetPreviousPersonalityMessage = aMsg;
    iCancelSetPreviousPersonalityOutstanding = ETrue;

    iUsbWatcherServer->Watcher().CancelSetPreviousPersonality();

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Set the flag to restore personality when disconnected
// ----------------------------------------------------------------------------
//
TInt CUsbWatcherSession::SetPreviousPersonalityOnDisconnect( const RMessage2&
        /*aMessage*/, TBool& /*aComplete*/ )
    {
    LOG_FUNC

    //connected currently, so ask on connection can be enabled
    SetAskOnConnectionSuppression( EFalse );
    iUsbWatcherServer->Watcher().SetPreviousPersonalityOnDisconnect();

    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Complete request
// ----------------------------------------------------------------------------
//
void CUsbWatcherSession::Notify( TInt /*aPersonalityId*/, TInt aStatus )
    {
    LOG_FUNC

    if( iCancelSetPersonalityOutstanding )
        {
        iCancelSetPersonalityOutstanding = EFalse;
        iCancelSetPersonalityMessage.Complete( KErrNone );

        iSetPersonalityMessage.Complete( aStatus );
        iSetPersonalityOutstanding = EFalse;
        }

    if ( iSetPersonalityOutstanding )
        {
        iSetPersonalityMessage.Complete( aStatus );
        iSetPersonalityOutstanding = EFalse;
        }

    if ( iCancelSetPreviousPersonalityOutstanding )
        {
        iCancelSetPreviousPersonalityOutstanding = EFalse;
        iCancelSetPreviousPersonalityMessage.Complete( KErrNone );

        iSetPreviousPersonalityMessage.Complete( aStatus );
        iSetPreviousPersonalityOutstanding = EFalse;
        }

    if ( iSetPreviousPersonalityOutstanding )
        {
        iSetPreviousPersonalityMessage.Complete( aStatus );
        iSetPreviousPersonalityOutstanding = EFalse;
        }
    }

// ----------------------------------------------------------------------------
// Set or clear AskOnConnection suppression
// ----------------------------------------------------------------------------
//
void CUsbWatcherSession::SetAskOnConnectionSuppression( TBool aSuppress )
    {
    LOG_FUNC

    iSuppressAskOnConnection = aSuppress;
    }

// ----------------------------------------------------------------------------
// Check if AskOnConnection is suppressed
// ----------------------------------------------------------------------------
//
TBool CUsbWatcherSession::IsAskOnConnectionSuppressed()
    {
    LOG_FUNC

    return iSuppressAskOnConnection;
    }

// End of file