/*

* Copyright (c) 2005-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:  Bearer plugin API Implementation file

 *

*/

#include <e32def.h>

#include <remcon/remconbearerobserver.h>

#include <remcon/remconconverterplugin.h>

#include <remconaddress.h>

#include <remconcoreapi.h>

#include <RemConExtensionApi.h>

#include <PSVariables.h>   // Property values

#include <coreapplicationuisdomainpskeys.h>

#include "hidremconbearerinternalpskeys.h"

#include "hidremconbearerscancodes.h"

#include "hidremconbearerimplementation.h"

#include "hidremconbearerobserver.h"

#include "debug.h"

_LIT8(KFormatString,"%c");

_LIT8(KVoiceFormatString,"%d");

_LIT_SECURITY_POLICY_C1(KHidRemconBearerReadPolicy, ECapability_None);

_LIT_SECURITY_POLICY_C1(KHidRemconBearerWritePolicy, ECapability_None);

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

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

// CHidRemconBearer::NewL()

// Description: Factory function.

// return: Ownership of a new CHidRemconBearer.

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

//

CHidRemconBearer* CHidRemconBearer::NewL( TBearerParams& aParams )

    {

    CHidRemconBearer* self = new ( ELeave ) CHidRemconBearer( aParams );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CHidRemconBearer::~CHidRemconBearer()

// Destructor.

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

//

CHidRemconBearer::~CHidRemconBearer()

    {

    delete iMediaKeyObserver;

    delete iAccessoryVolKeyObserver;

    delete iMuteKeyObserver;

    delete iHookKeyObserver;

    }

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

// CHidRemconBearer::CHidRemconBearer()

// construction.

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

//

CHidRemconBearer::CHidRemconBearer( TBearerParams& aParams ) :

    CRemConBearerPlugin( aParams )

    {

    //Pass

    }

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

// CHidRemconBearer::ConstructL()

// 2nd-phase construction.

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

//

void CHidRemconBearer::ConstructL()

    {

        TRACE_FUNC_ENTRY

    // throw an indication up to RemCon.

    TRemConAddress addr;

    addr.BearerUid() = Uid();

    TInt err = Observer().ConnectIndicate( addr );

    //Define the P&S for Volume keys and Media Keys    

    RProperty::Define( KPSUidHidEventNotifier, KHidControlKeyEvent,

            RProperty::EInt, KHidRemconBearerReadPolicy,

            KHidRemconBearerWritePolicy );

    // Define P&S Key for Volume keys from Accessory device

    RProperty::Define( KPSUidHidEventNotifier, KHidAccessoryVolumeEvent,

            RProperty::EInt, KHidRemconBearerReadPolicy,

            KHidRemconBearerWritePolicy );

    // Define P&S Key for Mute key from Accessory device

    RProperty::Define( KPSUidHidEventNotifier, KHidMuteKeyEvent,

            RProperty::EInt, KHidRemconBearerReadPolicy,

            KHidRemconBearerWritePolicy );

    // Define P&S Key for phone keys from Accessory device

    RProperty::Define( KPSUidHidEventNotifier, KHidHookKeyEvent,

            RProperty::EInt, KHidRemconBearerReadPolicy,

            KHidRemconBearerWritePolicy );

    // Start Active object for listening key events from P&S

    iMediaKeyObserver = CHidRemconBearerObserver::NewL( *this, EMediaKeys );

    iAccessoryVolKeyObserver = CHidRemconBearerObserver::NewL( *this,

            EAccessoryVolumeKeys );

    iMuteKeyObserver = CHidRemconBearerObserver::NewL( *this, EMuteKey );

    iHookKeyObserver = CHidRemconBearerObserver::NewL( *this, EHookKeys );

    }

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

// CHidRemconBearer::ConnectRequest()

// Rem Con server send connect request to Bearer Plugin

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

//

void CHidRemconBearer::ConnectRequest( const TRemConAddress& /*aAddr*/)

    {

    TRACE_FUNC

    // Pass

    }

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

// CHidRemconBearer::DisconnectRequest()

// Rem Con server send disconnect request to Bearer Plugin

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

//

void CHidRemconBearer::DisconnectRequest( const TRemConAddress& /*aAddr*/)

    {

    TRACE_FUNC

    // Pass

    }

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

// CHidRemconBearer::SendResponse()

// 

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

//

TInt CHidRemconBearer::SendResponse( TUid /* aInterfaceUid */,

        TUint /*aOperationId*/, 

        TUint /*aTransactionId*/, // we don't care about this transaction ID

        RBuf8& aData, 

        const TRemConAddress& /*aAddr*/)

    {

    TRACE_FUNC

    aData.Close();

    return KErrNone;

    }

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

// CHidRemconBearer::SendCommand()

// 

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

//

TInt CHidRemconBearer::SendCommand( TUid /* aInterfaceUid */,

        TUint /* aOperationId */, TUint /* aTransactionId */,

        RBuf8& /* aData */, const TRemConAddress& /*aAddr*/)

    {

    TRACE_FUNC

    return KErrNone;

    }

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

// CHidRemconBearer::GetResponse()

// 

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

//

TInt CHidRemconBearer::GetResponse( TUid& /* aInterfaceUid */,

        TUint& /* aTransactionId*/, TUint& /* aOperationId */,

        RBuf8& /* aData */, TRemConAddress& /*aAddr */)

    {

    TRACE_FUNC

    return KErrNone;

    }

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

// CHidRemconBearer::GetCommand()

// 

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

//

TInt CHidRemconBearer::GetCommand( TUid& aInterfaceUid,

        TUint& aTransactionId, TUint& aOperationId, RBuf8& aData,

        TRemConAddress& aAddr )

    {

        TRACE_FUNC

    aInterfaceUid = iInterfaceUid;

    aOperationId = iOperationId;

    // Pass ownership of this to RemCon.

    TRAPD(retTrap, aData.CreateL(iData));

    if ( retTrap != KErrNone )

        {

        return retTrap;

        }

    aAddr.BearerUid() = Uid();

    aAddr.Addr() = KNullDesC8();

    aTransactionId = iTransactionId;

    return KErrNone;

    }

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

// CHidRemconBearer::SetSVKOperationIdAndData()

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

//

void CHidRemconBearer::SetSVKOperationIdAndData( TInt aEnumValue )

    {

        TRACE_FUNC

    // 1. Interface ID is required when Getcommand is called

    iInterfaceUid = TUid::Uid( KRemConCoreApiUid ); // from Remconcoreapi.h

    switch ( aEnumValue )

        {

        case KPSVolumeUpPressed:

            iOperationId = ERemConCoreApiVolumeUp;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case KPSVolumeUpReleased:

            iOperationId = ERemConCoreApiVolumeUp;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case KPSVolumeUpClicked:

            iOperationId = ERemConCoreApiVolumeUp;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case KPSVolumeDownPressed:

            iOperationId = ERemConCoreApiVolumeDown;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case KPSVolumeDownReleased:

            iOperationId = ERemConCoreApiVolumeDown;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case KPSVolumeDownClicked:

            iOperationId = ERemConCoreApiVolumeDown;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case KPSVolumeNoKey: // This should never execute

            break;

        default:

            iOperationId = aEnumValue;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        }

    }

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

// CHidRemconBearer::SetMuteKeyOperationIdAndData

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

//

void CHidRemconBearer::SetMuteKeyOperationIdAndData( TInt aEnumValue )

    {

        TRACE_INFO((_L("[HID]\tCHidRemconBearer::SetMuteKeyOperation \

                IdAndData( %d )"), aEnumValue));

    // 1. Interface ID is required when Getcommand is called

    iInterfaceUid = TUid::Uid( KRemConCoreApiUid ); // from Remconcoreapi.h

    switch ( aEnumValue )

        {

        case KPSMutePressed:

            iOperationId = ERemConCoreApiMute;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case KPSMuteReleased:

            iOperationId = ERemConCoreApiMute;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case KPSMuteClicked:

            iOperationId = ERemConCoreApiMute;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        default:

            TRACE_INFO(_L("CHidRemconBearer::SetMuteKeyOperationIdAndData : \

                    Not supported"))

            ;

        }

    }

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

// CHidRemconBearer::SetMediaKeyOperationIdAndData()

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

//

void CHidRemconBearer::SetMediaKeyOperationIdAndData( TInt aEnumValue )

    {

        TRACE_FUNC

    // 1. Interface ID is required when Getcommand is called

    iInterfaceUid = TUid::Uid( KRemConCoreApiUid ); // from Remconcoreapi.h

    switch ( aEnumValue )

        {

        case EPlayReleased:

            iOperationId = ERemConCoreApiPausePlayFunction;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case EPlayPressed:

            iOperationId = ERemConCoreApiPausePlayFunction;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case EPlayClicked:

            iOperationId = ERemConCoreApiPausePlayFunction;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case EStopReleased:

            iOperationId = ERemConCoreApiStop;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case EStopPressed:

            iOperationId = ERemConCoreApiStop;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case EStopClicked:

            iOperationId = ERemConCoreApiStop;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case EForwardReleased:

            iOperationId = ERemConCoreApiForward;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case EForwardPressed:

            iOperationId = ERemConCoreApiForward;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case EForwardClicked:

            iOperationId = ERemConCoreApiForward;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case ERewindReleased:

            iOperationId = ERemConCoreApiRewind;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case ERewindPressed:

            iOperationId = ERemConCoreApiRewind;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case ERewindClicked:

            iOperationId = ERemConCoreApiRewind;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case EFastForwardReleased:

            iOperationId = ERemConCoreApiFastForward;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case EFastForwardPressed:

            iOperationId = ERemConCoreApiFastForward;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case EFastForwardClicked:

            iOperationId = ERemConCoreApiFastForward;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case EBackwardReleased:

            iOperationId = ERemConCoreApiBackward;

            iData.Format( KFormatString, ERemConCoreApiButtonRelease );

            break;

        case EBackwardPressed:

            iOperationId = ERemConCoreApiBackward;

            iData.Format( KFormatString, ERemConCoreApiButtonPress );

            break;

        case EBackwardClicked:

            iOperationId = ERemConCoreApiBackward;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

            // This should never execute

        default:

            iOperationId = aEnumValue;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        }

    }

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

// CHidRemconBearer::ReceivedKeyEvent()

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

//

void CHidRemconBearer::SetPhoneKeyOperationIdAndData( TInt aEnumValue )

    {

    TRACE_FUNC_ENTRY

    iInterfaceUid = TUid::Uid( KRemConExtCallHandlingApiUid );

    switch ( aEnumValue )

        {

        case KPSAnsweClicked:

            TRACE_INFO((_L("[HID]\tCHidRemconBearer::SetPhoneKey \

                    OperationIdAndData Answer")));

            iOperationId = ERemConExtAnswerCall;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case KPSHangUpClicked:

            iOperationId = ERemConExtEndCall;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case KPSRedial:

            iOperationId = ERemConExtLastNumberRedial;

            iData.Format( KFormatString, ERemConCoreApiButtonClick );

            break;

        case KPSVoiceDial:

            iOperationId = ERemConExtVoiceDial;

            iData.Format( KVoiceFormatString, ERemConCoreApiButtonRelease );

            break;

        default:

            TRACE_INFO(_L("CHidRemconBearer::SetPhoneKeyOperationIdAndData \

                    : Not supported"));        }

    TRACE_FUNC_EXIT

    }

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

// CHidRemconBearer::ReceivedKeyEvent()

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

//

void CHidRemconBearer::ReceivedKeyEvent( TInt aEnumValue, TInt aKeyType )

    {

    TRACE_INFO((_L("[HID]\tCHidRemconBearer::ReceivedKeyEvent: value %d, \

            type %d )"), aEnumValue, aKeyType));

    /* To keep the background light on */

    User::ResetInactivityTime();

    // 2. Transaction ID

    iTransactionId = Observer().NewTransactionId();

    // 3. Addr 

    TRemConAddress addr;

    addr.BearerUid() = Uid();

    addr.Addr() = KNullDesC8();

    // 4 & 5. Operation ID and Data

    HandleKeyOperation( aEnumValue, aKeyType );

    // Msgtype  is ERemConCommand

    TInt error = Observer().NewCommand( addr );

    TRACE_INFO((_L("[HID]\tCHidRemconBearer::ReceivedKeyEvent: error %d )"), 

            error));

    //Start the listener once again     

    RestartKeyObeserver( aKeyType );

    }

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

// CHidRemconBearer::RestartKeyObeserver

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

//

void CHidRemconBearer::RestartKeyObeserver( TInt aKeyType )

    {

    TRACE_FUNC_ENTRY

    switch ( aKeyType )

        {

        case EMediaKeys:

            iMediaKeyObserver->Start();

            break;

        case EAccessoryVolumeKeys:

            iAccessoryVolKeyObserver->Start();

            break;

        case EMuteKey:

            iMuteKeyObserver->Start();

            break;

        case EHookKeys:

            iHookKeyObserver->Start();

            break;

        default:

            TRACE_INFO(_L("CHidRemconBearer::RestartKeyObeserver : Not supported"))

            ;

        }

        TRACE_FUNC_EXIT

    }

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

// CHidRemconBearer::RestartObexserver

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

//

void CHidRemconBearer::HandleKeyOperation( TInt aEnumValue, TInt aKeyType )

    {

    TRACE_FUNC_ENTRY

    switch ( aKeyType )

        {

        case EAccessoryVolumeKeys:

            SetSVKOperationIdAndData( aEnumValue );

            break;

        case EMuteKey:

            SetMuteKeyOperationIdAndData( aEnumValue );

            break;

        case EMediaKeys:

            SetMediaKeyOperationIdAndData( aEnumValue );

            break;

        case EHookKeys:

            SetPhoneKeyOperationIdAndData( aEnumValue );

            break;

        default:

            TRACE_INFO(_L("CHidRemconBearer::HandleKeyOperation : Not \

                    supported"))

            ;

        }

    TRACE_FUNC_EXIT

    }

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

// CHidRemconBearer::SecurityPolicy()

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

//

TSecurityPolicy CHidRemconBearer::SecurityPolicy() const

    {

    return TSecurityPolicy( ECapabilityLocalServices );

    }

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

// CHidRemconBearer::ClientStatus()

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

//

void CHidRemconBearer::ClientStatus( TBool /*aControllerPresent*/, TBool /*aTargetPresent*/)

    {

        //Pass

    TRACE_FUNC

    }

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

// CHidRemconBearer::GetInterface()

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

//

TAny* CHidRemconBearer::GetInterface( TUid aUid )

    {

    TRACE_FUNC

    TAny* ret = NULL;

    if ( aUid == TUid::Uid( KRemConBearerInterface1 ) )

        {

        ret = reinterpret_cast<TAny*> ( 

                        static_cast<MRemConBearerInterface*> ( this ) );

        }

    return ret;

    }