/*
* Copyright (c) 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:  CTCChannel class implementation.
*
*/


#include <sensrvchannel.h>
#include <sensrvchannelfinder.h>
#include <ssycallback.h>

#include "tcchannel.h"
#include "tcutil.h"
#include "common.h"
#include "trace.h"

CTCChannel::~CTCChannel()
    {
    FUNC_LOG;
    
    Cancel();
    iStatePool.ResetAndDestroy();
    }

CTCChannel::CTCChannel( MSsyCallback& aCallback ):
    CActive( EPriorityNormal ),
    iCallback( aCallback )
    {
    FUNC_LOG;
    
    // Check that we have an active scheduler in the current process
    ASSERT_ALWAYS_SSY( CActiveScheduler::Current() );
    
    CActiveScheduler::Add( this );
    }

// METHODS

// ----------------------------------------------------------------------------------
// CTCChannel::ChannelId
// ----------------------------------------------------------------------------------
//
void CTCChannel::SetChannelId( TSensrvChannelId aId )
    {
    FUNC_LOG;
    
    INFO_1( "Set channel ID: [%d]", aId );
    
    iChannelInfo.iChannelId = aId;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::ChannelId
// ----------------------------------------------------------------------------------
//
TSensrvChannelId CTCChannel::ChannelId() const
    {
    FUNC_LOG;
    
    return iChannelInfo.iChannelId;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::ChannelSupported
// ----------------------------------------------------------------------------------
//
TBool CTCChannel::ChannelSupported( const TSensrvChannelInfo& aInfo )
    {
    FUNC_LOG;
    
    return iChannelInfo.IsMatch( aInfo );
    }

// ----------------------------------------------------------------------------------
// CTCChannel::DoCancel
// ----------------------------------------------------------------------------------
//
void CTCChannel::DoCancel()
    {
    FUNC_LOG;
    
    CompleteTransaction( KErrCancel );
    }

// ----------------------------------------------------------------------------------
// CTCChannel::RunError
// ----------------------------------------------------------------------------------
//
TInt CTCChannel::RunError( TInt aError )
    {
    FUNC_LOG;
    
    if( aError != KErrNone )
        {
        INFO_1( "RunError called with code [%d]", aError );
        }
    
    return KErrNone;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::CurrentState
// ----------------------------------------------------------------------------------
//
CTCState* CTCChannel::CurrentState() const
    {
    FUNC_LOG;
    
    return iCurrentState;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::ChangeState
// ----------------------------------------------------------------------------------
//
void CTCChannel::ChangeStateL( TInt aStateId )
    {
    FUNC_LOG;
    
    ASSERT_DEBUG_TRACE( aStateId >= CTCState::ETCStateIdle &&
        aStateId < CTCState::ETCStateLast, EInvalidState );
    
    iPreviousState = iCurrentState;
    iCurrentState = iStatePool[aStateId];
    
    // Inform new current state about state entry
    iCurrentState->HandleStateEntryL();
    
    // Inform previous state about state exit
    if( iPreviousState )
        {
        iPreviousState->HandleStateExitL();
        }
    
    INFO_2( "Changing channel state [%S] -> [%S]",
        &TCUtil::StateIdAsDesC( iPreviousState ),
        &TCUtil::StateIdAsDesC( iCurrentState ) );
    }

// ----------------------------------------------------------------------------------
// CTCChannel::DataBuffer
// ----------------------------------------------------------------------------------
//
TUint8* CTCChannel::DataBuffer() const
    {
    FUNC_LOG;
    
    return iData;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::DataCount
// ----------------------------------------------------------------------------------
//
TInt CTCChannel::DataCount() const
    {
    FUNC_LOG;
    
    return iCount;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::BaseConstructL
// ----------------------------------------------------------------------------------
//
void CTCChannel::BaseConstructL()
    {
    FUNC_LOG;
    
    // Register states
    RegisterStateL( CTCState::ETCStateIdle, iStatePool );
    RegisterStateL( CTCState::ETCStateOpen, iStatePool );
    RegisterStateL( CTCState::ETCStateListenData, iStatePool );
    RegisterStateL( CTCState::ETCStateBufferFull, iStatePool );
    RegisterStateL( CTCState::ETCStateClosing, iStatePool );
    
    // Switch to idle
    ChangeStateL( CTCState::ETCStateIdle );
    }

// ----------------------------------------------------------------------------------
// CTCChannel::FindChannelL
// ----------------------------------------------------------------------------------
//
TBool CTCChannel::FindChannelL( const TSensrvChannelTypeId& aChannelTypeId,
    const TDesC8& aLocation,
    const TDesC8& aVendorId,
    TSensrvChannelInfo& aChannelInfo )
    {
    FUNC_LOG;

    TBool found = EFalse;

    // Configure channel
    CSensrvChannelFinder* channelFinder = CSensrvChannelFinder::NewLC();
    RSensrvChannelInfoList channelInfoList;
    CleanupClosePushL( channelInfoList );
    
    // Find double tap channel
    aChannelInfo.iChannelId = 0;
    aChannelInfo.iContextType = ESensrvContextTypeNotDefined;
    aChannelInfo.iQuantity = ESensrvQuantityNotdefined;
    aChannelInfo.iChannelType = aChannelTypeId;
    aChannelInfo.iLocation = aLocation;
    aChannelInfo.iVendorId = aVendorId;
    aChannelInfo.iDataItemSize = 0;
    channelFinder->FindChannelsL( channelInfoList, aChannelInfo );
    if( channelInfoList.Count() > 0 )
        {
        INFO_2( "aChannelInfo size [%d] vs. channelInfoList[0] size [%d]",
            sizeof( aChannelInfo ),
            sizeof( channelInfoList[ 0 ] ) );
        
        // Take first match and assume it to be best one
        aChannelInfo = channelInfoList[ 0 ];
        found = ETrue;
        INFO_3( "Found sensor channel with parameters: ChannelTypeId: %x, Location: %S, Vendor: %S",
             aChannelTypeId, &aLocation, &aVendorId );
        }
    else
        {
        ERROR_GEN_3( "Did not found sensor channel: ChannelTypeId: %x, Location: %S, Vendor: %S",
             aChannelTypeId,
             &aLocation,
             &aVendorId );
        }
    
    // Cleanup
    CleanupStack::PopAndDestroy( &channelInfoList );
    CleanupStack::PopAndDestroy( channelFinder );

    return found;
    }

// ----------------------------------------------------------------------------------
// CTCChannel::CompleteTransaction
// ----------------------------------------------------------------------------------
//
void CTCChannel::CompleteTransaction( TInt aCode )
    {
    FUNC_LOG;
    
    ASSERT_DEBUG_TRACE( IsActive(), ENotActive );
    
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, aCode );
    }

// End of File