/*

* 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:  Generic hid implementation

 *

*/

#include <etel3rdparty.h>

#include <e32std.h>

#include <e32svr.h>

#include <coedef.h>

#include <eiksvdef.h>

#include <apgcli.h>

#include <apgtask.h>

#include <e32property.h>

#include <alarmuidomainpskeys.h>

#include <mpxplaybackmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxplaybackmessagedefs.h>

#include "hidremconbearerinternalpskeys.h"

#include "hidremconbearerscancodes.h"

#include "headset.h"

#include "finder.h"

#include "debug.h"

const TInt KHidUndefinedKeyCode = 0;

const TInt KHidNotSetKeyValue = 0;

const TInt KDoubleClickTimeout = 900000; // 0,9 seconds

const TInt KScanClickTimeout = 500000; // 0,5 seconds

const TInt KLongClickTimeout = 3000000; // 3 seconds

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

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

// CHidHeadsetDriver()

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

//

CHidHeadsetDriver::CHidHeadsetDriver( MDriverAccess* aGenericHid ) :

    iGenericHid( aGenericHid ), iFieldList(), iDriverState( EUninitialised ),

            iConnectionId( 0 ), iSupportedFieldCount( 0 ), iForwardStatus(

                    EScanNotPressed ), iBackwardStatus( EScanNotPressed )

    {

    TRACE_FUNC_ENTRY_THIS

    TRACE_FUNC_EXIT

    }

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

// NewLC

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

//

CHidHeadsetDriver* CHidHeadsetDriver::NewLC( MDriverAccess* aGenericHid )

    {

    TRACE_INFO((_L("[HID]\tCHidHeadsetDriver::NewLC(0x%08x)"), aGenericHid));

    CHidHeadsetDriver* self = new ( ELeave ) CHidHeadsetDriver( aGenericHid );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// NewL

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

//

CHidHeadsetDriver* CHidHeadsetDriver::NewL( MDriverAccess* aGenericHid )

    {

    CHidHeadsetDriver* self = CHidHeadsetDriver::NewLC( aGenericHid );

    CleanupStack::Pop();

    return self;

    }

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

// ConstructL()

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

//

void CHidHeadsetDriver::ConstructL()

    {

    TRACE_FUNC_THIS

    iTelephony = CTelephony::NewL();

    User::LeaveIfError( iAlarmServerSession.Connect() );

    iMusicPlayer = MMPXPlaybackUtility::UtilityL( KPbModeActivePlayer );

    iMusicPlayer->AddObserverL( *this );

    }

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

// Destructor

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

//

CHidHeadsetDriver::~CHidHeadsetDriver()

    {

    TRACE_FUNC_THIS

    iAlarmServerSession.Close();

    delete iTelephony;

    iFieldList.Reset();

    iFieldList.Close();

    delete iDoubleClicktimer;

    if ( iMusicPlayer )

        {

        iMusicPlayer->Close();

        }

    delete iScanPreviousTimer;

    delete iScanNextTimer;

    delete iLongClicktimer;

    }

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

// From class CHidDriver

// StartL()

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

//

void CHidHeadsetDriver::StartL( TInt /*aConnectionId*/)

    {

    TRACE_FUNC

    // Ready to process headset events:

    iDriverState = EInitialised;

    }

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

// From class CHidDriver

// InitialiseL()

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

//

void CHidHeadsetDriver::InitialiseL( TInt aConnectionId )

    {

    TRACE_FUNC

    TRACE_INFO((_L("[HID]\tCHidHeadsetDriver::InitialiseL(%d)"),

                        aConnectionId));

    // Store the connection ID:

    iConnectionId = aConnectionId;

    }

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

// From class CHidDriver

// Stop()

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

//

void CHidHeadsetDriver::Stop()

    {

    TRACE_FUNC

    iDriverState = EDisabled;

    }

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

// From class CHidDriver

// DataIn()

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

//

TInt CHidHeadsetDriver::DataIn( CHidTransport::THidChannelType aChannel,

        const TDesC8& aPayload )

    {

    TInt retVal = KErrNone;

    switch ( aChannel )

        {

        case CHidTransport::EHidChannelInt:

            if ( EInitialised == iDriverState )

                {

                retVal = InterruptData( aPayload );

                }

            break;

        case CHidTransport::EHidChannelCtrl:

            retVal = KErrNotSupported;

            break;

        default:

            retVal = KErrNotSupported;

            break;

        }

    return retVal;

    }

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

// From class CHidDriver

// CommandResult()

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

//

void CHidHeadsetDriver::CommandResult( TInt /*aCmdAck*/)

    {

    // No implementation as we don't issue any requests to be acknowledged

    }

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

// From class CHidDriver

// Disconnected()

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

//

void CHidHeadsetDriver::Disconnected( TInt aReason )

    {

    TRACE_INFO((_L("[HID]\tCHidHeadsetDriver::Disconnected(%d)"), aReason));

    aReason = aReason;

    Stop();

    }

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

// From class CHidDriver

// SetInputHandlingReg()

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

//

void CHidHeadsetDriver::SetInputHandlingReg(

        CHidInputDataHandlingReg* aHandlingReg )

    {

    iInputHandlingReg = aHandlingReg;

    }

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

// From class CHidDriver

// InterruptData()

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

//

TInt CHidHeadsetDriver::InterruptData( const TDesC8& aPayload )

    {

    // If the report has a report ID, it is in the first byte.

    // If not, this value is ignored (see CField::IsInReport()).

    //

    TInt retVal = KErrNone;

    TInt ret = KErrNotSupported;

    TInt firstByte = aPayload[0];

    TRACE_INFO((_L("[HID]\tCHidHeadsetDriver::InterruptData(), report \

            0x%x (%d), length %d"),firstByte, firstByte, aPayload.Length()));

    if ( iFieldList.Count() == 0 )

        {

        retVal = KErrNotSupported;

        }

    for ( TInt i = 0; i < iFieldList.Count(); i++ )

        {

        if ( iFieldList[i]->IsInReport( firstByte ) )

            {

            ret = HandleReport( aPayload, iFieldList[i] );

            if ( ret == KErrNone )

                {

                retVal = KErrNone;

                }

            }

        else

            {

            retVal = KErrNotSupported;

            }

        }

    return retVal;

    }

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

// HandleReport()

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

//

TInt CHidHeadsetDriver::HandleReport( const TDesC8& aReport,

        const CField* aField )

    {

    TRACE_FUNC_ENTRY

    TReportTranslator report( aReport, aField );

    TInt retVal = KErrNotSupported;

    // release if key if it pressed and relased

    ReleasePressedKeys( report );

    if ( HandleTelephonyUsage( report ) == KErrNone )

        {

        retVal = KErrNone;

        }

    if ( HandleControlUsage( report ) == KErrNone )

        {

        retVal = KErrNone;

        }

    if ( HandleVolumeUsage( report ) == KErrNone )

        {

        retVal = KErrNone;

        }

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// HandleTelephonyUsage()

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

//

TInt CHidHeadsetDriver::HandleTelephonyUsage( TReportTranslator& aReport )

    {

    TRACE_FUNC_ENTRY

    TInt retVal = KErrNotSupported;

    TInt hookSwitch = 0;

    TInt mute = 0;

    TInt poc = 0;

    // P&S key variables

    TUint key = KHidUndefinedKeyCode;

    TInt value = KHidNotSetKeyValue;

    if ( aReport.GetValue( mute, ETelephonyUsagePhoneMute ) == KErrNone

            && mute == 1 )

        {

        TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send mute \

                command"));

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageTelephony,

                ETelephonyUsagePhoneMute ) )

            {

            key = KHidMuteKeyEvent;

            value = KPSMuteClicked;

            iInputHandlingReg->AddHandledEvent( EUsagePageTelephony,

                    ETelephonyUsagePhoneMute );

            }

        }

    else if ( aReport.GetValue( hookSwitch, ETelephonyUsageHookSwitch )

            == KErrNone && hookSwitch == 1 )

        {

        TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send hook \

                switch command (disabled)"));

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageTelephony,

                ETelephonyUsageHookSwitch ) )

            {

            HookKeyPres( ETrue );

            iInputHandlingReg->AddHandledEvent( EUsagePageTelephony,

                    ETelephonyUsageHookSwitch );

            }

        }

    else if ( aReport.GetValue( poc, ETelephonyUsagePoC ) == KErrNone && poc

            == 1 )

        {

        TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send PoC \

                command (disabled)"));

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageTelephony,

                ETelephonyUsagePoC ) )

            {

            key = KHidMuteKeyEvent;

            value = KPSMuteClicked;

            iInputHandlingReg->AddHandledEvent( EUsagePageTelephony,

                    ETelephonyUsagePoC );

            }

        }

    if ( key != KHidUndefinedKeyCode && value != KHidNotSetKeyValue )

        {

        TInt err = RProperty::Set( KPSUidHidEventNotifier, key, value );

        retVal = KErrNone;

        }

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// HandleTelephonyUsage()

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

//

TInt CHidHeadsetDriver::HandleControlUsage( TReportTranslator& aReport )

    {

    TRACE_FUNC_ENTRY

    TInt retVal = KErrNotSupported;

    TInt playPause = 0;

    TInt scanNext = 0;

    TInt scanPrev = 0;

    TInt stop = 0;

    // P&S key variables

    TUint key = KHidUndefinedKeyCode;

    TInt value = KHidNotSetKeyValue;

    if ( aReport.GetValue( playPause, EConsumerUsagePlayPause ) == KErrNone

            && playPause )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsagePlayPause ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send \

                    play/pause command (currently only play)"));

            key = KHidControlKeyEvent;

            value = EPlayClicked;

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsagePlayPause );

            }

        }

    else if ( aReport.GetValue( scanNext, EConsumerUsageScanNext )

            == KErrNone && scanNext )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsageScanNext ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send \

                    scan next command"));

            TRAP_IGNORE( HandleScanNextPressL() );

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsageScanNext );

            }

        }

    else if ( aReport.GetValue( scanPrev, EConsumerUsageScanPrev )

            == KErrNone && scanPrev )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsageScanPrev ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Scan \

                    prev command"));

            TRAP_IGNORE( HandleScanPrevPressL());

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsageScanPrev );

            }

        }

    else if ( aReport.GetValue( stop, EConsumerUsageStop ) == KErrNone

            && stop )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsageStop ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send \

                    stop command"));

            key = KHidControlKeyEvent;

            value = EStopClicked;

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsageScanPrev );

            }

        }

    if ( key != KHidUndefinedKeyCode && value != KHidNotSetKeyValue )

        {

        TInt err = RProperty::Set( KPSUidHidEventNotifier, key, value );

        retVal = KErrNone;

        }

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// HandleVolumeUsage()

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

//

TInt CHidHeadsetDriver::HandleVolumeUsage( TReportTranslator& aReport )

    {

    TRACE_FUNC_ENTRY

    TInt retVal = KErrNotSupported;

    TInt volUp = 0;

    TInt volDown = 0;

    TInt speakermute = 0;

    // P&S key variables

    TUint key = KHidUndefinedKeyCode;

    TInt value = KHidNotSetKeyValue;

    if ( aReport.GetValue( volUp, EConsumerUsageVolumeInc ) == KErrNone

            && volUp )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsageVolumeInc ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): \

                    Send volume up command"));

            key = KHidAccessoryVolumeEvent;

            iVolumeUpPressed = ETrue;

            value = KPSVolumeUpPressed;

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsageScanPrev );

            }

        }

    else if ( aReport.GetValue( volDown, EConsumerUsageVolumeDec )

            == KErrNone && volDown )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsageVolumeDec ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send \

                    volume down command"));

            key = KHidAccessoryVolumeEvent;

            iVolumeDownPressed = ETrue;

            value = KPSVolumeDownPressed;

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsageVolumeDec );

            }

        }

    else if ( ( aReport.GetValue( speakermute, EConsumerUsageMute )

            == KErrNone && speakermute == 1 ) )

        {

        if ( iInputHandlingReg->AllowedToHandleEvent( EUsagePageConsumer,

                EConsumerUsageMute ) )

            {

            TRACE_INFO(_L("[HID]\tCHidHeadsetDriver::HandleReport(): Send \

                    mute command"));

            key = KHidMuteKeyEvent;

            value = KPSMuteClicked;

            iInputHandlingReg->AddHandledEvent( EUsagePageConsumer,

                    EConsumerUsageMute );

            }

        }

    if ( key != KHidUndefinedKeyCode && value != KHidNotSetKeyValue )

        {

        TInt err = RProperty::Set( KPSUidHidEventNotifier, key, value );

        retVal = KErrNone;

        }

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// HandleScanNextPressL()