/*

* Copyright (c) 2006 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:  Implementation of CMPXLbxExtendedFeatures

*

*/

// INCLUDE FILES

#include <eiktxlbx.h>

#include <eiktxlbm.h>

#include <aknconsts.h>

#include <aknsoundsystem.h>

#include <aknViewAppUi.h>

#include <aknnavide.h>

#include <aknnavilabel.h>

#include <eikspane.h>

#include <aknappui.h>

#include <StringLoader.h>

#include <centralrepository.h>

#include <AknUtils.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <MProfileEngine.h>

#include <MProfile.h>

#include <MProfileTones.h>

#include <TProfileToneSettings.h>

#include <AudioPreference.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcollectionmessage.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxsubscription.h>

#include <mpxuser.h>

#include <mpxcommonui.rsg>

#include <mpxcollectionutility.h>

#include "mpxinternalcrkeys.h"

#include "mpxlbxextendedfeatures.h"

#include "mpxlog.h"

// CONSTANTS

const TInt KMPXDefaultKeyRepeatInitDelay = KAknKeyboardRepeatInitialDelay;

const TInt KMPMicroSecPerMilliSec = 1000;

const TInt KSoundInterval = 1000000;  // 1 second

const TInt KMaxVolumeLevel = 3;

const TInt KSpeedScrollSetIndexInterval = 5;

_LIT( KMPXCommonUiRscPath, "mpxcommonui.rsc" );

//_LIT8( KPhoneNormalBeepSequence, "\x00\x11\x0A\x71\x06\x0B" );

_LIT8( KPhoneFastBeepSequence, "\x00\x11\x0A\x76\x06\x0B" );

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

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

// CMPXLbxExtendedFeatures::CMPXLbxExtendedFeatures

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMPXLbxExtendedFeatures::CMPXLbxExtendedFeatures(

    CEikTextListBox* aLbx,

    TBool aEnableSetIndex ) :

    iLbx( aLbx ),

    iKeyStatus( EMPXKeyOther ),

    iScrollingState( EMPXScrollingIdle ),

    iNaviEnabled( ETrue ),

    iKeysoundEnabled( ETrue ),

    iEnableSetIndex( aEnableSetIndex )

    {

    }

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

// CMPXLbxExtendedFeatures::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMPXLbxExtendedFeatures::ConstructL()

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::ConstructL" );

    CCoeEnv* coeEnv = CEikonEnv::Static();

    TParse parse;

    parse.Set( KMPXCommonUiRscPath, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resourceFile( parse.FullName() );

    User::LeaveIfError( MPXUser::CompleteWithDllPath( resourceFile ) );

    BaflUtils::NearestLanguageFile( coeEnv->FsSession(), resourceFile );

    iResourceOffset = coeEnv->AddResourceFileL( resourceFile );

    // connect to window server for scrolling speed setting

    iWsSession = CEikonEnv::Static()->WsSession();

    TUid naviPaneUid;

    naviPaneUid.iUid = EEikStatusPaneUidNavi;

    iNaviPane =

        static_cast<CAknNavigationControlContainer*>

        ( iAvkonViewAppUi->StatusPane()->ControlL( naviPaneUid ) );

    GetInfoFromCenRepL();

    iNaviDecorator = iNaviPane->CreateNavigationLabelL( KNullDesC );

    //Create label to change text in Navi pane

    iNaviLabel = static_cast<CAknNaviLabel*>

            ( iNaviDecorator->DecoratedControl() );

    iTimer = CPeriodic::NewL( CActive::EPriorityIdle );

    iToneUtility = CMdaAudioToneUtility::NewL( *this, NULL );

    iToneUtility->SetPriority(

        KAudioPriorityKeyPress,

        static_cast<TMdaPriorityPreference>( KAudioPrefKeyPressNonDTMF ) );

    iToneUtility->SetRepeats( 1,

        TTimeIntervalMicroSeconds( KSoundInterval ) );

    iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeDefault );

#ifdef __USE_MESSAGE_SUBSCRIPTION

    // Subscribe to only a few messages from collection utility

    CMPXSubscription* subscription( CMPXSubscription::NewL() );

    CleanupStack::PushL( subscription );

    CMPXSubscriptionItem* subItem1( CMPXSubscriptionItem::NewL() );

    CleanupStack::PushL( subItem1 );

    subItem1->SetTObjectValueL( KMPXMessageGeneralId, KMPXMessageGeneral );

    subItem1->SetTObjectValueL( KMPXMessageGeneralEvent, TMPXCollectionMessage::EPathChanged );

    subItem1->SetTObjectValueL( KMPXMessageGeneralType, EMcPathChangedByOpen );

    subscription->AddItemL( *subItem1 );

    iCollectionUtility->Collection().AddSubscriptionL( *subscription );

    CleanupStack::PopAndDestroy( subItem1 );

    CleanupStack::PopAndDestroy( subscription );

#endif

    }

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

// CMPXLbxExtendedFeatures::NewL

// Two-phased constructor.

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

//

EXPORT_C CMPXLbxExtendedFeatures* CMPXLbxExtendedFeatures::NewL(

    CEikTextListBox* aLbx, TBool aEnableSetIndex )

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::NewL" );

    __ASSERT_DEBUG( aLbx, User::Panic( _L("NewL"), KErrArgument ) );

    CMPXLbxExtendedFeatures* self =

        new ( ELeave ) CMPXLbxExtendedFeatures( aLbx, aEnableSetIndex );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

//

EXPORT_C CMPXLbxExtendedFeatures::~CMPXLbxExtendedFeatures()

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::~CMPXLbxExtendedFeatures" );

    delete iTimer;

    iWsSession.SetKeyboardRepeatRate(

        KAknKeyboardRepeatInitialDelay, KAknStandardKeyboardRepeatRate );

    iWsSession.Flush();

    if ( !iKeysoundEnabled )

        {

        // Enable keysound if it's not already enabled

        iAvkonViewAppUi->KeySounds()->PopContext();

        }

    if ( iNaviDecorator )

        {

        delete iNaviDecorator;

        }

    if ( iResourceOffset )

        {

        CEikonEnv::Static()->DeleteResourceFile( iResourceOffset );

        }

    if( iToneUtility )

        {

        if( iToneUtility->State() == EMdaAudioToneUtilityPlaying )

            {

            iToneUtility->CancelPlay();

            }

        else

            {

            iToneUtility->CancelPrepare();

            }

        delete iToneUtility;

        }

    if ( iCollectionUtility )

        {

        iCollectionUtility->Close();

        }

    }

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

// CMPXLbxExtendedFeatures::HandleLbxKeyEventL

// Handle key events

// (other items were commented in a header).

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

//

EXPORT_C TKeyResponse CMPXLbxExtendedFeatures::HandleLbxKeyEventL(

    const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    //MPX_FUNC( "CMPXLbxExtendedFeatures::HandleLbxKeyEventL" );

    TKeyResponse keyResponse = EKeyWasNotConsumed;

    if ( iSpeedScrollEnabled )

        {

        //MPX_DEBUG2( "CMPXLbxExtendedFeatures::HandleLbxKeyEventL EventType: %d", aType );

        if ( aType == EEventKeyDown )

            {

            MPX_PERF_CHECKPT("Key down issued")

            // pass it to listbox to handle

            keyResponse = iLbx->OfferKeyEventL( aKeyEvent, aType );

            keyResponse = HandleEventKeyDownL( aKeyEvent );

            iFirstKeyEvent = ETrue;

            }

        else if ( aType == EEventKeyUp )

            {

            // pass it to listbox to handle

            keyResponse = iLbx->OfferKeyEventL( aKeyEvent, aType );

            keyResponse = HandleEventKeyUpL( aKeyEvent );

            }

        else if ( aType == EEventKey )

            {

            if ( ( aKeyEvent.iScanCode == EStdKeyLeftArrow ) ||

                ( aKeyEvent.iScanCode == EStdKeyRightArrow ) )

                {

                keyResponse = iLbx->OfferKeyEventL(

                              aKeyEvent, aType );

                }

            else if ( !CheckBoundaryCases( iKeyStatus ) )

                {

                if ( !iSkipEvent )

                    {

                    keyResponse = iLbx->OfferKeyEventL(

                        aKeyEvent, aType );

                    if ( ( ( aKeyEvent.iScanCode == EStdKeyUpArrow ) ||

                         ( aKeyEvent.iScanCode == EStdKeyDownArrow ) ) &&

                         iEnableSetIndex )

                        {

                        // Get current listbox item index

                        TInt currentItem = iLbx->CurrentItemIndex();

                        if ( currentItem != KErrNotFound )

                            {

                            SetIndexToCollectionL( currentItem );

                            }

                        }

                    }

                else

                    {

                    // Simulate the key event to activate the updated scrolling speed

                    iWsSession.SimulateKeyEvent(aKeyEvent);

                    keyResponse = EKeyWasConsumed;

                    }

                }

            else

                {

                // bump effect

                if ( iFirstKeyEvent )

                    {

                    iSkipEvent = ETrue;

                    keyResponse = iLbx->OfferKeyEventL(

                        aKeyEvent, aType );

                    if ( ( ( aKeyEvent.iScanCode == EStdKeyUpArrow ) ||

                         ( aKeyEvent.iScanCode == EStdKeyDownArrow ) ) &&

                         iEnableSetIndex )

                        {

                        TInt currentItem = iLbx->CurrentItemIndex();

                        if ( currentItem != KErrNotFound )

                            {

                            SetIndexToCollectionL( currentItem );

                            }

                        }

                    iKeyStatus = EMPXKeyDown;

                    if ( aKeyEvent.iScanCode == EStdKeyUpArrow )

                        {

                        iKeyStatus = EMPXKeyUp;

                        }

                    // reset scrolling speed to normal

                    iScrollingState = EMPXScrollingIdle;

                    UpdateScrollingSpeed( iKeyStatus );

                    iScrollingState = EMPXScrolling1stBufferTime;

                    // after crossing the boundary, start timer again

                    StopTimer();

                    StartTimerL();

                    }

                EnableKeySoundL( EFalse );

                keyResponse = EKeyWasConsumed;

                MPX_PERF_CHECKPT("End of list reaches - bump effect");

                }

            iFirstKeyEvent = EFalse;

            iSkipEvent = EFalse;

            }

        else

            {

            // Other TEventCode; do nothing

            }

        } // end if iSpeedScrollEnabled

    else // iSpeedScrollEnabled is false

        {

        // pass it to listbox to handle

        keyResponse = iLbx->OfferKeyEventL( aKeyEvent, aType );

        // Get current listbox item index

        if ( ( ( aKeyEvent.iScanCode == EStdKeyUpArrow ) ||

             ( aKeyEvent.iScanCode == EStdKeyDownArrow ) ) &&

             iEnableSetIndex )

            {

            TInt currentItem = iLbx->CurrentItemIndex();

            if ( currentItem != KErrNotFound )

                {

                SetIndexToCollectionL( currentItem );

                }

            }

        }

    return keyResponse;

    }

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

// CMPXLbxExtendedFeatures::EnableSpeedScroll

// Enable/disable speed scroll

// (other items were commented in a header)

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

//

EXPORT_C void CMPXLbxExtendedFeatures::EnableSpeedScrollL( TBool aIsEnable )

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::EnableSpeedScrollL" );

    iSpeedScrollEnabled = aIsEnable;

    if ( !aIsEnable )

        {

        Reset();

        }

    }

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

// CMPXLbxExtendedFeatures::SpeedNaviUpdating

// Enable or disable speedscroll specific navi labelling

// (other items were commented in a header).

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

//

EXPORT_C void CMPXLbxExtendedFeatures::SpeedNaviUpdating( TBool aNaviEnable )

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::SpeedNaviUpdating" );

    iNaviEnabled = aNaviEnable;

    }

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

// CMPXLbxExtendedFeatures::Reset

// Reset everything to default (eg. scrolling speed)

// (other items were commented in a header).

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

//

void CMPXLbxExtendedFeatures::Reset()

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::Reset" );

    StopTimer();

    // Reset all states to idle

    iKeyStatus = EMPXKeyOther;

    iScrollingState = EMPXScrollingIdle;

    // Revert to original speed

    UpdateScrollingSpeed( iKeyStatus );

    TRAP_IGNORE( EnableKeySoundL( ETrue ) );

    }

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

// CMPXLbxExtendedFeatures::EnableAutoLoop

// Enable/disable auto loop

// (other items were commented in a header)

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

//

void CMPXLbxExtendedFeatures::EnableAutoLoop( TBool aIsEnable )

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::EnableAutoLoop" );

    iAutoLoopEnabled = aIsEnable;

    }

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

// CMPXLbxExtendedFeatures::StartTimer

// Start the timer

// (other items were commented in a header).

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

//

void CMPXLbxExtendedFeatures::StartTimerL()

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::StartTimerL" );

    TInt bufferTime = 0;

    TBool enabled = EFalse;

    switch ( iScrollingState )

        {

        case EMPXScrolling1stBufferTime:

            {

            // Enable 1st buffer timer

            bufferTime = iFirstBufferTime;

            enabled = ETrue;

            break;

            }

        case EMPXScrolling2ndBufferTime:

            {

            // Enable 2nd buffer timer

            bufferTime = iSecondBufferTime;

            enabled = ETrue;

            break;

            }

        default:

            {

            // Do nothing

            break;

            }

        }

    if ( enabled )

        {

        StopTimer();

        iTimer->Start( TTimeIntervalMicroSeconds32(

                            bufferTime * KMPMicroSecPerMilliSec ),

                       TTimeIntervalMicroSeconds32(

                            bufferTime * KMPMicroSecPerMilliSec ),

                       TCallBack( TimerCallBack, this ) );

        }

    }

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

// CMPXLbxExtendedFeatures::StopTimer

// Stop the timer

// (other items were commented in a header).

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

//

void CMPXLbxExtendedFeatures::StopTimer()

    {

    //MPX_FUNC( "CMPXLbxExtendedFeatures::StopTimer" );

    if ( iTimer && iTimer->IsActive() )

        {

        iTimer->Cancel();

        }

    }

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

// CMPXLbxExtendedFeatures::TimerCallBack

// Callback function for the timer

// (other items were commented in a header).

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

//

TInt CMPXLbxExtendedFeatures::TimerCallBack( TAny* aPtr )

    {

    //MPX_FUNC( "CMPXLbxExtendedFeatures::TimerCallBack" );

    CMPXLbxExtendedFeatures *p = ( CMPXLbxExtendedFeatures* )aPtr;

    p->BufferTimerHandler();

    return EFalse;

    }

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

// CMPXLbxExtendedFeatures::BufferTimerHandler

// Change scrolling status, called by TimerCallBack()

// (other items were commented in a header).

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

//

void CMPXLbxExtendedFeatures::BufferTimerHandler()

    {

    //MPX_FUNC( "CMPXLbxExtendedFeatures::BufferTimerHandler" );

    StopTimer();

    switch ( iScrollingState )

        {

        case EMPXScrolling1stBufferTime:

            {

            iScrollingState = EMPXScrolling1stSpeed;

            // Goto first speed

            UpdateScrollingSpeed( iKeyStatus );

            TRAP_IGNORE( EnableKeySoundL( EFalse ) );

            break;

            }

        default:

            {

            // Reset all states if timeout

            Reset();

            break;

            }

        }

    }

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

// CMPXLbxExtendedFeatures::UpdateScrollingSpeed

// Update and return scrolling speed

// (other items were commented in a header).

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

//

void CMPXLbxExtendedFeatures::UpdateScrollingSpeed( TMPXKeyStatus aKeyStatus )

    {

    MPX_FUNC( "CMPXLbxExtendedFeatures::UpdateScrollingSpeed" );

    TInt rate = 0;

    TInt repeatInitDelay = 0;

    TBool updated = EFalse;

    switch ( iScrollingState )

        {

        case EMPXScrolling1stSpeed:

            {

            MPX_DEBUG1( ">>>CMPXLbxExtendedFeatures::UpdateScrollingSpeed rate changed: first speed" );

            repeatInitDelay = iFirstSpeed * KMPMicroSecPerMilliSec;

            rate = iFirstSpeed * KMPMicroSecPerMilliSec;

            updated = ETrue;

            iSkipPlaying = EFalse;