/*
* Copyright (c) 2002-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:  Used as an reference implementation.
*
*/


// INCLUDE FILES
#include <remcon/remconconverterplugin.h>
#include <remcon/bearerparams.h>
#include <remconaddress.h>
#include <RemConKeyEventData.h>
#include <remconcoreapi.h>
#include "WiredAccessoryKeyEventHandler.h"
#include "AdaptationMessage.h"

#include "AdaptationMessageDefinitions.h"
#include "acc_debug.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::CWiredAccessoryKeyEventHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CWiredAccessoryKeyEventHandler::CWiredAccessoryKeyEventHandler( TBearerParams& aBearerParams )
    : CRemConBearerPlugin( aBearerParams )    
    , iState( EAccKeyEventHandlerStateUnknown )
    , iOperationId( 0 )
    , iTransactionId( 0 )
    {
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::CWiredAccessoryKeyEventHandler() - Enter" );
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::CWiredAccessoryKeyEventHandler() - Return" );
    
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::ConstructL()
    {
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::ConstructL() - Enter" );	   
    //
    // initialization of event subscribe(s) can be done here.
    //
    iState = EAccKeyEventHandlerStateReady;
    
    
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::ConstructL() - Return" );
    
    }

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

// Destructor
CWiredAccessoryKeyEventHandler::~CWiredAccessoryKeyEventHandler()
    {
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::~CWiredAccessoryKeyEventHandler() - Enter" );
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::~CWiredAccessoryKeyEventHandler() - Return" );    
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::GetInterface
// -----------------------------------------------------------------------------
//
TAny* CWiredAccessoryKeyEventHandler::GetInterface( TUid aUid )
    {

    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::GetInterface() - Enter" );
    
    
    TAny* bearer = NULL;

    if ( aUid == TUid::Uid( KRemConBearerInterface1 ) )
        {
        bearer = reinterpret_cast<TAny*>( static_cast<MRemConBearerInterface*>( this ) );
        }
    else
        {
        // Interface is not supported!
        }
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::GetInterface() - Return" );

    return bearer;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::GetResponse
// -----------------------------------------------------------------------------
//
TInt CWiredAccessoryKeyEventHandler::GetResponse( TUid& aInterfaceUid,
                                                  TUint& aTransactionId,
                                                  TUint& aOperationId,
                                                  RBuf8& aCommandData,
                                                  TRemConAddress& aAddr )
    {

    // Only events are forwarded, thus no need to implement get response
    TInt err ( KErrNotSupported );
                              
    ( void ) aTransactionId;
    ( void ) aOperationId;
    ( void ) aCommandData;
    ( void ) aAddr;
    ( void ) aInterfaceUid;

    return err;
    }

// -----------------------------------------------------------------------------
// CSACAccessoryKeyEventHandler::GetCommand
// -----------------------------------------------------------------------------
//
TInt CWiredAccessoryKeyEventHandler::GetCommand( TUid& aInterfaceUid,
                                                 TUint& aTransactionId,
                                                 TUint& aOperationId,
                                                 RBuf8& aCommandData,
                                                 TRemConAddress& aAddr )
    { 
    
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::GetCommand() - Enter" );
    TInt err ( KErrNone );
    
    if ( iState != EAccKeyEventHandlerStateNewCommand )
        {        
        err = KErrNotReady;
        }
    else
        {
        aInterfaceUid  = iInterfaceUid;
        aTransactionId = iTransactionId++;
        aOperationId   = iOperationId;
        
        aAddr.BearerUid() = Uid();
        aAddr.Addr()      = KNullDesC8();
        
        iState = EAccKeyEventHandlerStateReady;
        
        TRAP( err, aCommandData.CreateL( iData ) );
        
        if ( err != KErrNone )
            {
            //GetCommand - failed to create data
            }
        }

    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::GetCommand() - Return" );
    return err;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::SendCommand
// -----------------------------------------------------------------------------
//
TInt CWiredAccessoryKeyEventHandler::SendCommand( TUid aInterfaceUid,
                                                  TUint aOperationId,
                                                  TUint aTransactionId,
                                                  RBuf8& aData,
                                                  const TRemConAddress& aAddr )
    {

    // Only events are forwarded, thus no need to implement send command
    TInt err ( KErrNotSupported );

    ( void ) aTransactionId;
    ( void ) aOperationId;
    ( void ) aAddr;
    ( void ) aInterfaceUid;
    ( void ) aData;
                    
    return err;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::SendResponse
// -----------------------------------------------------------------------------
//
TInt CWiredAccessoryKeyEventHandler::SendResponse( TUid aInterfaceUid,
                                                   TUint aOperationId,
                                                   TUint aTransactionId,
                                                   RBuf8& aData,
                                                   const TRemConAddress& aAddr )
    {
    
    // Only events are forwarded, thus no need to implement send response
    TInt err ( KErrNotSupported );

    ( void ) aTransactionId;
    ( void ) aOperationId;
    ( void ) aAddr;
    ( void ) aInterfaceUid;
    ( void ) aData;
    
    return err;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::ConnectRequest
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::ConnectRequest( const TRemConAddress& aAddr )
    {

    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::ConnectRequest() - Enter" );
    
            
    TInt err = Observer().ConnectConfirm( aAddr, KErrNone );    

    if ( err != KErrNone )
        {
        // ConnectConfirm failed
        }        
        
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::ConnectRequest() - Return" );
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::DisconnectRequest
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::DisconnectRequest( const TRemConAddress& aAddr )
    {            
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::DisconnectRequest() - Enter" );
         
    Observer().DisconnectConfirm( aAddr, KErrNone );    
    
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::DisconnectRequest() - Return" );
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::ClientStatus
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::ClientStatus( TBool aControllerPresent, TBool aTargetPresent )
    {    
    ( void ) aTargetPresent;
    ( void ) aControllerPresent;           
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::SecurityPolicy
// -----------------------------------------------------------------------------
//
TSecurityPolicy CWiredAccessoryKeyEventHandler::SecurityPolicy() const
    {
    
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::SecurityPolicy() - Enter" );
    TSecurityPolicy securityPolicy ( ECapabilitySwEvent );
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::SecurityPolicy() - Return" );
    return securityPolicy;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::ProcessResponseL
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::ProcessResponseL( TAdaptationMessage& aMessage )
    {
    ( void ) aMessage;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::ProcessErrorResponseL
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::ProcessErrorResponseL( TInt aErrorCode,
                                                          TAdaptationMessage& aMessage )
    {    
    ( void ) aErrorCode;
    ( void ) aMessage;
    }

// -----------------------------------------------------------------------------
// CWiredAccessoryKeyEventHandler::RaiseEventL
// -----------------------------------------------------------------------------
//
void CWiredAccessoryKeyEventHandler::RaiseEventL( TAdaptationMessage& aMessage )
    {
    
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::RaiseEventL() - Enter" );
    //Accessory key events are received from Accessory Driver/Domestic OS.
    
    if ( iState != EAccKeyEventHandlerStateReady )
        {
        User::Leave( KErrNotReady );
        }

    // only key events are supported
    if ( aMessage.GroupId() != KBearerMessageGroupAccessoryEvent && aMessage.MessageId() != KBearerMessageGroupAccessoryKeyEvent )
        {        
        User::Leave( KErrArgument );
        }

    TRemConMessageType type( ERemConCommand );
    
    // Note!
    // following uid 0x102069AA should be used if platform key event converter is used, 
    // uid is hard coded to platfrom converter which is returned to remotecontrol.
    // Data should give as format defined in S60_Accessory_Key_Event_Handling_API_Specification_C.doc.
    const TInt KWireBearerUid = 0x102069AA;

    TInt err = Observer().BearerToInterface( TUid::Uid( KWireBearerUid ), 
                                             aMessage.Data(), 
                                             aMessage.Data(), 
                                             iInterfaceUid, 
                                             iOperationId, 
                                             type, 
                                             iData );     
    if ( err == KErrNotSupported )
        {
    
        }
    else if ( err == KErrNone )
        {
        iState = EAccKeyEventHandlerStateNewCommand;

        TRemConAddress addr;
        addr.BearerUid() = Uid();
        addr.Addr() = KNullDesC8();
        
        err = Observer().NewCommand( addr );
        
        if ( err != KErrNone )
            {
            User::Leave( err );
            }
        }
    else
        // leave if converting fails
        {       
        User::Leave( err );
        }    
        
    COM_TRACE_( "[AccFW:WiredBearerReference] CWiredAccessoryKeyEventHandler::RaiseEventL() - Return" );    
    }

//  End of File